by hook or by crook, force gcc to return the value of SkPoint::length() to actually be a float

trunk/tests/PointTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 // Unit tests for src/core/SkPoint.cpp and its header
 
 #include "SkPoint.h"
@@ skipping 42 matching lines @@
 // Ugh. Windows compiler can dive into other .cpp files, and sometimes
 // notices that I will generate an overflow... which is exactly the point
 // of this test!
 //
 // To avoid this warning, I need to convince the compiler that I might not
 // use that big value, hence this hacky helper function: reporter is
 // ALWAYS non-null. (shhhhhh, don't tell the compiler that).
 template <typename T> T get_value(skiatest::Reporter* reporter, T value) {
     return reporter ? value : 0;
 }
 

[robertphillips, 2013/05/06 15:42:23]

propagate

+// On linux gcc, 32bit, we are seeing the compiler propogate up the value
+// of SkPoint::length() as a double (which we use sometimes to avoid overflow
+// during the computation), even though the signature says float (SkScalar).
+//

[robertphillips, 2013/05/06 15:42:23]

rm "must"?

+// force_as_float is must meant to capture our latest technique (horrible as
+// it is) to force the value to be a float, so we can test whether it was
+// finite or not.
+static float force_as_float(skiatest::Reporter* reporter, float value) {
+    uint32_t storage;
+    memcpy(&storage, &value, 4);
+    // even the pair of memcpy calls are not sufficient, since those seem to
+    // be no-op'd, so we add a runtime tests (just like get_value) to force
+    // the compiler to give us an actual float.
+    if (NULL == reporter) {
+        storage = ~storage;
+    }
+    memcpy(&value, &storage, 4);
+    return value;
+}
+
 // test that we handle very large values correctly. i.e. that we can
 // successfully normalize something whose mag overflows a float.
 static void test_overflow(skiatest::Reporter* reporter) {
     SkScalar bigFloat = get_value(reporter, SkFloatToScalar(3.4e38f));
     SkPoint pt = { bigFloat, bigFloat };
 
     SkScalar length = pt.length();
+    length = force_as_float(reporter, length);
+
     // expect this to be non-finite, but dump the results if not.
     if (SkScalarIsFinite(length)) {
         SkDebugf("length(%g, %g) == %g\n", pt.fX, pt.fY, length);
         REPORTER_ASSERT(reporter, !SkScalarIsFinite(length));
     }
 
     // this should succeed, even though we can't represent length
     REPORTER_ASSERT(reporter, pt.setLength(SK_Scalar1));
 
     // now that pt is normalized, we check its length
@@ skipping 29 matching lines @@
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         test_length(reporter, gRec[i].fX, gRec[i].fY, gRec[i].fLength);
     }
 
     test_underflow(reporter);
     test_overflow(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Point", PointTestClass, PointTest)