blob: 646d5150e939fb99559bfc3d4ef83bcd0d2ffc0d [file] [log] [blame]
reed@google.com37f3ae02011-11-28 16:06:04 +00001/*
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +00002 * Copyright 2012 Google Inc.
reed@google.com37f3ae02011-11-28 16:06:04 +00003 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +00007
8/* Description:
9 * This test defines a series of elementatry test steps that perform
10 * a single or a small group of canvas API calls. Each test step is
11 * used in several test cases that verify that different types of SkCanvas
12 * flavors and derivatives pass it and yield consistent behavior. The
13 * test cases analyse results that are queryable through the API. They do
14 * not look at rendering results.
15 *
16 * Adding test stepss:
17 * The general pattern for creating a new test step is to write a test
18 * function of the form:
19 *
rmistry@google.comd6176b02012-08-23 18:14:13 +000020 * static void MyTestStepFunction(SkCanvas* canvas,
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +000021 * skiatest::Reporter* reporter,
22 * CanvasTestStep* testStep)
23 * {
24 * canvas->someCanvasAPImethod();
25 * (...)
26 * REPORTER_ASSERT_MESSAGE(reporter, (...), \
27 * testStep->assertMessage());
28 * }
29 *
30 * The definition of the test step function should be followed by an
31 * invocation of the TEST_STEP macro, which generates a class and
32 * instance for the test step:
33 *
34 * TEST_STEP(MyTestStep, MyTestStepFunction)
35 *
36 * There are also short hand macros for defining simple test steps
37 * in a single line of code. A simple test step is a one that is made
38 * of a single canvas API call.
39 *
40 * SIMPLE_TEST_STEP(MytestStep, someCanvasAPIMethod());
41 *
42 * There is another macro called SIMPLE_TEST_STEP_WITH_ASSERT that
43 * works the same way as SIMPLE_TEST_STEP, and additionally verifies
44 * that the invoked method returns a non-zero value.
45 */
reed@google.com37f3ae02011-11-28 16:06:04 +000046#include "SkBitmap.h"
47#include "SkCanvas.h"
reed687fa1c2015-04-07 08:00:56 -070048#include "SkClipStack.h"
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +000049#include "SkDeferredCanvas.h"
50#include "SkDevice.h"
halcanary3d32d502015-03-01 06:55:20 -080051#include "SkDocument.h"
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +000052#include "SkMatrix.h"
53#include "SkNWayCanvas.h"
54#include "SkPaint.h"
55#include "SkPath.h"
56#include "SkPicture.h"
57#include "SkPictureRecord.h"
robertphillips@google.com770963f2014-04-18 18:04:41 +000058#include "SkPictureRecorder.h"
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +000059#include "SkRect.h"
60#include "SkRegion.h"
61#include "SkShader.h"
62#include "SkStream.h"
reed@google.com28183b42014-02-04 15:34:10 +000063#include "SkSurface.h"
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +000064#include "SkTDArray.h"
65#include "Test.h"
reed@google.com37f3ae02011-11-28 16:06:04 +000066
piotaixrf05f5a72014-10-03 13:26:55 -070067static const int kWidth = 2, kHeight = 2;
68
69static void createBitmap(SkBitmap* bm, SkColor color) {
70 bm->allocN32Pixels(kWidth, kHeight);
71 bm->eraseColor(color);
72}
73
74static SkSurface* createSurface(SkColor color) {
reed3054be12014-12-10 07:24:28 -080075 SkSurface* surface = SkSurface::NewRasterN32Premul(kWidth, kHeight);
piotaixrf05f5a72014-10-03 13:26:55 -070076 surface->getCanvas()->clear(color);
77 return surface;
78}
79
80///////////////////////////////////////////////////////////////////////////////
81// Constants used by test steps
82const SkPoint kTestPoints[] = {
83 {SkIntToScalar(0), SkIntToScalar(0)},
84 {SkIntToScalar(2), SkIntToScalar(1)},
85 {SkIntToScalar(0), SkIntToScalar(2)}
86};
87const SkPoint kTestPoints2[] = {
88 { SkIntToScalar(0), SkIntToScalar(1) },
89 { SkIntToScalar(1), SkIntToScalar(1) },
90 { SkIntToScalar(2), SkIntToScalar(1) },
91 { SkIntToScalar(3), SkIntToScalar(1) },
92 { SkIntToScalar(4), SkIntToScalar(1) },
93 { SkIntToScalar(5), SkIntToScalar(1) },
94 { SkIntToScalar(6), SkIntToScalar(1) },
95 { SkIntToScalar(7), SkIntToScalar(1) },
96 { SkIntToScalar(8), SkIntToScalar(1) },
97 { SkIntToScalar(9), SkIntToScalar(1) },
98 { SkIntToScalar(10), SkIntToScalar(1) }
99};
100
101struct TestData {
102public:
103 TestData()
104 : fRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
105 SkIntToScalar(2), SkIntToScalar(1)))
106 , fMatrix(TestMatrix())
107 , fPath(TestPath())
108 , fNearlyZeroLengthPath(TestNearlyZeroLengthPath())
109 , fIRect(SkIRect::MakeXYWH(0, 0, 2, 1))
110 , fRegion(TestRegion())
111 , fColor(0x01020304)
112 , fPoints(kTestPoints)
113 , fPointCount(3)
114 , fWidth(2)
115 , fHeight(2)
116 , fText("Hello World")
117 , fPoints2(kTestPoints2)
118 , fBitmap(TestBitmap())
119 { }
120
121 SkRect fRect;
122 SkMatrix fMatrix;;
123 SkPath fPath;
124 SkPath fNearlyZeroLengthPath;
125 SkIRect fIRect;
126 SkRegion fRegion;
127 SkColor fColor;
128 SkPaint fPaint;
129 const SkPoint* fPoints;
130 size_t fPointCount;
131 int fWidth;
132 int fHeight;
133 SkString fText;
134 const SkPoint* fPoints2;
135 SkBitmap fBitmap;
136
137private:
138 static SkMatrix TestMatrix() {
139 SkMatrix matrix;
140 matrix.reset();
141 matrix.setScale(SkIntToScalar(2), SkIntToScalar(3));
142
143 return matrix;
144 }
145 static SkPath TestPath() {
146 SkPath path;
147 path.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
148 SkIntToScalar(2), SkIntToScalar(1)));
149 return path;
150 }
151 static SkPath TestNearlyZeroLengthPath() {
152 SkPath path;
153 SkPoint pt1 = { 0, 0 };
154 SkPoint pt2 = { 0, SK_ScalarNearlyZero };
155 SkPoint pt3 = { SkIntToScalar(1), 0 };
156 SkPoint pt4 = { SkIntToScalar(1), SK_ScalarNearlyZero/2 };
157 path.moveTo(pt1);
158 path.lineTo(pt2);
159 path.lineTo(pt3);
160 path.lineTo(pt4);
161 return path;
162 }
163 static SkRegion TestRegion() {
164 SkRegion region;
165 SkIRect rect = SkIRect::MakeXYWH(0, 0, 2, 1);
166 region.setRect(rect);
167 return region;
168 }
169 static SkBitmap TestBitmap() {
170 SkBitmap bitmap;
171 createBitmap(&bitmap, 0x05060708);
172 return bitmap;
173 }
174};
175
commit-bot@chromium.org5c70cdc2014-03-08 03:57:19 +0000176static bool equal_clips(const SkCanvas& a, const SkCanvas& b) {
177 if (a.isClipEmpty()) {
178 return b.isClipEmpty();
179 }
180 if (!a.isClipRect()) {
181 // this is liberally true, since we don't expose a way to know this exactly (for non-rects)
182 return !b.isClipRect();
183 }
184 SkIRect ar, br;
185 a.getClipDeviceBounds(&ar);
186 b.getClipDeviceBounds(&br);
187 return ar == br;
188}
189
reed@google.com90c07ea2012-04-13 13:50:27 +0000190class Canvas2CanvasClipVisitor : public SkCanvas::ClipVisitor {
191public:
192 Canvas2CanvasClipVisitor(SkCanvas* target) : fTarget(target) {}
193
mtklein36352bf2015-03-25 18:17:31 -0700194 void clipRect(const SkRect& r, SkRegion::Op op, bool aa) override {
reed@google.com90c07ea2012-04-13 13:50:27 +0000195 fTarget->clipRect(r, op, aa);
196 }
mtklein36352bf2015-03-25 18:17:31 -0700197 void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) override {
commit-bot@chromium.orge5b2af92014-02-16 13:25:24 +0000198 fTarget->clipRRect(r, op, aa);
199 }
mtklein36352bf2015-03-25 18:17:31 -0700200 void clipPath(const SkPath& p, SkRegion::Op op, bool aa) override {
reed@google.com90c07ea2012-04-13 13:50:27 +0000201 fTarget->clipPath(p, op, aa);
202 }
203
204private:
205 SkCanvas* fTarget;
206};
207
208static void test_clipVisitor(skiatest::Reporter* reporter, SkCanvas* canvas) {
209 SkISize size = canvas->getDeviceSize();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000210
reed@google.com90c07ea2012-04-13 13:50:27 +0000211 SkBitmap bm;
commit-bot@chromium.orga3264e52014-05-30 13:26:10 +0000212 bm.setInfo(SkImageInfo::MakeN32Premul(size.width(), size.height()));
reed@google.com90c07ea2012-04-13 13:50:27 +0000213 SkCanvas c(bm);
214
215 Canvas2CanvasClipVisitor visitor(&c);
216 canvas->replayClips(&visitor);
217
commit-bot@chromium.org5c70cdc2014-03-08 03:57:19 +0000218 REPORTER_ASSERT(reporter, equal_clips(c, *canvas));
reed@google.com90c07ea2012-04-13 13:50:27 +0000219}
220
reed687fa1c2015-04-07 08:00:56 -0700221static void test_clipstack(skiatest::Reporter* reporter) {
222 // The clipstack is refcounted, and needs to be able to out-live the canvas if a client has
223 // ref'd it.
224 const SkClipStack* cs = NULL;
225 {
226 SkCanvas canvas(10, 10);
227 cs = SkRef(canvas.getClipStack());
228 }
229 REPORTER_ASSERT(reporter, cs->unique());
230 cs->unref();
231}
232
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000233// Format strings that describe the test context. The %s token is where
234// the name of the test step is inserted. The context is required for
235// disambiguating the error in the case of failures that are reported in
236// functions that are called multiple times in different contexts (test
237// cases and test steps).
238static const char* const kDefaultAssertMessageFormat = "%s";
rmistry@google.comd6176b02012-08-23 18:14:13 +0000239static const char* const kCanvasDrawAssertMessageFormat =
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000240 "Drawing test step %s with SkCanvas";
rmistry@google.comd6176b02012-08-23 18:14:13 +0000241static const char* const kDeferredDrawAssertMessageFormat =
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000242 "Drawing test step %s with SkDeferredCanvas";
rmistry@google.comd6176b02012-08-23 18:14:13 +0000243static const char* const kNWayDrawAssertMessageFormat =
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000244 "Drawing test step %s with SkNWayCanvas";
rmistry@google.comd6176b02012-08-23 18:14:13 +0000245static const char* const kDeferredPreFlushAssertMessageFormat =
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000246 "test step %s, SkDeferredCanvas state consistency before flush";
junov@chromium.orgcff01c52012-07-18 21:50:26 +0000247static const char* const kDeferredPostFlushPlaybackAssertMessageFormat =
248 "test step %s, SkDeferredCanvas playback canvas state consistency after flush";
junov@chromium.orgfb103892012-09-20 19:35:43 +0000249static const char* const kDeferredPostSilentFlushPlaybackAssertMessageFormat =
250 "test step %s, SkDeferredCanvas playback canvas state consistency after silent flush";
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000251static const char* const kNWayStateAssertMessageFormat =
252 "test step %s, SkNWayCanvas state consistency";
253static const char* const kNWayIndirect1StateAssertMessageFormat =
254 "test step %s, SkNWayCanvas indirect canvas 1 state consistency";
255static const char* const kNWayIndirect2StateAssertMessageFormat =
256 "test step %s, SkNWayCanvas indirect canvas 2 state consistency";
edisonn@google.com77909122012-10-18 15:58:23 +0000257static const char* const kPdfAssertMessageFormat =
258 "PDF sanity check failed %s";
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000259
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000260class CanvasTestStep;
261static SkTDArray<CanvasTestStep*>& testStepArray() {
262 static SkTDArray<CanvasTestStep*> theTests;
263 return theTests;
264}
265
266class CanvasTestStep {
267public:
edisonn@google.com77909122012-10-18 15:58:23 +0000268 CanvasTestStep(bool fEnablePdfTesting = true) {
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000269 *testStepArray().append() = this;
270 fAssertMessageFormat = kDefaultAssertMessageFormat;
edisonn@google.com77909122012-10-18 15:58:23 +0000271 this->fEnablePdfTesting = fEnablePdfTesting;
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000272 }
djsollen@google.come63793a2012-03-21 15:39:03 +0000273 virtual ~CanvasTestStep() { }
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000274
piotaixrf05f5a72014-10-03 13:26:55 -0700275 virtual void draw(SkCanvas*, const TestData&, skiatest::Reporter*) = 0;
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000276 virtual const char* name() const = 0;
277
278 const char* assertMessage() {
279 fAssertMessage.printf(fAssertMessageFormat, name());
280 return fAssertMessage.c_str();
281 }
282
283 void setAssertMessageFormat(const char* format) {
284 fAssertMessageFormat = format;
285 }
286
edisonn@google.com77909122012-10-18 15:58:23 +0000287 bool enablePdfTesting() { return fEnablePdfTesting; }
288
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000289private:
290 SkString fAssertMessage;
291 const char* fAssertMessageFormat;
edisonn@google.com77909122012-10-18 15:58:23 +0000292 bool fEnablePdfTesting;
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000293};
294
295///////////////////////////////////////////////////////////////////////////////
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000296// Macros for defining test steps
297
298#define TEST_STEP(NAME, FUNCTION) \
299class NAME##_TestStep : public CanvasTestStep{ \
300public: \
piotaixrf05f5a72014-10-03 13:26:55 -0700301 virtual void draw(SkCanvas* canvas, const TestData& d, \
302 skiatest::Reporter* reporter) { \
303 FUNCTION (canvas, d, reporter, this); \
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000304 } \
305 virtual const char* name() const {return #NAME ;} \
306}; \
307static NAME##_TestStep NAME##_TestStepInstance;
308
piotaixrf05f5a72014-10-03 13:26:55 -0700309#define TEST_STEP_NO_PDF(NAME, FUNCTION) \
edisonn@google.com77909122012-10-18 15:58:23 +0000310class NAME##_TestStep : public CanvasTestStep{ \
311public: \
312 NAME##_TestStep() : CanvasTestStep(false) {} \
piotaixrf05f5a72014-10-03 13:26:55 -0700313 virtual void draw(SkCanvas* canvas, const TestData& d, \
314 skiatest::Reporter* reporter) { \
315 FUNCTION (canvas, d, reporter, this); \
edisonn@google.com77909122012-10-18 15:58:23 +0000316 } \
317 virtual const char* name() const {return #NAME ;} \
318}; \
319static NAME##_TestStep NAME##_TestStepInstance;
320
piotaixrf05f5a72014-10-03 13:26:55 -0700321#define SIMPLE_TEST_STEP(NAME, CALL) \
322static void NAME##TestStep(SkCanvas* canvas, const TestData& d, \
323 skiatest::Reporter*, CanvasTestStep*) { \
324 canvas-> CALL ; \
325} \
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000326TEST_STEP(NAME, NAME##TestStep )
327
328#define SIMPLE_TEST_STEP_WITH_ASSERT(NAME, CALL) \
piotaixrf05f5a72014-10-03 13:26:55 -0700329static void NAME##TestStep(SkCanvas* canvas, const TestData& d, \
330 skiatest::Reporter*, CanvasTestStep* testStep) { \
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000331 REPORTER_ASSERT_MESSAGE(reporter, canvas-> CALL , \
332 testStep->assertMessage()); \
333} \
334TEST_STEP(NAME, NAME##TestStep )
335
336
337///////////////////////////////////////////////////////////////////////////////
rmistry@google.comd6176b02012-08-23 18:14:13 +0000338// Basic test steps for most virtual methods in SkCanvas that draw or affect
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000339// the state of the canvas.
340
commit-bot@chromium.org92362382014-03-18 12:51:48 +0000341SIMPLE_TEST_STEP(Translate, translate(SkIntToScalar(1), SkIntToScalar(2)));
342SIMPLE_TEST_STEP(Scale, scale(SkIntToScalar(1), SkIntToScalar(2)));
343SIMPLE_TEST_STEP(Rotate, rotate(SkIntToScalar(1)));
344SIMPLE_TEST_STEP(Skew, skew(SkIntToScalar(1), SkIntToScalar(2)));
piotaixrf05f5a72014-10-03 13:26:55 -0700345SIMPLE_TEST_STEP(Concat, concat(d.fMatrix));
346SIMPLE_TEST_STEP(SetMatrix, setMatrix(d.fMatrix));
347SIMPLE_TEST_STEP(ClipRect, clipRect(d.fRect));
348SIMPLE_TEST_STEP(ClipPath, clipPath(d.fPath));
349SIMPLE_TEST_STEP(ClipRegion, clipRegion(d.fRegion, SkRegion::kReplace_Op));
350SIMPLE_TEST_STEP(Clear, clear(d.fColor));
piotaixrf05f5a72014-10-03 13:26:55 -0700351SIMPLE_TEST_STEP(BeginGroup, beginCommentGroup(d.fText.c_str()));
352SIMPLE_TEST_STEP(AddComment, addComment(d.fText.c_str(), d.fText.c_str()));
robertphillips@google.com0a4805e2013-05-29 13:24:23 +0000353SIMPLE_TEST_STEP(EndGroup, endCommentGroup());
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000354
355///////////////////////////////////////////////////////////////////////////////
356// Complex test steps
357
piotaixrf05f5a72014-10-03 13:26:55 -0700358static void SaveMatrixClipStep(SkCanvas* canvas, const TestData& d,
359 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000360 int saveCount = canvas->getSaveCount();
Florin Malita5f6102d2014-06-30 10:13:28 -0400361 canvas->save();
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000362 canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
piotaixrf05f5a72014-10-03 13:26:55 -0700363 canvas->clipRegion(d.fRegion);
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000364 canvas->restore();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000365 REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000366 testStep->assertMessage());
rmistry@google.comd6176b02012-08-23 18:14:13 +0000367 REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(),
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000368 testStep->assertMessage());
commit-bot@chromium.org5c70cdc2014-03-08 03:57:19 +0000369// REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() != kTestRegion, testStep->assertMessage());
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000370}
371TEST_STEP(SaveMatrixClip, SaveMatrixClipStep);
372
piotaixrf05f5a72014-10-03 13:26:55 -0700373static void SaveLayerStep(SkCanvas* canvas, const TestData& d,
374 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000375 int saveCount = canvas->getSaveCount();
376 canvas->saveLayer(NULL, NULL);
377 canvas->restore();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000378 REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000379 testStep->assertMessage());
380}
381TEST_STEP(SaveLayer, SaveLayerStep);
382
piotaixrf05f5a72014-10-03 13:26:55 -0700383static void BoundedSaveLayerStep(SkCanvas* canvas, const TestData& d,
384 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000385 int saveCount = canvas->getSaveCount();
piotaixrf05f5a72014-10-03 13:26:55 -0700386 canvas->saveLayer(&d.fRect, NULL);
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000387 canvas->restore();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000388 REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000389 testStep->assertMessage());
390}
391TEST_STEP(BoundedSaveLayer, BoundedSaveLayerStep);
392
piotaixrf05f5a72014-10-03 13:26:55 -0700393static void PaintSaveLayerStep(SkCanvas* canvas, const TestData& d,
394 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000395 int saveCount = canvas->getSaveCount();
piotaixrf05f5a72014-10-03 13:26:55 -0700396 canvas->saveLayer(NULL, &d.fPaint);
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000397 canvas->restore();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000398 REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000399 testStep->assertMessage());
400}
401TEST_STEP(PaintSaveLayer, PaintSaveLayerStep);
402
piotaixrf05f5a72014-10-03 13:26:55 -0700403static void TwoClipOpsStep(SkCanvas* canvas, const TestData& d,
404 skiatest::Reporter*, CanvasTestStep*) {
junov@chromium.orga6c9e0e2012-07-12 17:47:34 +0000405 // This test exercises a functionality in SkPicture that leads to the
rmistry@google.comd6176b02012-08-23 18:14:13 +0000406 // recording of restore offset placeholders. This test will trigger an
junov@chromium.orga6c9e0e2012-07-12 17:47:34 +0000407 // assertion at playback time if the placeholders are not properly
408 // filled when the recording ends.
piotaixrf05f5a72014-10-03 13:26:55 -0700409 canvas->clipRect(d.fRect);
410 canvas->clipRegion(d.fRegion);
junov@chromium.orga6c9e0e2012-07-12 17:47:34 +0000411}
412TEST_STEP(TwoClipOps, TwoClipOpsStep);
413
epoger@google.com94fa43c2012-04-11 17:51:01 +0000414// exercise fix for http://code.google.com/p/skia/issues/detail?id=560
415// ('SkPathStroker::lineTo() fails for line with length SK_ScalarNearlyZero')
piotaixrf05f5a72014-10-03 13:26:55 -0700416static void DrawNearlyZeroLengthPathTestStep(SkCanvas* canvas, const TestData& d,
417 skiatest::Reporter*, CanvasTestStep*) {
epoger@google.com94fa43c2012-04-11 17:51:01 +0000418 SkPaint paint;
419 paint.setStrokeWidth(SkIntToScalar(1));
420 paint.setStyle(SkPaint::kStroke_Style);
421
piotaixrf05f5a72014-10-03 13:26:55 -0700422 canvas->drawPath(d.fNearlyZeroLengthPath, paint);
epoger@google.com94fa43c2012-04-11 17:51:01 +0000423}
424TEST_STEP(DrawNearlyZeroLengthPath, DrawNearlyZeroLengthPathTestStep);
425
piotaixrf05f5a72014-10-03 13:26:55 -0700426static void DrawVerticesShaderTestStep(SkCanvas* canvas, const TestData& d,
427 skiatest::Reporter*, CanvasTestStep*) {
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000428 SkPoint pts[4];
429 pts[0].set(0, 0);
piotaixrf05f5a72014-10-03 13:26:55 -0700430 pts[1].set(SkIntToScalar(d.fWidth), 0);
431 pts[2].set(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight));
432 pts[3].set(0, SkIntToScalar(d.fHeight));
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000433 SkPaint paint;
piotaixrf05f5a72014-10-03 13:26:55 -0700434 SkShader* shader = SkShader::CreateBitmapShader(d.fBitmap,
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000435 SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
436 paint.setShader(shader)->unref();
437 canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
438 NULL, NULL, NULL, 0, paint);
439}
edisonn@google.com77909122012-10-18 15:58:23 +0000440// NYI: issue 240.
441TEST_STEP_NO_PDF(DrawVerticesShader, DrawVerticesShaderTestStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000442
piotaixrf05f5a72014-10-03 13:26:55 -0700443static void DrawPictureTestStep(SkCanvas* canvas, const TestData& d,
444 skiatest::Reporter*, CanvasTestStep*) {
robertphillips@google.com84b18c72014-04-13 19:09:42 +0000445 SkPictureRecorder recorder;
piotaixrf05f5a72014-10-03 13:26:55 -0700446 SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight),
robertphillipsa8d7f0b2014-08-29 08:03:56 -0700447 NULL, 0);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000448 testCanvas->scale(SkIntToScalar(2), SkIntToScalar(1));
piotaixrf05f5a72014-10-03 13:26:55 -0700449 testCanvas->clipRect(d.fRect);
450 testCanvas->drawRect(d.fRect, d.fPaint);
robertphillips@google.com84b18c72014-04-13 19:09:42 +0000451 SkAutoTUnref<SkPicture> testPicture(recorder.endRecording());
452
robertphillips9b14f262014-06-04 05:40:44 -0700453 canvas->drawPicture(testPicture);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000454}
455TEST_STEP(DrawPicture, DrawPictureTestStep);
456
piotaixrf05f5a72014-10-03 13:26:55 -0700457static void SaveRestoreTestStep(SkCanvas* canvas, const TestData& d,
458 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000459 int baseSaveCount = canvas->getSaveCount();
tomhudson@google.com8afae612012-08-14 15:03:35 +0000460 int n = canvas->save();
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000461 REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount == n, testStep->assertMessage());
462 REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000463 testStep->assertMessage());
464 canvas->save();
465 canvas->save();
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000466 REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 3 == canvas->getSaveCount(),
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000467 testStep->assertMessage());
junov@chromium.org4e6dfa52012-07-16 14:04:59 +0000468 canvas->restoreToCount(baseSaveCount + 1);
469 REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000470 testStep->assertMessage());
471
472 // should this pin to 1, or be a no-op, or crash?
473 canvas->restoreToCount(0);
474 REPORTER_ASSERT_MESSAGE(reporter, 1 == canvas->getSaveCount(),
475 testStep->assertMessage());
476}
477TEST_STEP(SaveRestore, SaveRestoreTestStep);
478
piotaixrf05f5a72014-10-03 13:26:55 -0700479static void NestedSaveRestoreWithSolidPaintTestStep(SkCanvas* canvas, const TestData& d,
480 skiatest::Reporter*, CanvasTestStep*) {
reed@google.com3b3e8952012-08-16 20:53:31 +0000481 // This test step challenges the TestDeferredCanvasStateConsistency
482 // test cases because the opaque paint can trigger an optimization
483 // that discards previously recorded commands. The challenge is to maintain
484 // correct clip and matrix stack state.
485 canvas->resetMatrix();
486 canvas->rotate(SkIntToScalar(30));
487 canvas->save();
488 canvas->translate(SkIntToScalar(2), SkIntToScalar(1));
489 canvas->save();
490 canvas->scale(SkIntToScalar(3), SkIntToScalar(3));
491 SkPaint paint;
492 paint.setColor(0xFFFFFFFF);
493 canvas->drawPaint(paint);
494 canvas->restore();
495 canvas->restore();
496}
497TEST_STEP(NestedSaveRestoreWithSolidPaint, \
498 NestedSaveRestoreWithSolidPaintTestStep);
499
piotaixrf05f5a72014-10-03 13:26:55 -0700500static void NestedSaveRestoreWithFlushTestStep(SkCanvas* canvas, const TestData& d,
501 skiatest::Reporter*, CanvasTestStep*) {
reed@google.com3b3e8952012-08-16 20:53:31 +0000502 // This test step challenges the TestDeferredCanvasStateConsistency
503 // test case because the canvas flush on a deferred canvas will
504 // reset the recording session. The challenge is to maintain correct
505 // clip and matrix stack state on the playback canvas.
506 canvas->resetMatrix();
507 canvas->rotate(SkIntToScalar(30));
508 canvas->save();
509 canvas->translate(SkIntToScalar(2), SkIntToScalar(1));
510 canvas->save();
511 canvas->scale(SkIntToScalar(3), SkIntToScalar(3));
piotaixrf05f5a72014-10-03 13:26:55 -0700512 canvas->drawRect(d.fRect,d.fPaint);
reed@google.com3b3e8952012-08-16 20:53:31 +0000513 canvas->flush();
514 canvas->restore();
515 canvas->restore();
516}
piotaixrf05f5a72014-10-03 13:26:55 -0700517TEST_STEP(NestedSaveRestoreWithFlush, NestedSaveRestoreWithFlushTestStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000518
piotaixrf05f5a72014-10-03 13:26:55 -0700519static void AssertCanvasStatesEqual(skiatest::Reporter* reporter, const TestData& d,
520 const SkCanvas* canvas1, const SkCanvas* canvas2,
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000521 CanvasTestStep* testStep) {
522 REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDeviceSize() ==
523 canvas2->getDeviceSize(), testStep->assertMessage());
524 REPORTER_ASSERT_MESSAGE(reporter, canvas1->getSaveCount() ==
525 canvas2->getSaveCount(), testStep->assertMessage());
reed@google.com3b3e8952012-08-16 20:53:31 +0000526
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000527 SkRect bounds1, bounds2;
528 REPORTER_ASSERT_MESSAGE(reporter,
reed@google.com3b3e8952012-08-16 20:53:31 +0000529 canvas1->getClipBounds(&bounds1) == canvas2->getClipBounds(&bounds2),
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000530 testStep->assertMessage());
531 REPORTER_ASSERT_MESSAGE(reporter, bounds1 == bounds2,
reed@google.com3b3e8952012-08-16 20:53:31 +0000532 testStep->assertMessage());
533
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000534 REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDrawFilter() ==
535 canvas2->getDrawFilter(), testStep->assertMessage());
536 SkIRect deviceBounds1, deviceBounds2;
537 REPORTER_ASSERT_MESSAGE(reporter,
538 canvas1->getClipDeviceBounds(&deviceBounds1) ==
539 canvas2->getClipDeviceBounds(&deviceBounds2),
540 testStep->assertMessage());
reed868074b2014-06-03 10:53:59 -0700541 REPORTER_ASSERT_MESSAGE(reporter, deviceBounds1 == deviceBounds2, testStep->assertMessage());
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000542 REPORTER_ASSERT_MESSAGE(reporter, canvas1->getTotalMatrix() ==
543 canvas2->getTotalMatrix(), testStep->assertMessage());
commit-bot@chromium.org5c70cdc2014-03-08 03:57:19 +0000544 REPORTER_ASSERT_MESSAGE(reporter, equal_clips(*canvas1, *canvas2), testStep->assertMessage());
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000545
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000546 SkCanvas::LayerIter layerIter1(const_cast<SkCanvas*>(canvas1), false);
547 SkCanvas::LayerIter layerIter2(const_cast<SkCanvas*>(canvas2), false);
548 while (!layerIter1.done() && !layerIter2.done()) {
549 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.matrix() ==
550 layerIter2.matrix(), testStep->assertMessage());
551 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.clip() ==
552 layerIter2.clip(), testStep->assertMessage());
553 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.paint() ==
554 layerIter2.paint(), testStep->assertMessage());
555 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.x() ==
556 layerIter2.x(), testStep->assertMessage());
557 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.y() ==
558 layerIter2.y(), testStep->assertMessage());
559 layerIter1.next();
560 layerIter2.next();
561 }
562 REPORTER_ASSERT_MESSAGE(reporter, layerIter1.done(),
563 testStep->assertMessage());
564 REPORTER_ASSERT_MESSAGE(reporter, layerIter2.done(),
565 testStep->assertMessage());
piotaixr76993ed2014-10-27 15:31:34 -0700566
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000567}
568
edisonn@google.com77909122012-10-18 15:58:23 +0000569static void TestPdfDevice(skiatest::Reporter* reporter,
piotaixrf05f5a72014-10-03 13:26:55 -0700570 const TestData& d,
edisonn@google.com77909122012-10-18 15:58:23 +0000571 CanvasTestStep* testStep) {
halcanary3d32d502015-03-01 06:55:20 -0800572 SkDynamicMemoryWStream outStream;
573 SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(&outStream));
574 SkCanvas* canvas = doc->beginPage(SkIntToScalar(d.fWidth),
575 SkIntToScalar(d.fHeight));
576 REPORTER_ASSERT(reporter, canvas);
edisonn@google.com77909122012-10-18 15:58:23 +0000577 testStep->setAssertMessageFormat(kPdfAssertMessageFormat);
halcanary3d32d502015-03-01 06:55:20 -0800578 testStep->draw(canvas, d, reporter);
579
580 REPORTER_ASSERT(reporter, doc->close());
edisonn@google.com77909122012-10-18 15:58:23 +0000581}
582
junov@chromium.org88e29142012-08-07 16:48:22 +0000583// The following class groups static functions that need to access
584// the privates members of SkDeferredCanvas
585class SkDeferredCanvasTester {
586public:
587 static void TestDeferredCanvasStateConsistency(
588 skiatest::Reporter* reporter,
piotaixrf05f5a72014-10-03 13:26:55 -0700589 const TestData& d,
junov@chromium.org88e29142012-08-07 16:48:22 +0000590 CanvasTestStep* testStep,
junov@chromium.orgfb103892012-09-20 19:35:43 +0000591 const SkCanvas& referenceCanvas, bool silent) {
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000592
reed@google.com28183b42014-02-04 15:34:10 +0000593 SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
594 SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(surface.get()));
595
junov@chromium.org88e29142012-08-07 16:48:22 +0000596 testStep->setAssertMessageFormat(kDeferredDrawAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700597 testStep->draw(deferredCanvas, d, reporter);
junov@chromium.org88e29142012-08-07 16:48:22 +0000598 testStep->setAssertMessageFormat(kDeferredPreFlushAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700599 AssertCanvasStatesEqual(reporter, d, deferredCanvas, &referenceCanvas, testStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000600
junov@chromium.orgfb103892012-09-20 19:35:43 +0000601 if (silent) {
junov@chromium.org66070a52013-05-28 17:39:08 +0000602 deferredCanvas->silentFlush();
junov@chromium.orgfb103892012-09-20 19:35:43 +0000603 } else {
junov@chromium.org66070a52013-05-28 17:39:08 +0000604 deferredCanvas->flush();
junov@chromium.orgfb103892012-09-20 19:35:43 +0000605 }
606
skia.committer@gmail.com4c5ea442012-09-21 02:01:01 +0000607 testStep->setAssertMessageFormat(
junov@chromium.orgfb103892012-09-20 19:35:43 +0000608 silent ? kDeferredPostSilentFlushPlaybackAssertMessageFormat :
junov@chromium.org88e29142012-08-07 16:48:22 +0000609 kDeferredPostFlushPlaybackAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700610 AssertCanvasStatesEqual(reporter, d, deferredCanvas->immediateCanvas(),
611 &referenceCanvas, testStep);
junov@chromium.orgcff01c52012-07-18 21:50:26 +0000612
junov@chromium.org88e29142012-08-07 16:48:22 +0000613 // Verified that deferred canvas state is not affected by flushing
614 // pending draw operations
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000615
junov@chromium.org88e29142012-08-07 16:48:22 +0000616 // The following test code is commented out because it currently fails.
617 // Issue: http://code.google.com/p/skia/issues/detail?id=496
618 /*
619 testStep->setAssertMessageFormat(kDeferredPostFlushAssertMessageFormat);
620 AssertCanvasStatesEqual(reporter, &deferredCanvas, &referenceCanvas,
621 testStep);
622 */
623 }
624};
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000625
caryclark@google.com42639cd2012-06-06 12:03:39 +0000626// unused
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000627static void TestNWayCanvasStateConsistency(
628 skiatest::Reporter* reporter,
piotaixrf05f5a72014-10-03 13:26:55 -0700629 const TestData& d,
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000630 CanvasTestStep* testStep,
631 const SkCanvas& referenceCanvas) {
632
633 SkBitmap indirectStore1;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000634 createBitmap(&indirectStore1, 0xFFFFFFFF);
reed2a8ca932014-06-26 22:12:09 -0700635 SkCanvas indirectCanvas1(indirectStore1);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000636
637 SkBitmap indirectStore2;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000638 createBitmap(&indirectStore2, 0xFFFFFFFF);
reed2a8ca932014-06-26 22:12:09 -0700639 SkCanvas indirectCanvas2(indirectStore2);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000640
djsollen@google.comf0a062b2012-05-01 16:50:25 +0000641 SkISize canvasSize = referenceCanvas.getDeviceSize();
642 SkNWayCanvas nWayCanvas(canvasSize.width(), canvasSize.height());
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000643 nWayCanvas.addCanvas(&indirectCanvas1);
644 nWayCanvas.addCanvas(&indirectCanvas2);
645
646 testStep->setAssertMessageFormat(kNWayDrawAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700647 testStep->draw(&nWayCanvas, d, reporter);
scroggo648238c2015-01-29 11:58:51 -0800648 // Verify that the SkNWayCanvas reports consitent state
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000649 testStep->setAssertMessageFormat(kNWayStateAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700650 AssertCanvasStatesEqual(reporter, d, &nWayCanvas, &referenceCanvas, testStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000651 // Verify that the indirect canvases report consitent state
652 testStep->setAssertMessageFormat(kNWayIndirect1StateAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700653 AssertCanvasStatesEqual(reporter, d, &indirectCanvas1, &referenceCanvas, testStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000654 testStep->setAssertMessageFormat(kNWayIndirect2StateAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700655 AssertCanvasStatesEqual(reporter, d, &indirectCanvas2, &referenceCanvas, testStep);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000656}
657
658/*
659 * This sub-test verifies that the test step passes when executed
660 * with SkCanvas and with classes derrived from SkCanvas. It also verifies
661 * that the all canvas derivatives report the same state as an SkCanvas
662 * after having executed the test step.
663 */
piotaixrf05f5a72014-10-03 13:26:55 -0700664static void TestOverrideStateConsistency(skiatest::Reporter* reporter, const TestData& d,
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000665 CanvasTestStep* testStep) {
666 SkBitmap referenceStore;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000667 createBitmap(&referenceStore, 0xFFFFFFFF);
reed2a8ca932014-06-26 22:12:09 -0700668 SkCanvas referenceCanvas(referenceStore);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000669 testStep->setAssertMessageFormat(kCanvasDrawAssertMessageFormat);
piotaixrf05f5a72014-10-03 13:26:55 -0700670 testStep->draw(&referenceCanvas, d, reporter);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000671
piotaixrf05f5a72014-10-03 13:26:55 -0700672 SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, d, testStep, referenceCanvas, false);
junov@chromium.orgfb103892012-09-20 19:35:43 +0000673
piotaixrf05f5a72014-10-03 13:26:55 -0700674 SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, d, testStep, referenceCanvas, true);
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000675
caryclark@google.com42639cd2012-06-06 12:03:39 +0000676 // The following test code is disabled because SkNWayCanvas does not
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000677 // report correct clipping and device bounds information
678 // Issue: http://code.google.com/p/skia/issues/detail?id=501
caryclark@google.com42639cd2012-06-06 12:03:39 +0000679
680 if (false) { // avoid bit rot, suppress warning
piotaixrf05f5a72014-10-03 13:26:55 -0700681 TestNWayCanvasStateConsistency(reporter, d, testStep, referenceCanvas);
caryclark@google.com42639cd2012-06-06 12:03:39 +0000682 }
rmistry@google.comd6176b02012-08-23 18:14:13 +0000683
caryclark@google.com42639cd2012-06-06 12:03:39 +0000684 if (false) { // avoid bit rot, suppress warning
685 test_clipVisitor(reporter, &referenceCanvas);
686 }
reed687fa1c2015-04-07 08:00:56 -0700687 test_clipstack(reporter);
reed@google.com7c202932011-12-14 18:48:05 +0000688}
reed@google.com37f3ae02011-11-28 16:06:04 +0000689
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000690static void test_newraster(skiatest::Reporter* reporter) {
691 SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
reed3054be12014-12-10 07:24:28 -0800692 const size_t minRowBytes = info.minRowBytes();
693 const size_t size = info.getSafeSize(minRowBytes);
694 SkAutoMalloc storage(size);
695 SkPMColor* baseAddr = static_cast<SkPMColor*>(storage.get());
696 sk_bzero(baseAddr, size);
697
698 SkCanvas* canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000699 REPORTER_ASSERT(reporter, canvas);
700
701 SkImageInfo info2;
702 size_t rowBytes;
703 const SkPMColor* addr = (const SkPMColor*)canvas->peekPixels(&info2, &rowBytes);
704 REPORTER_ASSERT(reporter, addr);
705 REPORTER_ASSERT(reporter, info == info2);
reed3054be12014-12-10 07:24:28 -0800706 REPORTER_ASSERT(reporter, minRowBytes == rowBytes);
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000707 for (int y = 0; y < info.height(); ++y) {
708 for (int x = 0; x < info.width(); ++x) {
709 REPORTER_ASSERT(reporter, 0 == addr[x]);
710 }
711 addr = (const SkPMColor*)((const char*)addr + rowBytes);
712 }
713 SkDELETE(canvas);
714
715 // now try a deliberately bad info
reede5ea5002014-09-03 11:54:58 -0700716 info = info.makeWH(-1, info.height());
reed3054be12014-12-10 07:24:28 -0800717 REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000718
719 // too big
reede5ea5002014-09-03 11:54:58 -0700720 info = info.makeWH(1 << 30, 1 << 30);
reed3054be12014-12-10 07:24:28 -0800721 REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
skia.committer@gmail.com0e530752014-02-28 03:02:05 +0000722
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000723 // not a valid pixel type
reede5ea5002014-09-03 11:54:58 -0700724 info = SkImageInfo::Make(10, 10, kUnknown_SkColorType, info.alphaType());
reed3054be12014-12-10 07:24:28 -0800725 REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000726
727 // We should succeed with a zero-sized valid info
728 info = SkImageInfo::MakeN32Premul(0, 0);
reed3054be12014-12-10 07:24:28 -0800729 canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000730 REPORTER_ASSERT(reporter, canvas);
731 SkDELETE(canvas);
732}
733
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +0000734DEF_TEST(Canvas, reporter) {
piotaixrf05f5a72014-10-03 13:26:55 -0700735 TestData d;
reed@google.com37f3ae02011-11-28 16:06:04 +0000736
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000737 for (int testStep = 0; testStep < testStepArray().count(); testStep++) {
piotaixrf05f5a72014-10-03 13:26:55 -0700738 TestOverrideStateConsistency(reporter, d, testStepArray()[testStep]);
edisonn@google.com77909122012-10-18 15:58:23 +0000739 if (testStepArray()[testStep]->enablePdfTesting()) {
piotaixrf05f5a72014-10-03 13:26:55 -0700740 TestPdfDevice(reporter, d, testStepArray()[testStep]);
edisonn@google.com77909122012-10-18 15:58:23 +0000741 }
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000742 }
junov@chromium.orgcd62ecf2012-08-02 17:43:25 +0000743
commit-bot@chromium.org3107b6a2014-02-27 20:32:51 +0000744 test_newraster(reporter);
reed@google.com37f3ae02011-11-28 16:06:04 +0000745}
reedf0090cb2014-11-26 08:55:51 -0800746
747DEF_TEST(Canvas_SaveState, reporter) {
748 SkCanvas canvas(10, 10);
749 REPORTER_ASSERT(reporter, 1 == canvas.getSaveCount());
750
751 int n = canvas.save();
752 REPORTER_ASSERT(reporter, 1 == n);
753 REPORTER_ASSERT(reporter, 2 == canvas.getSaveCount());
754
755 n = canvas.saveLayer(NULL, NULL);
756 REPORTER_ASSERT(reporter, 2 == n);
757 REPORTER_ASSERT(reporter, 3 == canvas.getSaveCount());
758
759 canvas.restore();
760 REPORTER_ASSERT(reporter, 2 == canvas.getSaveCount());
761 canvas.restore();
762 REPORTER_ASSERT(reporter, 1 == canvas.getSaveCount());
763}
reedc1b11f12015-03-13 08:48:26 -0700764
765DEF_TEST(Canvas_ClipEmptyPath, reporter) {
766 SkCanvas canvas(10, 10);
767 canvas.save();
768 SkPath path;
769 canvas.clipPath(path);
770 canvas.restore();
771 canvas.save();
772 path.moveTo(5, 5);
773 canvas.clipPath(path);
774 canvas.restore();
775 canvas.save();
776 path.moveTo(7, 7);
777 canvas.clipPath(path); // should not assert here
778 canvas.restore();
779}