Add REPORTF test macro.

tests/BitmapCopyTest.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 "Test.h"
 #include "TestClassDef.h"
 #include "SkBitmap.h"
 #include "SkRect.h"
 
 static const char* boolStr(bool value) {
     return value ? "true" : "false";
 }
 
 // these are in the same order as the SkBitmap::Config enum
 static const char* gConfigName[] = {
     "None", "A8", "Index8", "565", "4444", "8888"
 };
 
 static void report_opaqueness(skiatest::Reporter* reporter, const SkBitmap& src,
                               const SkBitmap& dst) {
-    SkString str;
-    str.printf("src %s opaque:%d, dst %s opaque:%d",
-               gConfigName[src.config()], src.isOpaque(),
-               gConfigName[dst.config()], dst.isOpaque());
-    reporter->reportFailed(str);
+    ERRORF(reporter, "src %s opaque:%d, dst %s opaque:%d",
+           gConfigName[src.config()], src.isOpaque(),
+           gConfigName[dst.config()], dst.isOpaque());
 }
 
 static bool canHaveAlpha(SkBitmap::Config config) {
     return config != SkBitmap::kRGB_565_Config;
 }
 
 // copyTo() should preserve isOpaque when it makes sense
 static void test_isOpaque(skiatest::Reporter* reporter,
                           const SkBitmap& srcOpaque, const SkBitmap& srcPremul,
                           SkBitmap::Config dstConfig) {
@@ skipping 146 matching lines @@
     bool success = true;
 
     // Confirm all pixels in the list match.
     for (int i = 0; i < coords.length; ++i) {
         success = success &&
                   (getPixel(coords[i]->fX, coords[i]->fY, bm1) ==
                    getPixel(coords[i]->fX, coords[i]->fY, bm2));
     }
 
     if (!success) {
-        SkString str;
-        str.printf("%s [config = %s]",
-                   msg, getSkConfigName(bm1));
-        reporter->reportFailed(str);
+        ERRORF(reporter, "%s [config = %s]", msg, getSkConfigName(bm1));
     }
 }
 
 // Writes unique pixel values at locations specified by coords.
 static void writeCoordPixels(SkBitmap& bm, const Coordinates& coords) {
     for (int i = 0; i < coords.length; ++i)
         setPixel(coords[i]->fX, coords[i]->fY, i, bm);
 }
 
 DEF_TEST(BitmapCopy, reporter) {
@@ skipping 31 matching lines @@
                 srcPremul.allocPixels(ctPremul);
                 SkSafeUnref(ctOpaque);
                 SkSafeUnref(ctPremul);
             }
             init_src(srcOpaque);
             init_src(srcPremul);
 
             bool success = srcPremul.copyTo(&dst, gPairs[j].fConfig);
             bool expected = gPairs[i].fValid[j] != '0';
             if (success != expected) {
-                SkString str;
-                str.printf("SkBitmap::copyTo from %s to %s. expected %s returned %s",
-                           gConfigName[i], gConfigName[j], boolStr(expected),
-                           boolStr(success));
-                reporter->reportFailed(str);
+                ERRORF(reporter, "SkBitmap::copyTo from %s to %s. expected %s "
+                       "returned %s", gConfigName[i], gConfigName[j],
+                       boolStr(expected), boolStr(success));
             }
 
             bool canSucceed = srcPremul.canCopyTo(gPairs[j].fConfig);
             if (success != canSucceed) {
-                SkString str;
-                str.printf("SkBitmap::copyTo from %s to %s. returned %s canCopyTo %s",
-                           gConfigName[i], gConfigName[j], boolStr(success),
-                           boolStr(canSucceed));
-                reporter->reportFailed(str);
+                ERRORF(reporter, "SkBitmap::copyTo from %s to %s. returned %s "
+                       "canCopyTo %s", gConfigName[i], gConfigName[j],
+                       boolStr(success), boolStr(canSucceed));
             }
 
             if (success) {
                 REPORTER_ASSERT(reporter, srcPremul.width() == dst.width());
                 REPORTER_ASSERT(reporter, srcPremul.height() == dst.height());
                 REPORTER_ASSERT(reporter, dst.config() == gPairs[j].fConfig);
                 test_isOpaque(reporter, srcOpaque, srcPremul, dst.config());
                 if (srcPremul.config() == dst.config()) {
                     SkAutoLockPixels srcLock(srcPremul);
                     SkAutoLockPixels dstLock(dst);
@@ skipping 64 matching lines @@
             //       Please take care if modifying.
 
             // Tests for getSafeSize64().
             // Test with a very large configuration without pixel buffer
             // attached.
             SkBitmap tstSafeSize;
             tstSafeSize.setConfig(gPairs[i].fConfig, 100000000U,
                                   100000000U);
             int64_t safeSize = tstSafeSize.computeSafeSize64();
             if (safeSize < 0) {
-                SkString str;
-                str.printf("getSafeSize64() negative: %s",
-                    getSkConfigName(tstSafeSize));
-                reporter->reportFailed(str);
+                ERRORF(reporter, "getSafeSize64() negative: %s",
+                       getSkConfigName(tstSafeSize));
             }
             bool sizeFail = false;
             // Compare against hand-computed values.
             switch (gPairs[i].fConfig) {
                 case SkBitmap::kNo_Config:
                     break;
 
                 case SkBitmap::kA8_Config:
                 case SkBitmap::kIndex8_Config:
                     if (safeSize != 0x2386F26FC10000LL) {
@@ skipping 11 matching lines @@
                 case SkBitmap::kARGB_8888_Config:
                     if (safeSize != 0x8E1BC9BF040000LL) {
                         sizeFail = true;
                     }
                     break;
 
                 default:
                     break;
             }
             if (sizeFail) {
-                SkString str;
-                str.printf("computeSafeSize64() wrong size: %s",
-                    getSkConfigName(tstSafeSize));
-                reporter->reportFailed(str);
+                ERRORF(reporter, "computeSafeSize64() wrong size: %s",
+                       getSkConfigName(tstSafeSize));
             }
 
             int subW = 2;
             int subH = 2;
 
             // Create bitmap to act as source for copies and subsets.
             SkBitmap src, subset;
             SkColorTable* ct = NULL;
             if (isExtracted[copyCase]) { // A larger image to extract from.
                 src.setConfig(gPairs[i].fConfig, 2 * subW + 1, subH);
@@ skipping 147 matching lines @@
                 // for the transfer.
                 REPORTER_ASSERT(reporter,
                     subset.copyPixelsFrom(buf, 1, subset.rowBytes()) ==
                         false);
 
 #endif
             }
         } // for (size_t copyCase ...
     }
 }