bool testSimplify(SkPath& path, bool useXor, SkPath& out, PathOpsThreadState& state, const char* pathStr) { SkPath::FillType fillType = useXor ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType; path.setFillType(fillType); state.fReporter->bumpTestCount(); if (!Simplify(path, &out)) { SkDebugf("%s did not expect failure\n", __FUNCTION__); REPORTER_ASSERT(state.fReporter, 0); return false; } if (!state.fReporter->verbose()) { return true; } int result = comparePaths(state.fReporter, nullptr, path, out, *state.fBitmap); if (result) { SkAutoMutexAcquire autoM(simplifyDebugOut); char temp[8192]; sk_bzero(temp, sizeof(temp)); SkMemoryWStream stream(temp, sizeof(temp)); const char* pathPrefix = nullptr; const char* nameSuffix = nullptr; if (fillType == SkPath::kEvenOdd_FillType) { pathPrefix = " path.setFillType(SkPath::kEvenOdd_FillType);\n"; nameSuffix = "x"; } const char testFunction[] = "testSimplify(reporter, path);"; outputToStream(pathStr, pathPrefix, nameSuffix, testFunction, false, stream); SkDebugf("%s", temp); REPORTER_ASSERT(state.fReporter, 0); } state.fReporter->bumpTestCount(); return result == 0; }
static bool inner_simplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename, ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) { #if 0 && DEBUG_SHOW_TEST_NAME showPathData(path); #endif SkPath out; if (!SimplifyDebug(path, &out SkDEBUGPARAMS(SkipAssert::kYes == skipAssert) SkDEBUGPARAMS(testName))) { if (ExpectSuccess::kYes == expectSuccess) { SkDebugf("%s did not expect %s failure\n", __FUNCTION__, filename); REPORTER_ASSERT(reporter, 0); } return false; } else { if (ExpectSuccess::kNo == expectSuccess) { SkDebugf("%s %s unexpected success\n", __FUNCTION__, filename); REPORTER_ASSERT(reporter, 0); } } SkBitmap bitmap; int errors = comparePaths(reporter, filename, path, out, bitmap); if (ExpectMatch::kNo == expectMatch) { if (!errors) { SkDebugf("%s failing test %s now succeeds\n", __FUNCTION__, filename); REPORTER_ASSERT(reporter, 0); return false; } } else if (errors) { REPORTER_ASSERT(reporter, 0); } reporter->bumpTestCount(); return errors == 0; }
// FIXME: Fails on Windows if one of the paths does not specify a drive letter // E.g. c:\foo\bar and \foo\myfile.txt String getRelativePath(const String& fromAbsPath, const String& toAbsPath) { // Tokenize the paths StringVec fromTokens, toTokens; tokenize(posixPath(fromAbsPath), fromTokens, "/", "", "", "", "\\", false, false); tokenize(posixPath(toAbsPath), toTokens, "/", "", "", "", "\\", false, false); // Find the longest common prefix unsigned i = 0; StringVec::iterator fromIt = fromTokens.begin(); StringVec::iterator toIt = toTokens.begin(); for (; fromIt != fromTokens.end() && toIt != toTokens.end(); fromIt++, toIt++, i++) { if (!comparePaths(*fromIt, *toIt)) break; } if (i > 0) { // Assemble the relative path StringVec relPathTokens(fromTokens.size() - i, ".."); relPathTokens.insert(relPathTokens.end(), toIt, toTokens.end()); return joinStrings(relPathTokens, "/"); } else { // Paths have nothing in common, so no relative path exists (Windows-only) return sanitizePath(toAbsPath); } }
static bool inner_simplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename, bool checkFail) { #if 0 && DEBUG_SHOW_TEST_NAME showPathData(path); #endif SkPath out; if (!Simplify(path, &out)) { SkDebugf("%s did not expect %s failure\n", __FUNCTION__, filename); REPORTER_ASSERT(reporter, 0); return false; } SkBitmap bitmap; int errors = comparePaths(reporter, filename, path, out, bitmap); if (!checkFail) { if (!errors) { SkDebugf("%s failing test %s now succeeds\n", __FUNCTION__, filename); REPORTER_ASSERT(reporter, 0); return false; } } else if (errors) { REPORTER_ASSERT(reporter, 0); } reporter->bumpTestCount(); return errors == 0; }
bool testSimplifyx(SkPath& path, bool useXor, SkPath& out, State4& state, const char* pathStr) { SkPath::FillType fillType = useXor ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType; path.setFillType(fillType); if (gShowPath) { showPath(path); } simplifyx(path, out); if (!gComparePaths) { return true; } int result = comparePaths(path, out, state.bitmap); if (result && gPathStrAssert) { SkDebugf("addTest %s\n", state.filename); char temp[8192]; bzero(temp, sizeof(temp)); SkMemoryWStream stream(temp, sizeof(temp)); const char* pathPrefix = NULL; const char* nameSuffix = NULL; if (fillType == SkPath::kEvenOdd_FillType) { pathPrefix = " path.setFillType(SkPath::kEvenOdd_FillType);\n"; nameSuffix = "x"; } const char testFunction[] = "testSimplifyx(path);"; outputToStream(state, pathStr, pathPrefix, nameSuffix, testFunction, stream); SkDebugf(temp); SkASSERT(0); } return result == 0; }
bool testSimplifyx(const SkPath& path) { SkPath out; simplifyx(path, out); SkBitmap bitmap; int result = comparePaths(path, out, bitmap); if (result && gPathStrAssert) { SkASSERT(0); } return result == 0; }
bool testSimplify(const SkPath& path, bool fill, SkPath& out, SkBitmap& bitmap) { if (gShowPath) { showPath(path); } simplify(path, fill, out); if (!gComparePaths) { return true; } return comparePaths(path, out, bitmap) == 0; }
static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const char* testName, bool threaded) { #if DEBUG_SHOW_TEST_NAME if (testName == NULL) { SkDebugf("\n"); showPathData(a); showOp(shapeOp); showPathData(b); } else { SkPathOpsDebug::ShowPath(a, b, shapeOp, testName); } #endif SkPath out; if (!Op(a, b, shapeOp, &out) ) { SkDebugf("%s did not expect failure\n", __FUNCTION__); REPORTER_ASSERT(reporter, 0); return false; } if (threaded && !reporter->verbose()) { return true; } SkPath pathOut, scaledPathOut; SkRegion rgnA, rgnB, openClip, rgnOut; openClip.setRect(-16000, -16000, 16000, 16000); rgnA.setPath(a, openClip); rgnB.setPath(b, openClip); rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp); rgnOut.getBoundaryPath(&pathOut); SkMatrix scale; scaleMatrix(a, b, scale); SkRegion scaledRgnA, scaledRgnB, scaledRgnOut; SkPath scaledA, scaledB; scaledA.addPath(a, scale); scaledA.setFillType(a.getFillType()); scaledB.addPath(b, scale); scaledB.setFillType(b.getFillType()); scaledRgnA.setPath(scaledA, openClip); scaledRgnB.setPath(scaledB, openClip); scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp); scaledRgnOut.getBoundaryPath(&scaledPathOut); SkBitmap bitmap; SkPath scaledOut; scaledOut.addPath(out, scale); scaledOut.setFillType(out.getFillType()); int result = comparePaths(reporter, pathOut, scaledPathOut, out, scaledOut, bitmap, a, b, shapeOp, scale); if (result && gPathStrAssert) { REPORTER_ASSERT(reporter, 0); } reporter->bumpTestCount(); return result == 0; }
static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const char* testName, ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) { #if 0 && DEBUG_SHOW_TEST_NAME showName(a, b, shapeOp); #endif SkPath out; if (!OpDebug(a, b, shapeOp, &out SkDEBUGPARAMS(SkipAssert::kYes == skipAssert) SkDEBUGPARAMS(testName))) { if (ExpectSuccess::kYes == expectSuccess) { SkDebugf("%s %s did not expect failure\n", __FUNCTION__, testName); REPORTER_ASSERT(reporter, 0); } return false; } else { if (ExpectSuccess::kNo == expectSuccess) { SkDebugf("%s %s unexpected success\n", __FUNCTION__, testName); REPORTER_ASSERT(reporter, 0); } } if (!reporter->verbose()) { return true; } SkPath pathOut, scaledPathOut; SkRegion rgnA, rgnB, openClip, rgnOut; openClip.setRect(-16000, -16000, 16000, 16000); rgnA.setPath(a, openClip); rgnB.setPath(b, openClip); rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp); rgnOut.getBoundaryPath(&pathOut); SkMatrix scale; scaleMatrix(a, b, scale); SkRegion scaledRgnA, scaledRgnB, scaledRgnOut; SkPath scaledA, scaledB; scaledA.addPath(a, scale); scaledA.setFillType(a.getFillType()); scaledB.addPath(b, scale); scaledB.setFillType(b.getFillType()); scaledRgnA.setPath(scaledA, openClip); scaledRgnB.setPath(scaledB, openClip); scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp); scaledRgnOut.getBoundaryPath(&scaledPathOut); SkBitmap bitmap; SkPath scaledOut; scaledOut.addPath(out, scale); scaledOut.setFillType(out.getFillType()); int result = comparePaths(reporter, testName, pathOut, scaledPathOut, out, scaledOut, bitmap, a, b, shapeOp, scale, ExpectMatch::kYes == expectMatch); reporter->bumpTestCount(); return result == 0; }
DEF_TEST(BuilderIssue3838_2, reporter) { SkPath path; path.addCircle(100, 100, 50); SkOpBuilder builder; builder.add(path, kUnion_SkPathOp); builder.add(path, kUnion_SkPathOp); SkPath result; builder.resolve(&result); int pixelDiff = comparePaths(reporter, __FUNCTION__, path, result); REPORTER_ASSERT(reporter, pixelDiff == 0); }
bool testShapeOp(const SkPath& a, const SkPath& b, const ShapeOp shapeOp) { SkPath out; operate(a, b, shapeOp, out); SkPath pathOut; SkRegion rgnA, rgnB, openClip, rgnOut; openClip.setRect(-16000, -16000, 16000, 16000); rgnA.setPath(a, openClip); rgnB.setPath(b, openClip); rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp); rgnOut.getBoundaryPath(&pathOut); SkBitmap bitmap; int result = comparePaths(pathOut, out, bitmap, a, b, shapeOp); if (result && gPathStrAssert) { SkASSERT(0); } return result == 0; }
bool testSimplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename) { #if DEBUG_SHOW_TEST_NAME showPathData(path); #endif SkPath out; if (!Simplify(path, &out)) { SkDebugf("%s did not expect failure\n", __FUNCTION__); REPORTER_ASSERT(reporter, 0); return false; } SkBitmap bitmap; int result = comparePaths(reporter, filename, path, out, bitmap); if (result && gPathStrAssert) { REPORTER_ASSERT(reporter, 0); } reporter->bumpTestCount(); return result == 0; }
static void testPathTriangleRendering() { SkPath one, two; one.moveTo(0, 0); one.lineTo(3, 3); one.lineTo(0, 3); one.lineTo(1, 2); one.close(); for (float x = .1f; x <= 2.9ff; x += .1f) { SkDebugf("%s x=%g\n", __FUNCTION__, x); two.moveTo(0, 0); two.lineTo(x, x); two.lineTo(3, 3); two.lineTo(0, 3); two.lineTo(1, 2); two.close(); comparePaths(one, two); two.reset(); } }
DEF_TEST(BuilderIssue3838_3, reporter) { SkPath path; path.moveTo(40, 10); path.lineTo(60, 10); path.lineTo(60, 30); path.lineTo(40, 30); path.lineTo(40, 10); path.moveTo(41, 11); path.lineTo(41, 29); path.lineTo(59, 29); path.lineTo(59, 11); path.lineTo(41, 11); SkOpBuilder builder; builder.add(path, kUnion_SkPathOp); SkPath result; builder.resolve(&result); int pixelDiff = comparePaths(reporter, __FUNCTION__, path, result); REPORTER_ASSERT(reporter, pixelDiff == 0); }
DEF_TEST(BuilderIssue3838, reporter) { SkPath path; path.moveTo(200, 170); path.lineTo(220, 170); path.lineTo(220, 230); path.lineTo(240, 230); path.lineTo(240, 210); path.lineTo(180, 210); path.lineTo(180, 190); path.lineTo(260, 190); path.lineTo(260, 250); path.lineTo(200, 250); path.lineTo(200, 170); path.close(); SkPath path2; SkOpBuilder builder; builder.add(path, kUnion_SkPathOp); builder.resolve(&path2); int pixelDiff = comparePaths(reporter, __FUNCTION__, path, path2); REPORTER_ASSERT(reporter, pixelDiff == 0); }
DEF_TEST(PathOpsBuilder, reporter) { SkOpBuilder builder; SkPath result; REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isEmpty()); builder.add(result, kDifference_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isEmpty()); builder.add(result, kUnion_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isEmpty()); SkPath rectPath; rectPath.setFillType(SkPath::kEvenOdd_FillType); rectPath.addRect(0, 1, 2, 3, SkPath::kCW_Direction); builder.add(rectPath, kUnion_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); bool closed; SkPath::Direction dir; REPORTER_ASSERT(reporter, result.isRect(nullptr, &closed, &dir)); REPORTER_ASSERT(reporter, closed); REPORTER_ASSERT(reporter, dir == SkPath::kCCW_Direction); int pixelDiff = comparePaths(reporter, __FUNCTION__, rectPath, result); REPORTER_ASSERT(reporter, pixelDiff == 0); rectPath.reset(); rectPath.setFillType(SkPath::kEvenOdd_FillType); rectPath.addRect(0, 1, 2, 3, SkPath::kCCW_Direction); builder.add(rectPath, kUnion_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isRect(nullptr, &closed, &dir)); REPORTER_ASSERT(reporter, closed); REPORTER_ASSERT(reporter, dir == SkPath::kCCW_Direction); REPORTER_ASSERT(reporter, rectPath == result); builder.add(rectPath, kDifference_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isEmpty()); SkPath rect2, rect3; rect2.addRect(2, 1, 4, 3, SkPath::kCW_Direction); rect3.addRect(4, 1, 5, 3, SkPath::kCCW_Direction); builder.add(rectPath, kUnion_SkPathOp); builder.add(rect2, kUnion_SkPathOp); builder.add(rect3, kUnion_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); REPORTER_ASSERT(reporter, result.isRect(nullptr, &closed, &dir)); REPORTER_ASSERT(reporter, closed); SkRect expected; expected.set(0, 1, 5, 3); REPORTER_ASSERT(reporter, result.getBounds() == expected); SkPath circle1, circle2, circle3; circle1.addCircle(5, 6, 4, SkPath::kCW_Direction); circle2.addCircle(7, 4, 8, SkPath::kCCW_Direction); circle3.addCircle(6, 5, 6, SkPath::kCW_Direction); SkPath opCompare; Op(circle1, circle2, kUnion_SkPathOp, &opCompare); Op(opCompare, circle3, kDifference_SkPathOp, &opCompare); builder.add(circle1, kUnion_SkPathOp); builder.add(circle2, kUnion_SkPathOp); builder.add(circle3, kDifference_SkPathOp); REPORTER_ASSERT(reporter, builder.resolve(&result)); pixelDiff = comparePaths(reporter, __FUNCTION__, opCompare, result); REPORTER_ASSERT(reporter, pixelDiff == 0); }