Unit Tests: eliminate stray SkDebugf()s.

tests/MathTest.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.
  */
 
 #include "SkColorPriv.h"
 #include "SkEndian.h"
 #include "SkFloatBits.h"
@@ skipping 34 matching lines @@
     return (float)(x + big) - big;
 }
 
 static float std_floor(float x) {
     return sk_float_floor(x);
 }
 
 static void test_floor_value(skiatest::Reporter* reporter, float value) {
     float fast = fast_floor(value);
     float std = std_floor(value);
-    REPORTER_ASSERT(reporter, std == fast);
-//    SkDebugf("value[%1.9f] std[%g] fast[%g] equal[%d]\n",
-//             value, std, fast, std == fast);
+    if (std != fast) {
+        ERRORF(reporter, "fast_floor(%.9g) == %.9g != %.9g == std_floor(%.9g)",
+               value, fast, std, value);
+    }
 }
 
 static void test_floor(skiatest::Reporter* reporter) {
     static const float gVals[] = {
         0, 1, 1.1f, 1.01f, 1.001f, 1.0001f, 1.00001f, 1.000001f, 1.0000001f
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gVals); ++i) {
         test_floor_value(reporter, gVals[i]);
 //        test_floor_value(reporter, -gVals[i]);
@@ skipping 75 matching lines @@
 //                int r0 = blend31_round(src, dst, a);
 //                int r0 = blend31_old(src, dst, a);
                 int r0 = blend31_slow(src, dst, a);
 
                 float f = float_blend(src, dst, a / 31.f);
                 int r1 = (int)f;
                 int r2 = SkScalarRoundToInt(f);
 
                 if (r0 != r1 && r0 != r2) {
                     SkDebugf("src:%d dst:%d a:%d result:%d float:%g\n",
-                                  src,   dst, a,        r0,      f);
+                                 src,   dst, a,        r0,      f);
                     failed += 1;
                 }
                 if (r0 > 255) {
                     death += 1;
                     SkDebugf("death src:%d dst:%d a:%d result:%d float:%g\n",
                                         src,   dst, a,        r0,      f);
                 }
             }
         }
     }
     SkDebugf("---- failed %d death %d\n", failed, death);
 }
 
 static void test_blend(skiatest::Reporter* reporter) {
     for (int src = 0; src <= 255; src++) {
         for (int dst = 0; dst <= 255; dst++) {
             for (int a = 0; a <= 255; a++) {
                 int r0 = SkAlphaBlend255(src, dst, a);
                 float f1 = float_blend(src, dst, a / 255.f);
                 int r1 = SkScalarRoundToInt(f1);
 
                 if (r0 != r1) {
                     float diff = sk_float_abs(f1 - r1);
                     diff = sk_float_abs(diff - 0.5f);
                     if (diff > (1 / 255.f)) {
-#ifdef SK_DEBUG
-                        SkDebugf("src:%d dst:%d a:%d result:%d float:%g\n",
-                                 src, dst, a, r0, f1);
-#endif
-                        REPORTER_ASSERT(reporter, false);
+                        ERRORF(reporter, "src:%d dst:%d a:%d "
+                               "result:%d float:%g\n", src, dst, a, r0, f1);
                     }
                 }
             }
         }
     }
 }
 
 static void check_length(skiatest::Reporter* reporter,
                          const SkPoint& p, SkScalar targetLen) {
     float x = SkScalarToFloat(p.fX);
@@ skipping 497 matching lines @@
     test_divmod<int16_t>(r);
 }
 
 DEF_TEST(divmod_s32, r) {
     test_divmod<int32_t>(r);
 }
 
 DEF_TEST(divmod_s64, r) {
     test_divmod<int64_t>(r);
 }