1 /*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "PathOpsExtendedTest.h"
9 #include "PathOpsThreadedCommon.h"
10 #include "SkMacros.h"
11 #include "SkString.h"
12
13 // four rects, of four sizes
14 // for 3 smaller sizes, tall, wide
15 // top upper mid lower bottom aligned (3 bits, 5 values)
16 // same with x (3 bits, 5 values)
17 // not included, square, tall, wide (2 bits)
18 // cw or ccw (1 bit)
19
testSimplify4x4RectsMain(PathOpsThreadState * data)20 static void testSimplify4x4RectsMain(PathOpsThreadState* data)
21 {
22 SkASSERT(data);
23 PathOpsThreadState& state = *data;
24 int aShape = state.fA & 0x03;
25 SkPath::Direction aCW = state.fA >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
26 int bShape = state.fB & 0x03;
27 SkPath::Direction bCW = state.fB >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
28 int cShape = state.fC & 0x03;
29 SkPath::Direction cCW = state.fC >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
30 int dShape = state.fD & 0x03;
31 SkPath::Direction dCW = state.fD >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
32 for (int aXAlign = 0; aXAlign < 5; ++aXAlign) {
33 for (int aYAlign = 0; aYAlign < 5; ++aYAlign) {
34 for (int bXAlign = 0; bXAlign < 5; ++bXAlign) {
35 for (int bYAlign = 0; bYAlign < 5; ++bYAlign) {
36 for (int cXAlign = 0; cXAlign < 5; ++cXAlign) {
37 for (int cYAlign = 0; cYAlign < 5; ++cYAlign) {
38 for (int dXAlign = 0; dXAlign < 5; ++dXAlign) {
39 for (int dYAlign = 0; dYAlign < 5; ++dYAlign) {
40 SkString pathStr;
41 SkPath path, out;
42 path.setFillType(SkPath::kWinding_FillType);
43 int l SK_INIT_TO_AVOID_WARNING, t SK_INIT_TO_AVOID_WARNING,
44 r SK_INIT_TO_AVOID_WARNING, b SK_INIT_TO_AVOID_WARNING;
45 if (aShape) {
46 switch (aShape) {
47 case 1: // square
48 l = 0; r = 60;
49 t = 0; b = 60;
50 aXAlign = 5;
51 aYAlign = 5;
52 break;
53 case 2:
54 l = aXAlign * 12;
55 r = l + 30;
56 t = 0; b = 60;
57 aYAlign = 5;
58 break;
59 case 3:
60 l = 0; r = 60;
61 t = aYAlign * 12;
62 b = l + 30;
63 aXAlign = 5;
64 break;
65 }
66 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
67 aCW);
68 if (state.fReporter->verbose()) {
69 pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
70 " SkPath::kC%sW_Direction);\n", l, t, r, b, aCW ? "C" : "");
71 }
72 } else {
73 aXAlign = 5;
74 aYAlign = 5;
75 }
76 if (bShape) {
77 switch (bShape) {
78 case 1: // square
79 l = bXAlign * 10;
80 r = l + 20;
81 t = bYAlign * 10;
82 b = l + 20;
83 break;
84 case 2:
85 l = bXAlign * 10;
86 r = l + 20;
87 t = 10; b = 40;
88 bYAlign = 5;
89 break;
90 case 3:
91 l = 10; r = 40;
92 t = bYAlign * 10;
93 b = l + 20;
94 bXAlign = 5;
95 break;
96 }
97 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
98 bCW);
99 if (state.fReporter->verbose()) {
100 pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
101 " SkPath::kC%sW_Direction);\n", l, t, r, b, bCW ? "C" : "");
102 }
103 } else {
104 bXAlign = 5;
105 bYAlign = 5;
106 }
107 if (cShape) {
108 switch (cShape) {
109 case 1: // square
110 l = cXAlign * 6;
111 r = l + 12;
112 t = cYAlign * 6;
113 b = l + 12;
114 break;
115 case 2:
116 l = cXAlign * 6;
117 r = l + 12;
118 t = 20; b = 30;
119 cYAlign = 5;
120 break;
121 case 3:
122 l = 20; r = 30;
123 t = cYAlign * 6;
124 b = l + 20;
125 cXAlign = 5;
126 break;
127 }
128 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
129 cCW);
130 if (state.fReporter->verbose()) {
131 pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
132 " SkPath::kC%sW_Direction);\n", l, t, r, b, cCW ? "C" : "");
133 }
134 } else {
135 cXAlign = 5;
136 cYAlign = 5;
137 }
138 if (dShape) {
139 switch (dShape) {
140 case 1: // square
141 l = dXAlign * 4;
142 r = l + 9;
143 t = dYAlign * 4;
144 b = l + 9;
145 break;
146 case 2:
147 l = dXAlign * 6;
148 r = l + 9;
149 t = 32; b = 36;
150 dYAlign = 5;
151 break;
152 case 3:
153 l = 32; r = 36;
154 t = dYAlign * 6;
155 b = l + 9;
156 dXAlign = 5;
157 break;
158 }
159 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
160 dCW);
161 if (state.fReporter->verbose()) {
162 pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
163 " SkPath::kC%sW_Direction);\n", l, t, r, b, dCW ? "C" : "");
164 }
165 } else {
166 dXAlign = 5;
167 dYAlign = 5;
168 }
169 path.close();
170 if (state.fReporter->verbose()) {
171 state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
172 }
173 testSimplify(path, false, out, state, pathStr.c_str());
174 if (state.fReporter->verbose()) {
175 state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
176 }
177 testSimplify(path, true, out, state, pathStr.c_str());
178 }
179 }
180 }
181 }
182 }
183 }
184 }
185 }
186 }
187
DEF_TEST(PathOpsSimplifyRectsThreaded,reporter)188 DEF_TEST(PathOpsSimplifyRectsThreaded, reporter) {
189 initializeTests(reporter, "testLine");
190 PathOpsThreadedTestRunner testRunner(reporter);
191 for (int a = 0; a < 8; ++a) { // outermost
192 for (int b = a ; b < 8; ++b) {
193 for (int c = b ; c < 8; ++c) {
194 for (int d = c; d < 8; ++d) {
195 *testRunner.fRunnables.append() = new PathOpsThreadedRunnable(
196 &testSimplify4x4RectsMain, a, b, c, d, &testRunner);
197 }
198 if (!reporter->allowExtendedTest()) goto finish;
199 }
200 }
201 }
202 finish:
203 testRunner.render();
204 }
205