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 "include/core/SkBitmap.h"
9 #include "include/core/SkCanvas.h"
10 #include "include/core/SkMatrix.h"
11 #include "include/core/SkPaint.h"
12 #include "include/core/SkRegion.h"
13 #include "include/core/SkStream.h"
14 #include "include/private/SkMutex.h"
15 #include "include/utils/SkParsePath.h"
16 #include "tests/PathOpsDebug.h"
17 #include "tests/PathOpsExtendedTest.h"
18 #include "tests/PathOpsThreadedCommon.h"
19
20 #include <stdlib.h>
21 #include <vector>
22 #include <string>
23 #include <algorithm>
24
25 std::vector<std::string> gUniqueNames;
26
27 #ifdef SK_BUILD_FOR_MAC
28 #include <sys/sysctl.h>
29 #endif
30
31 // std::to_string isn't implemented on android
32 #include <sstream>
33
34 template <typename T>
std_to_string(T value)35 std::string std_to_string(T value)
36 {
37 std::ostringstream os ;
38 os << value ;
39 return os.str() ;
40 }
41
42 bool OpDebug(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result
43 SkDEBUGPARAMS(bool skipAssert)
44 SkDEBUGPARAMS(const char* testName));
45
46 bool SimplifyDebug(const SkPath& one, SkPath* result
47 SkDEBUGPARAMS(bool skipAssert)
48 SkDEBUGPARAMS(const char* testName));
49
50 static const char marker[] =
51 "</div>\n"
52 "\n"
53 "<script type=\"text/javascript\">\n"
54 "\n"
55 "var testDivs = [\n";
56
57 static const char* opStrs[] = {
58 "kDifference_SkPathOp",
59 "kIntersect_SkPathOp",
60 "kUnion_SkPathOp",
61 "kXOR_PathOp",
62 "kReverseDifference_SkPathOp",
63 };
64
65 static const char* opSuffixes[] = {
66 "d",
67 "i",
68 "u",
69 "o",
70 "r",
71 };
72
73 enum class ExpectSuccess {
74 kNo,
75 kYes,
76 kFlaky
77 };
78
79 enum class SkipAssert {
80 kNo,
81 kYes
82 };
83
84 enum class ExpectMatch {
85 kNo,
86 kYes,
87 kFlaky
88 };
89
90 #if DEBUG_SHOW_TEST_NAME
showPathData(const SkPath & path)91 static void showPathData(const SkPath& path) {
92 SkPath::RawIter iter(path);
93 uint8_t verb;
94 SkPoint pts[4];
95 SkPoint firstPt = {0, 0}, lastPt = {0, 0};
96 bool firstPtSet = false;
97 bool lastPtSet = true;
98 while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
99 switch (verb) {
100 case SkPath::kMove_Verb:
101 if (firstPtSet && lastPtSet && firstPt != lastPt) {
102 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", lastPt.fX, lastPt.fY,
103 firstPt.fX, firstPt.fY);
104 lastPtSet = false;
105 }
106 firstPt = pts[0];
107 firstPtSet = true;
108 continue;
109 case SkPath::kLine_Verb:
110 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", pts[0].fX, pts[0].fY,
111 pts[1].fX, pts[1].fY);
112 lastPt = pts[1];
113 lastPtSet = true;
114 break;
115 case SkPath::kQuad_Verb:
116 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
117 pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
118 lastPt = pts[2];
119 lastPtSet = true;
120 break;
121 case SkPath::kConic_Verb:
122 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}}, //weight=%1.9g\n",
123 pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY,
124 iter.conicWeight());
125 lastPt = pts[2];
126 lastPtSet = true;
127 break;
128 case SkPath::kCubic_Verb:
129 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
130 pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY,
131 pts[3].fX, pts[3].fY);
132 lastPt = pts[3];
133 lastPtSet = true;
134 break;
135 case SkPath::kClose_Verb:
136 if (firstPtSet && lastPtSet && firstPt != lastPt) {
137 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", lastPt.fX, lastPt.fY,
138 firstPt.fX, firstPt.fY);
139 }
140 firstPtSet = lastPtSet = false;
141 break;
142 default:
143 SkDEBUGFAIL("bad verb");
144 return;
145 }
146 }
147 if (firstPtSet && lastPtSet && firstPt != lastPt) {
148 SkDebugf("{{%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", lastPt.fX, lastPt.fY,
149 firstPt.fX, firstPt.fY);
150 }
151 }
152 #endif
153
showOp(const SkPathOp op)154 void showOp(const SkPathOp op) {
155 switch (op) {
156 case kDifference_SkPathOp:
157 SkDebugf("op difference\n");
158 break;
159 case kIntersect_SkPathOp:
160 SkDebugf("op intersect\n");
161 break;
162 case kUnion_SkPathOp:
163 SkDebugf("op union\n");
164 break;
165 case kXOR_SkPathOp:
166 SkDebugf("op xor\n");
167 break;
168 case kReverseDifference_SkPathOp:
169 SkDebugf("op reverse difference\n");
170 break;
171 default:
172 SkASSERT(0);
173 }
174 }
175
176 #if DEBUG_SHOW_TEST_NAME
hexorator(int x)177 static char hexorator(int x) {
178 if (x < 10) {
179 return x + '0';
180 }
181 x -= 10;
182 SkASSERT(x < 26);
183 return x + 'A';
184 }
185 #endif
186
ShowTestName(PathOpsThreadState * state,int a,int b,int c,int d)187 void ShowTestName(PathOpsThreadState* state, int a, int b, int c, int d) {
188 #if DEBUG_SHOW_TEST_NAME
189 state->fSerialNo[0] = hexorator(state->fA);
190 state->fSerialNo[1] = hexorator(state->fB);
191 state->fSerialNo[2] = hexorator(state->fC);
192 state->fSerialNo[3] = hexorator(state->fD);
193 state->fSerialNo[4] = hexorator(a);
194 state->fSerialNo[5] = hexorator(b);
195 state->fSerialNo[6] = hexorator(c);
196 state->fSerialNo[7] = hexorator(d);
197 state->fSerialNo[8] = '\0';
198 SkDebugf("%s\n", state->fSerialNo);
199 if (strcmp(state->fSerialNo, state->fKey) == 0) {
200 SkDebugf("%s\n", state->fPathStr.c_str());
201 }
202 #endif
203 }
204
205 const int bitWidth = 64;
206 const int bitHeight = 64;
207
scaleMatrix(const SkPath & one,const SkPath & two,SkMatrix & scale)208 static void scaleMatrix(const SkPath& one, const SkPath& two, SkMatrix& scale) {
209 SkRect larger = one.getBounds();
210 larger.join(two.getBounds());
211 SkScalar largerWidth = larger.width();
212 if (largerWidth < 4) {
213 largerWidth = 4;
214 }
215 SkScalar largerHeight = larger.height();
216 if (largerHeight < 4) {
217 largerHeight = 4;
218 }
219 SkScalar hScale = (bitWidth - 2) / largerWidth;
220 SkScalar vScale = (bitHeight - 2) / largerHeight;
221 scale.reset();
222 scale.preScale(hScale, vScale);
223 larger.fLeft *= hScale;
224 larger.fRight *= hScale;
225 larger.fTop *= vScale;
226 larger.fBottom *= vScale;
227 SkScalar dx = -16000 > larger.fLeft ? -16000 - larger.fLeft
228 : 16000 < larger.fRight ? 16000 - larger.fRight : 0;
229 SkScalar dy = -16000 > larger.fTop ? -16000 - larger.fTop
230 : 16000 < larger.fBottom ? 16000 - larger.fBottom : 0;
231 scale.postTranslate(dx, dy);
232 }
233
pathsDrawTheSame(SkBitmap & bits,const SkPath & scaledOne,const SkPath & scaledTwo,int & error2x2)234 static int pathsDrawTheSame(SkBitmap& bits, const SkPath& scaledOne, const SkPath& scaledTwo,
235 int& error2x2) {
236 if (bits.width() == 0) {
237 bits.allocN32Pixels(bitWidth * 2, bitHeight);
238 }
239 SkCanvas canvas(bits);
240 canvas.drawColor(SK_ColorWHITE);
241 SkPaint paint;
242 canvas.save();
243 const SkRect& bounds1 = scaledOne.getBounds();
244 canvas.translate(-bounds1.fLeft + 1, -bounds1.fTop + 1);
245 canvas.drawPath(scaledOne, paint);
246 canvas.restore();
247 canvas.save();
248 canvas.translate(-bounds1.fLeft + 1 + bitWidth, -bounds1.fTop + 1);
249 canvas.drawPath(scaledTwo, paint);
250 canvas.restore();
251 int errors2 = 0;
252 int errors = 0;
253 for (int y = 0; y < bitHeight - 1; ++y) {
254 uint32_t* addr1 = bits.getAddr32(0, y);
255 uint32_t* addr2 = bits.getAddr32(0, y + 1);
256 uint32_t* addr3 = bits.getAddr32(bitWidth, y);
257 uint32_t* addr4 = bits.getAddr32(bitWidth, y + 1);
258 for (int x = 0; x < bitWidth - 1; ++x) {
259 // count 2x2 blocks
260 bool err = addr1[x] != addr3[x];
261 if (err) {
262 errors2 += addr1[x + 1] != addr3[x + 1]
263 && addr2[x] != addr4[x] && addr2[x + 1] != addr4[x + 1];
264 errors++;
265 }
266 }
267 }
268 error2x2 = errors2;
269 return errors;
270 }
271
pathsDrawTheSame(const SkPath & one,const SkPath & two,SkBitmap & bits,SkPath & scaledOne,SkPath & scaledTwo,int & error2x2)272 static int pathsDrawTheSame(const SkPath& one, const SkPath& two, SkBitmap& bits, SkPath& scaledOne,
273 SkPath& scaledTwo, int& error2x2) {
274 SkMatrix scale;
275 scaleMatrix(one, two, scale);
276 one.transform(scale, &scaledOne);
277 two.transform(scale, &scaledTwo);
278 return pathsDrawTheSame(bits, scaledOne, scaledTwo, error2x2);
279 }
280
drawAsciiPaths(const SkPath & one,const SkPath & two,bool drawPaths)281 bool drawAsciiPaths(const SkPath& one, const SkPath& two, bool drawPaths) {
282 if (!drawPaths) {
283 return true;
284 }
285 const SkRect& bounds1 = one.getBounds();
286 const SkRect& bounds2 = two.getBounds();
287 SkRect larger = bounds1;
288 larger.join(bounds2);
289 SkBitmap bits;
290 char out[256];
291 int bitWidth = SkScalarCeilToInt(larger.width()) + 2;
292 if (bitWidth * 2 + 1 >= (int) sizeof(out)) {
293 return false;
294 }
295 int bitHeight = SkScalarCeilToInt(larger.height()) + 2;
296 if (bitHeight >= (int) sizeof(out)) {
297 return false;
298 }
299 bits.allocN32Pixels(bitWidth * 2, bitHeight);
300 SkCanvas canvas(bits);
301 canvas.drawColor(SK_ColorWHITE);
302 SkPaint paint;
303 canvas.save();
304 canvas.translate(-bounds1.fLeft + 1, -bounds1.fTop + 1);
305 canvas.drawPath(one, paint);
306 canvas.restore();
307 canvas.save();
308 canvas.translate(-bounds1.fLeft + 1 + bitWidth, -bounds1.fTop + 1);
309 canvas.drawPath(two, paint);
310 canvas.restore();
311 for (int y = 0; y < bitHeight; ++y) {
312 uint32_t* addr1 = bits.getAddr32(0, y);
313 int x;
314 char* outPtr = out;
315 for (x = 0; x < bitWidth; ++x) {
316 *outPtr++ = addr1[x] == (uint32_t) -1 ? '_' : 'x';
317 }
318 *outPtr++ = '|';
319 for (x = bitWidth; x < bitWidth * 2; ++x) {
320 *outPtr++ = addr1[x] == (uint32_t) -1 ? '_' : 'x';
321 }
322 *outPtr++ = '\0';
323 SkDebugf("%s\n", out);
324 }
325 return true;
326 }
327
comparePaths(skiatest::Reporter * reporter,const char * filename,const SkPath & one,const SkPath & two,SkBitmap & bitmap)328 int comparePaths(skiatest::Reporter* reporter, const char* filename, const SkPath& one,
329 const SkPath& two, SkBitmap& bitmap) {
330 int errors2x2;
331 SkPath scaledOne, scaledTwo;
332 (void) pathsDrawTheSame(one, two, bitmap, scaledOne, scaledTwo, errors2x2);
333 if (errors2x2 == 0) {
334 return 0;
335 }
336 const int MAX_ERRORS = 9;
337 return errors2x2 > MAX_ERRORS ? errors2x2 : 0;
338 }
339
340 static SkTDArray<SkPathOp> gTestOp;
341
showPathOpPath(const char * testName,const SkPath & one,const SkPath & two,const SkPath & a,const SkPath & b,const SkPath & scaledOne,const SkPath & scaledTwo,const SkPathOp shapeOp,const SkMatrix & scale)342 static void showPathOpPath(const char* testName, const SkPath& one, const SkPath& two,
343 const SkPath& a, const SkPath& b, const SkPath& scaledOne, const SkPath& scaledTwo,
344 const SkPathOp shapeOp, const SkMatrix& scale) {
345 SkASSERT((unsigned) shapeOp < SK_ARRAY_COUNT(opStrs));
346 if (!testName) {
347 testName = "xOp";
348 }
349 SkDebugf("static void %s_%s(skiatest::Reporter* reporter, const char* filename) {\n",
350 testName, opSuffixes[shapeOp]);
351 *gTestOp.append() = shapeOp;
352 SkDebugf(" SkPath path, pathB;\n");
353 SkPathOpsDebug::ShowOnePath(a, "path", false);
354 SkPathOpsDebug::ShowOnePath(b, "pathB", false);
355 SkDebugf(" testPathOp(reporter, path, pathB, %s, filename);\n", opStrs[shapeOp]);
356 SkDebugf("}\n");
357 drawAsciiPaths(scaledOne, scaledTwo, true);
358 }
359
comparePaths(skiatest::Reporter * reporter,const char * testName,const SkPath & one,const SkPath & scaledOne,const SkPath & two,const SkPath & scaledTwo,SkBitmap & bitmap,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const SkMatrix & scale,ExpectMatch expectMatch)360 static int comparePaths(skiatest::Reporter* reporter, const char* testName, const SkPath& one,
361 const SkPath& scaledOne, const SkPath& two, const SkPath& scaledTwo, SkBitmap& bitmap,
362 const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const SkMatrix& scale,
363 ExpectMatch expectMatch) {
364 static SkMutex& compareDebugOut3 = *(new SkMutex);
365 int errors2x2;
366 const int MAX_ERRORS = 8;
367 (void) pathsDrawTheSame(bitmap, scaledOne, scaledTwo, errors2x2);
368 if (ExpectMatch::kNo == expectMatch) {
369 if (errors2x2 < MAX_ERRORS) {
370 REPORTER_ASSERT(reporter, 0);
371 }
372 return 0;
373 }
374 if (errors2x2 == 0) {
375 return 0;
376 }
377 if (ExpectMatch::kYes == expectMatch && errors2x2 >= MAX_ERRORS) {
378 SkAutoMutexExclusive autoM(compareDebugOut3);
379 showPathOpPath(testName, one, two, a, b, scaledOne, scaledTwo, shapeOp, scale);
380 SkDebugf("\n/*");
381 REPORTER_ASSERT(reporter, 0);
382 SkDebugf(" */\n");
383 }
384 return errors2x2 >= MAX_ERRORS ? errors2x2 : 0;
385 }
386
387 // Default values for when reporter->verbose() is false.
388 static int testNumber = 55;
389 static const char* testName = "pathOpTest";
390
appendTestName(const char * nameSuffix,std::string & out)391 static void appendTestName(const char* nameSuffix, std::string& out) {
392 out += testName;
393 out += std_to_string(testNumber);
394 ++testNumber;
395 if (nameSuffix) {
396 out.append(nameSuffix);
397 }
398 }
399
appendTest(const char * pathStr,const char * pathPrefix,const char * nameSuffix,const char * testFunction,bool twoPaths,std::string & out)400 static void appendTest(const char* pathStr, const char* pathPrefix, const char* nameSuffix,
401 const char* testFunction, bool twoPaths, std::string& out) {
402 #if 0
403 out.append("\n<div id=\"");
404 appendTestName(nameSuffix, out);
405 out.append("\">\n");
406 if (pathPrefix) {
407 out.append(pathPrefix);
408 }
409 out.append(pathStr);
410 out.append("</div>\n\n");
411
412 out.append(marker);
413 out.append(" ");
414 appendTestName(nameSuffix, out);
415 out.append(",\n\n\n");
416 #endif
417 out.append("static void ");
418 appendTestName(nameSuffix, out);
419 out.append("(skiatest::Reporter* reporter) {\n SkPath path");
420 if (twoPaths) {
421 out.append(", pathB");
422 }
423 out.append(";\n");
424 if (pathPrefix) {
425 out.append(pathPrefix);
426 }
427 out += pathStr;
428 out += " ";
429 out += testFunction;
430 #if 0
431 out.append("static void (*firstTest)() = ");
432 appendTestName(nameSuffix, out);
433 out.append(";\n\n");
434
435 out.append("static struct {\n");
436 out.append(" void (*fun)();\n");
437 out.append(" const char* str;\n");
438 out.append("} tests[] = {\n");
439 out.append(" TEST(");
440 appendTestName(nameSuffix, out);
441 out.append("),\n");
442 #endif
443 }
444
markTestFlakyForPathKit()445 void markTestFlakyForPathKit() {
446 if (PathOpsDebug::gJson) {
447 SkASSERT(!PathOpsDebug::gMarkJsonFlaky);
448 PathOpsDebug::gMarkJsonFlaky = true;
449 }
450 }
451
testSimplify(SkPath & path,bool useXor,SkPath & out,PathOpsThreadState & state,const char * pathStr)452 bool testSimplify(SkPath& path, bool useXor, SkPath& out, PathOpsThreadState& state,
453 const char* pathStr) {
454 static SkMutex& simplifyDebugOut = *(new SkMutex);
455 SkPathFillType fillType = useXor ? SkPathFillType::kEvenOdd : SkPathFillType::kWinding;
456 path.setFillType(fillType);
457 state.fReporter->bumpTestCount();
458 if (!Simplify(path, &out)) {
459 SkDebugf("%s did not expect failure\n", __FUNCTION__);
460 REPORTER_ASSERT(state.fReporter, 0);
461 return false;
462 }
463 if (!state.fReporter->verbose()) {
464 return true;
465 }
466 int result = comparePaths(state.fReporter, nullptr, path, out, *state.fBitmap);
467 if (result) {
468 SkAutoMutexExclusive autoM(simplifyDebugOut);
469 std::string str;
470 const char* pathPrefix = nullptr;
471 const char* nameSuffix = nullptr;
472 if (fillType == SkPathFillType::kEvenOdd) {
473 pathPrefix = " path.setFillType(SkPathFillType::kEvenOdd);\n";
474 nameSuffix = "x";
475 }
476 const char testFunction[] = "testSimplify(reporter, path);";
477 appendTest(pathStr, pathPrefix, nameSuffix, testFunction, false, str);
478 SkDebugf("%s", str.c_str());
479 REPORTER_ASSERT(state.fReporter, 0);
480 }
481 state.fReporter->bumpTestCount();
482 return result == 0;
483 }
484
json_status(ExpectSuccess expectSuccess,ExpectMatch expectMatch,bool opSucceeded)485 static void json_status(ExpectSuccess expectSuccess, ExpectMatch expectMatch, bool opSucceeded) {
486 fprintf(PathOpsDebug::gOut, " \"expectSuccess\": \"%s\",\n",
487 ExpectSuccess::kNo == expectSuccess ? "no" :
488 ExpectSuccess::kYes == expectSuccess ? "yes" : "flaky");
489 if (PathOpsDebug::gMarkJsonFlaky) {
490 expectMatch = ExpectMatch::kFlaky;
491 PathOpsDebug::gMarkJsonFlaky = false;
492 }
493 fprintf(PathOpsDebug::gOut, " \"expectMatch\": \"%s\",\n",
494 ExpectMatch::kNo == expectMatch ? "no" :
495 ExpectMatch::kYes == expectMatch ? "yes" : "flaky");
496 fprintf(PathOpsDebug::gOut, " \"succeeded\": %s,\n", opSucceeded ? "true" : "false");
497 }
498
json_path_out(const SkPath & path,const char * pathName,const char * fillTypeName,bool lastField)499 static void json_path_out(const SkPath& path, const char* pathName, const char* fillTypeName,
500 bool lastField) {
501 char const * const gFillTypeStrs[] = {
502 "Winding",
503 "EvenOdd",
504 "InverseWinding",
505 "InverseEvenOdd",
506 };
507 if (PathOpsDebug::gOutputSVG) {
508 SkString svg;
509 SkParsePath::ToSVGString(path, &svg);
510 fprintf(PathOpsDebug::gOut, " \"%s\": \"%s\",\n", pathName, svg.c_str());
511 } else {
512 SkPath::RawIter iter(path);
513 SkPath::Verb verb;
514 // MOVE, LINE, QUAD, CONIC, CUBIC, CLOSE
515 const int verbConst[] = { 0, 1, 2, 3, 4, 5 };
516 const int pointIndex[] = { 0, 1, 1, 1, 1, 0 };
517 const int pointCount[] = { 1, 2, 3, 3, 4, 0 };
518 fprintf(PathOpsDebug::gOut, " \"%s\": [", pathName);
519 bool first = true;
520 do {
521 SkPoint points[4];
522 verb = iter.next(points);
523 if (SkPath::kDone_Verb == verb) {
524 break;
525 }
526 if (first) {
527 first = false;
528 } else {
529 fprintf(PathOpsDebug::gOut, ",\n ");
530 }
531 int verbIndex = (int) verb;
532 fprintf(PathOpsDebug::gOut, "[%d", verbConst[verbIndex]);
533 for (int i = pointIndex[verbIndex]; i < pointCount[verbIndex]; ++i) {
534 fprintf(PathOpsDebug::gOut, ", \"0x%08x\", \"0x%08x\"",
535 SkFloat2Bits(points[i].fX), SkFloat2Bits(points[i].fY));
536 }
537 if (SkPath::kConic_Verb == verb) {
538 fprintf(PathOpsDebug::gOut, ", \"0x%08x\"", SkFloat2Bits(iter.conicWeight()));
539 }
540 fprintf(PathOpsDebug::gOut, "]");
541 } while (SkPath::kDone_Verb != verb);
542 fprintf(PathOpsDebug::gOut, "],\n");
543 }
544 fprintf(PathOpsDebug::gOut, " \"fillType%s\": \"k%s_FillType\"%s", fillTypeName,
545 gFillTypeStrs[(int) path.getFillType()], lastField ? "\n}" : ",\n");
546 }
547
check_for_duplicate_names(const char * testName)548 static bool check_for_duplicate_names(const char* testName) {
549 if (PathOpsDebug::gCheckForDuplicateNames) {
550 if (gUniqueNames.end() != std::find(gUniqueNames.begin(), gUniqueNames.end(),
551 std::string(testName))) {
552 SkDebugf(""); // convenience for setting breakpoints
553 }
554 gUniqueNames.push_back(std::string(testName));
555 return true;
556 }
557 return false;
558 }
559
inner_simplify(skiatest::Reporter * reporter,const SkPath & path,const char * filename,ExpectSuccess expectSuccess,SkipAssert skipAssert,ExpectMatch expectMatch)560 static bool inner_simplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename,
561 ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) {
562 #if 0 && DEBUG_SHOW_TEST_NAME
563 showPathData(path);
564 #endif
565 if (PathOpsDebug::gJson) {
566 if (check_for_duplicate_names(filename)) {
567 return true;
568 }
569 if (!PathOpsDebug::gOutFirst) {
570 fprintf(PathOpsDebug::gOut, ",\n");
571 }
572 PathOpsDebug::gOutFirst = false;
573 fprintf(PathOpsDebug::gOut, "\"%s\": {\n", filename);
574 json_path_out(path, "path", "", false);
575 }
576 SkPath out;
577 if (!SimplifyDebug(path, &out SkDEBUGPARAMS(SkipAssert::kYes == skipAssert)
578 SkDEBUGPARAMS(testName))) {
579 if (ExpectSuccess::kYes == expectSuccess) {
580 SkDebugf("%s did not expect %s failure\n", __FUNCTION__, filename);
581 REPORTER_ASSERT(reporter, 0);
582 }
583 if (PathOpsDebug::gJson) {
584 json_status(expectSuccess, expectMatch, false);
585 fprintf(PathOpsDebug::gOut, " \"out\": \"\"\n}");
586 }
587 return false;
588 } else {
589 if (ExpectSuccess::kNo == expectSuccess) {
590 SkDebugf("%s %s unexpected success\n", __FUNCTION__, filename);
591 REPORTER_ASSERT(reporter, 0);
592 }
593 if (PathOpsDebug::gJson) {
594 json_status(expectSuccess, expectMatch, true);
595 json_path_out(out, "out", "Out", true);
596 }
597 }
598 SkBitmap bitmap;
599 int errors = comparePaths(reporter, filename, path, out, bitmap);
600 if (ExpectMatch::kNo == expectMatch) {
601 if (!errors) {
602 SkDebugf("%s failing test %s now succeeds\n", __FUNCTION__, filename);
603 REPORTER_ASSERT(reporter, 0);
604 return false;
605 }
606 } else if (ExpectMatch::kYes == expectMatch && errors) {
607 REPORTER_ASSERT(reporter, 0);
608 }
609 reporter->bumpTestCount();
610 return errors == 0;
611 }
612
testSimplify(skiatest::Reporter * reporter,const SkPath & path,const char * filename)613 bool testSimplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename) {
614 return inner_simplify(reporter, path, filename, ExpectSuccess::kYes, SkipAssert::kNo,
615 ExpectMatch::kYes);
616 }
617
testSimplifyFuzz(skiatest::Reporter * reporter,const SkPath & path,const char * filename)618 bool testSimplifyFuzz(skiatest::Reporter* reporter, const SkPath& path, const char* filename) {
619 return inner_simplify(reporter, path, filename, ExpectSuccess::kFlaky, SkipAssert::kYes,
620 ExpectMatch::kFlaky);
621 }
622
testSimplifyCheck(skiatest::Reporter * reporter,const SkPath & path,const char * filename,bool checkFail)623 bool testSimplifyCheck(skiatest::Reporter* reporter, const SkPath& path, const char* filename,
624 bool checkFail) {
625 return inner_simplify(reporter, path, filename, checkFail ?
626 ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
627 }
628
testSimplifyFail(skiatest::Reporter * reporter,const SkPath & path,const char * filename)629 bool testSimplifyFail(skiatest::Reporter* reporter, const SkPath& path, const char* filename) {
630 return inner_simplify(reporter, path, filename,
631 ExpectSuccess::kNo, SkipAssert::kYes, ExpectMatch::kNo);
632 }
633
634 #if DEBUG_SHOW_TEST_NAME
showName(const SkPath & a,const SkPath & b,const SkPathOp shapeOp)635 static void showName(const SkPath& a, const SkPath& b, const SkPathOp shapeOp) {
636 SkDebugf("\n");
637 showPathData(a);
638 showOp(shapeOp);
639 showPathData(b);
640 }
641 #endif
642
innerPathOp(skiatest::Reporter * reporter,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const char * testName,ExpectSuccess expectSuccess,SkipAssert skipAssert,ExpectMatch expectMatch)643 static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
644 const SkPathOp shapeOp, const char* testName, ExpectSuccess expectSuccess,
645 SkipAssert skipAssert, ExpectMatch expectMatch) {
646 #if 0 && DEBUG_SHOW_TEST_NAME
647 showName(a, b, shapeOp);
648 #endif
649 if (PathOpsDebug::gJson) {
650 if (check_for_duplicate_names(testName)) {
651 return true;
652 }
653 if (!PathOpsDebug::gOutFirst) {
654 fprintf(PathOpsDebug::gOut, ",\n");
655 }
656 PathOpsDebug::gOutFirst = false;
657 fprintf(PathOpsDebug::gOut, "\"%s\": {\n", testName);
658 json_path_out(a, "p1", "1", false);
659 json_path_out(b, "p2", "2", false);
660 fprintf(PathOpsDebug::gOut, " \"op\": \"%s\",\n", opStrs[shapeOp]);
661 }
662 SkPath out;
663 if (!OpDebug(a, b, shapeOp, &out SkDEBUGPARAMS(SkipAssert::kYes == skipAssert)
664 SkDEBUGPARAMS(testName))) {
665 if (ExpectSuccess::kYes == expectSuccess) {
666 SkDebugf("%s %s did not expect failure\n", __FUNCTION__, testName);
667 REPORTER_ASSERT(reporter, 0);
668 }
669 if (PathOpsDebug::gJson) {
670 json_status(expectSuccess, expectMatch, false);
671 fprintf(PathOpsDebug::gOut, " \"out\": \"\"\n}");
672 }
673 return false;
674 } else {
675 if (ExpectSuccess::kNo == expectSuccess) {
676 SkDebugf("%s %s unexpected success\n", __FUNCTION__, testName);
677 REPORTER_ASSERT(reporter, 0);
678 }
679 if (PathOpsDebug::gJson) {
680 json_status(expectSuccess, expectMatch, true);
681 json_path_out(out, "out", "Out", true);
682 }
683 }
684 if (!reporter->verbose()) {
685 return true;
686 }
687 SkPath pathOut, scaledPathOut;
688 SkRegion rgnA, rgnB, openClip, rgnOut;
689 openClip.setRect({-16000, -16000, 16000, 16000});
690 rgnA.setPath(a, openClip);
691 rgnB.setPath(b, openClip);
692 rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp);
693 rgnOut.getBoundaryPath(&pathOut);
694
695 SkMatrix scale;
696 scaleMatrix(a, b, scale);
697 SkRegion scaledRgnA, scaledRgnB, scaledRgnOut;
698 SkPath scaledA, scaledB;
699 scaledA.addPath(a, scale);
700 scaledA.setFillType(a.getFillType());
701 scaledB.addPath(b, scale);
702 scaledB.setFillType(b.getFillType());
703 scaledRgnA.setPath(scaledA, openClip);
704 scaledRgnB.setPath(scaledB, openClip);
705 scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp);
706 scaledRgnOut.getBoundaryPath(&scaledPathOut);
707 SkBitmap bitmap;
708 SkPath scaledOut;
709 scaledOut.addPath(out, scale);
710 scaledOut.setFillType(out.getFillType());
711 int result = comparePaths(reporter, testName, pathOut, scaledPathOut, out, scaledOut, bitmap,
712 a, b, shapeOp, scale, expectMatch);
713 reporter->bumpTestCount();
714 return result == 0;
715 }
716
testPathOp(skiatest::Reporter * reporter,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const char * testName)717 bool testPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
718 const SkPathOp shapeOp, const char* testName) {
719 return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kYes, SkipAssert::kNo,
720 ExpectMatch::kYes);
721 }
722
testPathOpCheck(skiatest::Reporter * reporter,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const char * testName,bool checkFail)723 bool testPathOpCheck(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
724 const SkPathOp shapeOp, const char* testName, bool checkFail) {
725 return innerPathOp(reporter, a, b, shapeOp, testName, checkFail ?
726 ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
727 }
728
testPathOpFuzz(skiatest::Reporter * reporter,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const char * testName)729 bool testPathOpFuzz(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
730 const SkPathOp shapeOp, const char* testName) {
731 return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kFlaky, SkipAssert::kYes,
732 ExpectMatch::kFlaky);
733 }
734
testPathOpFail(skiatest::Reporter * reporter,const SkPath & a,const SkPath & b,const SkPathOp shapeOp,const char * testName)735 bool testPathOpFail(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
736 const SkPathOp shapeOp, const char* testName) {
737 #if DEBUG_SHOW_TEST_NAME
738 showName(a, b, shapeOp);
739 #endif
740 SkPath orig;
741 orig.lineTo(54, 43);
742 SkPath out = orig;
743 if (Op(a, b, shapeOp, &out) ) {
744 SkDebugf("%s test is expected to fail\n", __FUNCTION__);
745 REPORTER_ASSERT(reporter, 0);
746 return false;
747 }
748 SkASSERT(out == orig);
749 return true;
750 }
751
initializeTests(skiatest::Reporter * reporter,const char * test)752 void initializeTests(skiatest::Reporter* reporter, const char* test) {
753 static SkMutex& mu = *(new SkMutex);
754 if (reporter->verbose()) {
755 SkAutoMutexExclusive lock(mu);
756 testName = test;
757 size_t testNameSize = strlen(test);
758 SkFILEStream inFile("../../experimental/Intersection/op.htm");
759 if (inFile.isValid()) {
760 SkTDArray<char> inData;
761 inData.setCount((int) inFile.getLength());
762 size_t inLen = inData.count();
763 inFile.read(inData.begin(), inLen);
764 inFile.close();
765 char* insert = strstr(inData.begin(), marker);
766 if (insert) {
767 insert += sizeof(marker) - 1;
768 const char* numLoc = insert + 4 /* indent spaces */ + testNameSize - 1;
769 testNumber = atoi(numLoc) + 1;
770 }
771 }
772 }
773 }
774
outputProgress(const char * pathStr,SkPathFillType pathFillType)775 void PathOpsThreadState::outputProgress(const char* pathStr, SkPathFillType pathFillType) {
776 const char testFunction[] = "testSimplify(path);";
777 const char* pathPrefix = nullptr;
778 const char* nameSuffix = nullptr;
779 if (pathFillType == SkPathFillType::kEvenOdd) {
780 pathPrefix = " path.setFillType(SkPathFillType::kEvenOdd);\n";
781 nameSuffix = "x";
782 }
783 appendTest(pathStr, pathPrefix, nameSuffix, testFunction, false, fPathStr);
784 }
785
outputProgress(const char * pathStr,SkPathOp op)786 void PathOpsThreadState::outputProgress(const char* pathStr, SkPathOp op) {
787 const char testFunction[] = "testOp(path);";
788 SkASSERT((size_t) op < SK_ARRAY_COUNT(opSuffixes));
789 const char* nameSuffix = opSuffixes[op];
790 appendTest(pathStr, nullptr, nameSuffix, testFunction, true, fPathStr);
791 }
792
RunTestSet(skiatest::Reporter * reporter,TestDesc tests[],size_t count,void (* firstTest)(skiatest::Reporter *,const char * filename),void (* skipTest)(skiatest::Reporter *,const char * filename),void (* stopTest)(skiatest::Reporter *,const char * filename),bool reverse)793 void RunTestSet(skiatest::Reporter* reporter, TestDesc tests[], size_t count,
794 void (*firstTest)(skiatest::Reporter* , const char* filename),
795 void (*skipTest)(skiatest::Reporter* , const char* filename),
796 void (*stopTest)(skiatest::Reporter* , const char* filename), bool reverse) {
797 size_t index;
798 if (firstTest) {
799 index = count - 1;
800 while (index > 0 && tests[index].fun != firstTest) {
801 --index;
802 }
803 #if DEBUG_SHOW_TEST_NAME
804 SkDebugf("\n<div id=\"%s\">\n", tests[index].str);
805 #endif
806 (*tests[index].fun)(reporter, tests[index].str);
807 if (tests[index].fun == stopTest) {
808 return;
809 }
810 }
811 index = reverse ? count - 1 : 0;
812 size_t last = reverse ? 0 : count - 1;
813 bool foundSkip = !skipTest;
814 do {
815 if (tests[index].fun == skipTest) {
816 foundSkip = true;
817 }
818 if (foundSkip && tests[index].fun != firstTest) {
819 #if DEBUG_SHOW_TEST_NAME
820 SkDebugf("\n<div id=\"%s\">\n", tests[index].str);
821 #endif
822 (*tests[index].fun)(reporter, tests[index].str);
823 }
824 if (tests[index].fun == stopTest || index == last) {
825 break;
826 }
827 index += reverse ? -1 : 1;
828 } while (true);
829 #if DEBUG_SHOW_TEST_NAME
830 SkDebugf(
831 "\n"
832 "</div>\n"
833 "\n"
834 "<script type=\"text/javascript\">\n"
835 "\n"
836 "var testDivs = [\n"
837 );
838 index = reverse ? count - 1 : 0;
839 last = reverse ? 0 : count - 1;
840 foundSkip = !skipTest;
841 do {
842 if (tests[index].fun == skipTest) {
843 foundSkip = true;
844 }
845 if (foundSkip && tests[index].fun != firstTest) {
846 SkDebugf(" %s,\n", tests[index].str);
847 }
848 if (tests[index].fun == stopTest || index == last) {
849 break;
850 }
851 index += reverse ? -1 : 1;
852 } while (true);
853 #endif
854 }
855