Give PictureTest more verbose error messages.

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
@@ skipping 398 matching lines @@
                                  const SkRect& subset) {
     for (int i = 0; i < count; ++i) {
         SkRect rect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY, w, h);
 
         if (SkRect::Intersects(subset, rect)) {
             result->append(analytic[i].count(), analytic[i].begin());
         }
     }
 }
 
-static const DrawBitmapProc gProcs[] = {
-        drawpaint_proc,
-        drawpoints_proc,
-        drawrect_proc,
-        drawoval_proc,
-        drawrrect_proc,
-        drawpath_proc,
-        drawbitmap_proc,
-        drawbitmap_withshader_proc,
-        drawsprite_proc,
+
+static const struct {
+    const DrawBitmapProc proc;
+    const char* const desc;
+} gProcs[] = {
+    {drawpaint_proc, "drawpaint"},
+    {drawpoints_proc, "drawpoints"},
+    {drawrect_proc, "drawrect"},
+    {drawoval_proc, "drawoval"},
+    {drawrrect_proc, "drawrrect"},
+    {drawpath_proc, "drawpath"},
+    {drawbitmap_proc, "drawbitmap"},
+    {drawbitmap_withshader_proc, "drawbitmap_withshader"},
+    {drawsprite_proc, "drawsprite"},
 #if 0
-        drawsprite_withshader_proc,
+    {drawsprite_withshader_proc, "drawsprite_withshader"},
 #endif
-        drawbitmaprect_proc,
-        drawbitmaprect_withshader_proc,
-        drawtext_proc,
-        drawpostext_proc,
-        drawtextonpath_proc,
-        drawverts_proc,
+    {drawbitmaprect_proc, "drawbitmaprect"},
+    {drawbitmaprect_withshader_proc, "drawbitmaprect_withshader"},
+    {drawtext_proc, "drawtext"},
+    {drawpostext_proc, "drawpostext"},
+    {drawtextonpath_proc, "drawtextonpath"},
+    {drawverts_proc, "drawverts"},
 };
 
 static void create_textures(SkBitmap* bm, SkPixelRef** refs, int num, int w, int h) {
     // Our convention is that the color components contain an encoding of
     // the index of their corresponding bitmap/pixelref. (0,0,0,0) is
     // reserved for the background
     for (int i = 0; i < num; ++i) {
         make_bm(&bm[i], w, h,
                 SkColorSetARGB(0xFF,
                                gColorScale*i+gColorOffset,
@@ skipping 22 matching lines @@
     SkTDArray<SkPixelRef*> analytic[N];
 
     const SkPoint pos[N] = {
         { 0, 0 }, { W, 0 }, { 0, H }, { W, H }
     };
 
     create_textures(bm, refs, N, IW, IH);
 
     SkRandom rand;
     for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) {
-        SkAutoTUnref<SkPicture> pic(record_bitmaps(bm, pos, analytic, N, gProcs[k]));
+        SkAutoTUnref<SkPicture> pic(
+            record_bitmaps(bm, pos, analytic, N, gProcs[k].proc));
 
         REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0);
         // quick check for a small piece of each quadrant, which should just
         // contain 1 or 2 bitmaps.
         for (size_t  i = 0; i < SK_ARRAY_COUNT(pos); ++i) {
             SkRect r;
             r.set(2, 2, W - 2, H - 2);
             r.offset(pos[i].fX, pos[i].fY);
             SkAutoDataUnref data(SkPictureUtils::GatherPixelRefs(pic, r));
-            REPORTER_ASSERT(reporter, data);
-            if (data) {
-                SkPixelRef** gatheredRefs = (SkPixelRef**)data->data();
-                int count = static_cast<int>(data->size() / sizeof(SkPixelRef*));
-                REPORTER_ASSERT(reporter, 1 == count || 2 == count);
-                if (1 == count) {
-                    REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]);
-                } else if (2 == count) {
-                    REPORTER_ASSERT(reporter,
-                        (gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) ||
-                        (gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N]));
-                }
+            if (!data) {
+                ERRORF(reporter, "SkPictureUtils::GatherPixelRefs returned "
+                       "NULL for %s.", gProcs[k].desc);
+                continue;
+            }
+            SkPixelRef** gatheredRefs = (SkPixelRef**)data->data();
+            int count = static_cast<int>(data->size() / sizeof(SkPixelRef*));
+            REPORTER_ASSERT(reporter, 1 == count || 2 == count);
+            if (1 == count) {
+                REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]);
+            } else if (2 == count) {
+                REPORTER_ASSERT(reporter,
+                    (gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) ||
+                    (gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N]));
             }
         }
 
         SkBitmap image;
         draw(pic, 2*IW, 2*IH, &image);
 
         // Test a bunch of random (mostly) rects, and compare the gather results
         // with a deduced list of refs by looking at the colors drawn.
         for (int j = 0; j < 100; ++j) {
             SkRect r;
             rand_rect(&r, rand, 2*W, 2*H);
 
             SkTDArray<SkPixelRef*> fromImage;
             gather_from_image(image, refs, N, &fromImage, r);
 
             SkTDArray<SkPixelRef*> fromAnalytic;
             gather_from_analytic(pos, W, H, analytic, N, &fromAnalytic, r);
 
             SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
             size_t dataSize = data ? data->size() : 0;
             int gatherCount = static_cast<int>(dataSize / sizeof(SkPixelRef*));
             SkASSERT(gatherCount * sizeof(SkPixelRef*) == dataSize);
             SkPixelRef** gatherRefs = data ? (SkPixelRef**)(data->data()) : NULL;
             SkAutoDataUnref adu(data);
 
             // Everything that we saw drawn should appear in the analytic list
             // but the analytic list may contain some pixelRefs that were not
             // seen in the image (e.g., A8 textures used as masks)
             for (int i = 0; i < fromImage.count(); ++i) {
-                REPORTER_ASSERT(reporter, -1 != fromAnalytic.find(fromImage[i]));
+                if (-1 == fromAnalytic.find(fromImage[i])) {
+                    ERRORF(reporter, "PixelRef missing %d %s",
+                           i, gProcs[k].desc);
+                }
             }
 
             /*
              *  GatherPixelRefs is conservative, so it can return more bitmaps
              *  than are strictly required. Thus our check here is only that
              *  Gather didn't miss any that we actually needed. Even that isn't
              *  a strict requirement on Gather, which is meant to be quick and
              *  only mostly-correct, but at the moment this test should work.
              */
             for (int i = 0; i < fromAnalytic.count(); ++i) {
                 bool found = find(gatherRefs, fromAnalytic[i], gatherCount);
-                REPORTER_ASSERT(reporter, found);
+                if (!found) {
+                    ERRORF(reporter, "PixelRef missing %d %s",
+                           i, gProcs[k].desc);
+                }
 #if 0
                 // enable this block of code to debug failures, as it will rerun
                 // the case that failed.
                 if (!found) {
                     SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
                     size_t dataSize = data ? data->size() : 0;
                 }
 #endif
             }
         }
@@ skipping 12 matching lines @@
     SkTDArray<SkPixelRef*> analytic[N];
 
     const SkPoint pos[N] = {
         { 0, 0 }, { W, 0 }, { 0, H }, { W, H }
     };
 
     create_textures(bm, refs, N, IW, IH);
 
     SkRandom rand;
     for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) {
-        SkAutoTUnref<SkPicture> pic(record_bitmaps(bm, pos, analytic, N, gProcs[k]));
+        SkAutoTUnref<SkPicture> pic(
+            record_bitmaps(bm, pos, analytic, N, gProcs[k].proc));
 
         REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0);
 
         SkAutoTUnref<SkPictureUtils::SkPixelRefContainer> prCont(
                                 new SkPictureUtils::SkPixelRefsAndRectsList);
 
         SkPictureUtils::GatherPixelRefsAndRects(pic, prCont);
 
         // quick check for a small piece of each quadrant, which should just
         // contain 1 or 2 bitmaps.
@@ skipping 535 matching lines @@
     picture.endRecording();
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }