harden pathops for pathological test

tests/PathOpsOpTest.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.
  */
 #include "PathOpsExtendedTest.h"
 #include "PathOpsTestCommon.h"
 
 #define TEST(name) { name, #name }
@@ skipping 1701 matching lines @@
     path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
     path.lineTo(704.000000f, 33.0000000f);
     path.lineTo(705.000000f, 33.0000000f);
     path.lineTo(705.000000f, 17.0000000f);
     path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
     path.lineTo(708.099182f, 7.09919119f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(704.000000f, 3.00000000f);
-#if 0
-    pathB.lineTo(719.500000f, 3.00000000f);
-    pathB.lineTo(705.000000f, 33.0000000f);
-    pathB.lineTo(704.000000f, 33.0000000f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
-#else
     pathB.lineTo(704.000000f, 33.0000000f);
     pathB.lineTo(705.000000f, 33.0000000f);
     pathB.lineTo(719.500000f, 3.00000000f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
-#endif
 }
 
 static void skpahrefs_com88(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1099.82886f, 7.17117119f);
     path.lineTo(1099.12134f, 7.87867832f);
     path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
     path.lineTo(1100.00000f, 28.0000000f);
     path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
@@ skipping 983 matching lines @@
     pathB.lineTo(194, 1041);
     pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
     pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
     pathB.lineTo(195, 785);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 // this fails because cubic/quad misses an intersection (failure is isolated in c/q int test)
 static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) {
-    if (!FLAGS_runFail) {
-        return;
-    }
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(945, 597);
     path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
     path.quadTo(870, 640.93396f, 870, 672);
     path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
     path.quadTo(913.93396f, 747, 945, 747);
     path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
     path.quadTo(1020, 703.06604f, 1020, 672);
     path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
     path.quadTo(976.06604f, 597, 945, 597);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(945.080994f, 597.161987f);
     pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
     pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
     pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
     pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
     pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
     pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOpCheck(reporter, path, pathB, kIntersect_PathOp, filename, FLAGS_runFail);
 }
 
 static void skpbangalorenest_com4(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 926);
     path.lineTo(0, 0);
     path.lineTo(1265, 0);
     path.lineTo(1265, 926);
     path.lineTo(0, 926);
@@ skipping 504 matching lines @@
     path.moveTo(2,4);
     path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
     path.close();
     pathB.moveTo(3,5);
     pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
 static void cubicOp114(skiatest::Reporter* reporter, const char* filename) {
-    if (!FLAGS_runFail) {
-        return;
-    }
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 1);
     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 3);
     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOpCheck(reporter, path, pathB, kIntersect_PathOp, filename, FLAGS_runFail);
 }
 
 static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 1);
     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 3);
@@ skipping 145 matching lines @@
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
 static void issue2753(skiatest::Reporter* reporter, const char* filename) {
-    if (!FLAGS_runFail) {
-        return;
-    }
     SkPath path1;
     path1.moveTo(142.701f, 110.568f);
     path1.lineTo(142.957f, 100);
     path1.lineTo(153.835f, 100);
     path1.lineTo(154.592f, 108.188f);
     path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f);
     path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f);
     path1.close();
 
     SkPath path2;
     path2.moveTo(39, 124.001f);
     path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f);
     path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f);
     path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f);
     path2.close();
 
-    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
+    testPathOpCheck(reporter, path1, path2, kUnion_PathOp, filename, FLAGS_runFail);
 }
 
 static void issue2808(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1, path2;
 
         path1.moveTo(509.20300293f, 385.601989746f);
         path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f);
         path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f);
         path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f);
         path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f);
@@ skipping 10 matching lines @@
         path2.quadTo(400, 301.028259277f, 400, 290.87298584f);
         path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f);
         path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f);
         path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f);
         path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f);
         path2.close();
 
     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
 }
 
+static void cubicOp115(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(0,1);
+    path.cubicTo(3,4, 2,1, 5,3);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(1,2);
+    pathB.cubicTo(3,5, 1,0, 4,3);
+    pathB.close();
+    SkPath path2(path);
+    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
+}
+
 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
+    TEST(cubicOp115),
     TEST(issue2753),  // FIXME: pair of cubics miss intersection
     TEST(cubicOp114),  // FIXME: curve with inflection is ordered the wrong way
     TEST(issue2808),
     TEST(cubicOp114asQuad),
     TEST(rects4),
     TEST(rects3),
     TEST(rects2),
     TEST(rects1),
     TEST(issue2540),
     TEST(issue2504),
@@ skipping 430 matching lines @@
 };
 
 static const size_t failTestCount = SK_ARRAY_COUNT(failTests);
 
 DEF_TEST(PathOpsFailOp, reporter) {
 #if DEBUG_SHOW_TEST_NAME
     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
 #endif
     RunTestSet(reporter, failTests, failTestCount, 0, 0, false);
 }