Add tests for SkCanvas::drawImage[Rect]()

tests/CanvasTest.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.
  */
 
 /*  Description:
  *      This test defines a series of elementatry test steps that perform
  *      a single or a small group of canvas API calls. Each test step is
@@ skipping 134 matching lines @@
     "test step %s, SkProxyCanvas indirect canvas state consistency";
 static const char* const kNWayStateAssertMessageFormat =
     "test step %s, SkNWayCanvas state consistency";
 static const char* const kNWayIndirect1StateAssertMessageFormat =
     "test step %s, SkNWayCanvas indirect canvas 1 state consistency";
 static const char* const kNWayIndirect2StateAssertMessageFormat =
     "test step %s, SkNWayCanvas indirect canvas 2 state consistency";
 static const char* const kPdfAssertMessageFormat =
     "PDF sanity check failed %s";
 
-static void createBitmap(SkBitmap* bm, SkColor color) {
+static void create_bitmap(SkBitmap* bm, SkColor color) {
     bm->allocN32Pixels(kWidth, kHeight);
     bm->eraseColor(color);
 }
 
-static SkSurface* createSurface(SkColor color) {
+static SkSurface* create_surface(SkColor color) {
     SkSurface* surface = SkSurface::NewRasterPMColor(kWidth, kHeight);
     surface->getCanvas()->clear(color);
     return surface;
 }
 
 class CanvasTestStep;
 static SkTDArray<CanvasTestStep*>& testStepArray() {
     static SkTDArray<CanvasTestStep*> theTests;
     return theTests;
 }
@@ skipping 71 matching lines @@
 const SkColor kTestColor = 0x01020304;
 const SkPaint kTestPaint;
 const SkPoint kTestPoints[3] = {
     {SkIntToScalar(0), SkIntToScalar(0)},
     {SkIntToScalar(2), SkIntToScalar(1)},
     {SkIntToScalar(0), SkIntToScalar(2)}
 };
 const size_t kTestPointCount = 3;
 static SkBitmap testBitmap() {
     SkBitmap bitmap;
-    createBitmap(&bitmap, 0x05060708);
+    create_bitmap(&bitmap, 0x05060708);
     return bitmap;
 }
 SkBitmap kTestBitmap; // cannot be created during static init
 SkString kTestText("Hello World");
 SkPoint kTestPoints2[] = {
   { SkIntToScalar(0), SkIntToScalar(1) },
   { SkIntToScalar(1), SkIntToScalar(1) },
   { SkIntToScalar(2), SkIntToScalar(1) },
   { SkIntToScalar(3), SkIntToScalar(1) },
   { SkIntToScalar(4), SkIntToScalar(1) },
   { SkIntToScalar(5), SkIntToScalar(1) },
   { SkIntToScalar(6), SkIntToScalar(1) },
   { SkIntToScalar(7), SkIntToScalar(1) },
   { SkIntToScalar(8), SkIntToScalar(1) },
   { SkIntToScalar(9), SkIntToScalar(1) },
   { SkIntToScalar(10), SkIntToScalar(1) },
 };
-
+SkSurface* kTestSurface;
+SkImage* kTestImage;

[reed1, 2014/09/30 13:44:55]

ugh -- can we find a way to not use these globals?

[Rémi Piotaix, 2014/09/30 15:44:50]

Seems that we can't.
The use of the same bitmap/image/surface is needed by this test to test
consistency between deterrent canvas types or sth. like that.

 
 ///////////////////////////////////////////////////////////////////////////////
 // Macros for defining test steps
 
 #define TEST_STEP(NAME, FUNCTION)                                       \
 class NAME##_TestStep : public CanvasTestStep{                          \
 public:                                                                 \
     virtual void draw(SkCanvas* canvas, skiatest::Reporter* reporter) { \
         FUNCTION (canvas, reporter, this);                              \
     }                                                                   \
     virtual const char* name() const {return #NAME ;}                   \
 };                                                                      \
 static NAME##_TestStep NAME##_TestStepInstance;
 
-#define TEST_STEP_NO_PDF(NAME, FUNCTION)                                       \
+#define TEST_STEP_NO_PDF(NAME, FUNCTION)                                \
 class NAME##_TestStep : public CanvasTestStep{                          \
 public:                                                                 \
     NAME##_TestStep() : CanvasTestStep(false) {}                        \
     virtual void draw(SkCanvas* canvas, skiatest::Reporter* reporter) { \
         FUNCTION (canvas, reporter, this);                              \
     }                                                                   \
     virtual const char* name() const {return #NAME ;}                   \
 };                                                                      \
 static NAME##_TestStep NAME##_TestStepInstance;
 
@@ skipping 60 matching lines @@
 SIMPLE_TEST_STEP(DrawPosText, drawPosText(kTestText.c_str(),
     kTestText.size(), kTestPoints2, kTestPaint));
 SIMPLE_TEST_STEP(DrawTextOnPath, drawTextOnPath(kTestText.c_str(),
     kTestText.size(), kTestPath, NULL, kTestPaint));
 SIMPLE_TEST_STEP(DrawTextOnPathMatrix, drawTextOnPath(kTestText.c_str(),
     kTestText.size(), kTestPath, &kTestMatrix, kTestPaint));
 SIMPLE_TEST_STEP(DrawData, drawData(kTestText.c_str(), kTestText.size()));
 SIMPLE_TEST_STEP(BeginGroup, beginCommentGroup(kTestText.c_str()));
 SIMPLE_TEST_STEP(AddComment, addComment(kTestText.c_str(), kTestText.c_str()));
 SIMPLE_TEST_STEP(EndGroup, endCommentGroup());
+SIMPLE_TEST_STEP(DrawImage, drawImage(kTestImage, 0, 0));
+SIMPLE_TEST_STEP(DrawImageRect, drawImageRect(kTestImage, 0, SkRect::MakeWH(kWidth, kHeight)));
 
 ///////////////////////////////////////////////////////////////////////////////
 // Complex test steps
 
 static void SaveMatrixClipStep(SkCanvas* canvas,
                                skiatest::Reporter* reporter,
                                CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->save();
     canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
@@ skipping 80 matching lines @@
     canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
                          NULL, NULL, NULL, 0, paint);
 }
 // NYI: issue 240.
 TEST_STEP_NO_PDF(DrawVerticesShader, DrawVerticesShaderTestStep);
 
 static void DrawPictureTestStep(SkCanvas* canvas,
                                 skiatest::Reporter*,
                                 CanvasTestStep*) {
     SkPictureRecorder recorder;
-    SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight), 
+    SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
                                                    NULL, 0);
     testCanvas->scale(SkIntToScalar(2), SkIntToScalar(1));
     testCanvas->clipRect(kTestRect);
     testCanvas->drawRect(kTestRect, kTestPaint);
     SkAutoTUnref<SkPicture> testPicture(recorder.endRecording());
 
     canvas->drawPicture(testPicture);
 }
 TEST_STEP(DrawPicture, DrawPictureTestStep);
 
@@ skipping 205 matching lines @@
 public:
 
     static void TestPictureFlattenedObjectReuse(skiatest::Reporter* reporter,
                                                 CanvasTestStep* testStep,
                                                 uint32_t recordFlags) {
         // Verify that when a test step is executed twice, no extra resources
         // are flattened during the second execution
         testStep->setAssertMessageFormat(kPictureDrawAssertMessageFormat);
         SkPictureRecorder referenceRecorder;
         SkCanvas* referenceCanvas =
-            referenceRecorder.DEPRECATED_beginRecording(SkIntToScalar(kWidth), 
-                                                        SkIntToScalar(kHeight), 
+            referenceRecorder.DEPRECATED_beginRecording(SkIntToScalar(kWidth),
+                                                        SkIntToScalar(kHeight),
                                                         NULL, recordFlags);
         testStep->draw(referenceCanvas, reporter);
 
         SkPictureRecorder testRecorder;
         SkCanvas* testCanvas =
-            testRecorder.DEPRECATED_beginRecording(SkIntToScalar(kWidth), 
-                                                   SkIntToScalar(kHeight), 
+            testRecorder.DEPRECATED_beginRecording(SkIntToScalar(kWidth),
+                                                   SkIntToScalar(kHeight),
                                                    NULL, recordFlags);
         testStep->draw(testCanvas, reporter);
         testStep->setAssertMessageFormat(kPictureSecondDrawAssertMessageFormat);
         testStep->draw(testCanvas, reporter);
 
         SkPictureRecord* referenceRecord = static_cast<SkPictureRecord*>(referenceCanvas);
         SkPictureRecord* testRecord = static_cast<SkPictureRecord*>(testCanvas);
         testStep->setAssertMessageFormat(kPictureResourceReuseMessageFormat);
         AssertFlattenedObjectsEqual(referenceRecord, testRecord,
                                     reporter, testStep);
@@ skipping 15 matching lines @@
 
 // The following class groups static functions that need to access
 // the privates members of SkDeferredCanvas
 class SkDeferredCanvasTester {
 public:
     static void TestDeferredCanvasStateConsistency(
         skiatest::Reporter* reporter,
         CanvasTestStep* testStep,
         const SkCanvas& referenceCanvas, bool silent) {
 
-        SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
+        SkAutoTUnref<SkSurface> surface(create_surface(0xFFFFFFFF));
         SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(surface.get()));
 
         testStep->setAssertMessageFormat(kDeferredDrawAssertMessageFormat);
         testStep->draw(deferredCanvas, reporter);
         testStep->setAssertMessageFormat(kDeferredPreFlushAssertMessageFormat);
         AssertCanvasStatesEqual(reporter, deferredCanvas, &referenceCanvas,
             testStep);
 
         if (silent) {
             deferredCanvas->silentFlush();
@@ skipping 21 matching lines @@
     }
 };
 
 // unused
 static void TestProxyCanvasStateConsistency(
     skiatest::Reporter* reporter,
     CanvasTestStep* testStep,
     const SkCanvas& referenceCanvas) {
 
     SkBitmap indirectStore;
-    createBitmap(&indirectStore, 0xFFFFFFFF);
+    create_bitmap(&indirectStore, 0xFFFFFFFF);
     SkCanvas indirectCanvas(indirectStore);
     SkProxyCanvas proxyCanvas(&indirectCanvas);
     testStep->setAssertMessageFormat(kProxyDrawAssertMessageFormat);
     testStep->draw(&proxyCanvas, reporter);
     // Verify that the SkProxyCanvas reports consitent state
     testStep->setAssertMessageFormat(kProxyStateAssertMessageFormat);
     AssertCanvasStatesEqual(reporter, &proxyCanvas, &referenceCanvas,
         testStep);
     // Verify that the indirect canvas reports consitent state
     testStep->setAssertMessageFormat(kProxyIndirectStateAssertMessageFormat);
     AssertCanvasStatesEqual(reporter, &indirectCanvas, &referenceCanvas,
         testStep);
 }
 
 // unused
 static void TestNWayCanvasStateConsistency(
     skiatest::Reporter* reporter,
     CanvasTestStep* testStep,
     const SkCanvas& referenceCanvas) {
 
     SkBitmap indirectStore1;
-    createBitmap(&indirectStore1, 0xFFFFFFFF);
+    create_bitmap(&indirectStore1, 0xFFFFFFFF);
     SkCanvas indirectCanvas1(indirectStore1);
 
     SkBitmap indirectStore2;
-    createBitmap(&indirectStore2, 0xFFFFFFFF);
+    create_bitmap(&indirectStore2, 0xFFFFFFFF);
     SkCanvas indirectCanvas2(indirectStore2);
 
     SkISize canvasSize = referenceCanvas.getDeviceSize();
     SkNWayCanvas nWayCanvas(canvasSize.width(), canvasSize.height());
     nWayCanvas.addCanvas(&indirectCanvas1);
     nWayCanvas.addCanvas(&indirectCanvas2);
 
     testStep->setAssertMessageFormat(kNWayDrawAssertMessageFormat);
     testStep->draw(&nWayCanvas, reporter);
     // Verify that the SkProxyCanvas reports consitent state
@@ skipping 11 matching lines @@
 
 /*
  * This sub-test verifies that the test step passes when executed
  * with SkCanvas and with classes derrived from SkCanvas. It also verifies
  * that the all canvas derivatives report the same state as an SkCanvas
  * after having executed the test step.
  */
 static void TestOverrideStateConsistency(skiatest::Reporter* reporter,
                                          CanvasTestStep* testStep) {
     SkBitmap referenceStore;
-    createBitmap(&referenceStore, 0xFFFFFFFF);
+    create_bitmap(&referenceStore, 0xFFFFFFFF);
     SkCanvas referenceCanvas(referenceStore);
     testStep->setAssertMessageFormat(kCanvasDrawAssertMessageFormat);
     testStep->draw(&referenceCanvas, reporter);
 
     SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, testStep, referenceCanvas, false);
 
     SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, testStep, referenceCanvas, true);
 
     // The following test code is disabled because SkProxyCanvas is
     // missing a lot of virtual overrides on get* methods, which are used
@@ skipping 51 matching lines @@
     info = SkImageInfo::MakeN32Premul(0, 0);
     canvas = SkCanvas::NewRaster(info);
     REPORTER_ASSERT(reporter, canvas);
     SkDELETE(canvas);
 }
 
 DEF_TEST(Canvas, reporter) {
     // Init global here because bitmap pixels cannot be alocated during
     // static initialization
     kTestBitmap = testBitmap();
+    kTestSurface = create_surface(SK_ColorGREEN);
+    kTestImage = kTestSurface->newImageSnapshot();

[Justin Novosad, 2014/09/30 18:06:46]

I guess these globals could be packaged into a local struct that gets passed to
the test functions

[Rémi Piotaix, 2014/10/02 18:45:24]

Done here: https://codereview.chromium.org/617093004/

 
     for (int testStep = 0; testStep < testStepArray().count(); testStep++) {
         TestOverrideStateConsistency(reporter, testStepArray()[testStep]);
         SkPictureTester::TestPictureFlattenedObjectReuse(reporter,
             testStepArray()[testStep], 0);
         if (testStepArray()[testStep]->enablePdfTesting()) {
             TestPdfDevice(reporter, testStepArray()[testStep]);
         }
     }
 
     // Explicitly call reset(), so we don't leak the pixels (since kTestBitmap is a global)
     kTestBitmap.reset();
+    kTestSurface->unref();
+    kTestImage->unref();
 
     test_newraster(reporter);
 }