harden pathops for pathological test

tests/PathOpsSkpTest.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"
 
 #define TEST(name) { name, #name }
 
-#define TEST_NEW_FAILURES 0
-
 static void skpcheeseandburger_com225(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(555, 468);
     path.lineTo(555, 362);
     path.lineTo(872, 362);
     path.lineTo(872, 468);
     path.lineTo(555, 468);
     path.close();
     SkPath pathB;
@@ skipping 3560 matching lines @@
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(728.37677f, 870.59082f);
     pathB.lineTo(754.088257f, 901.232605f);
     pathB.lineTo(738.767395f, 914.088379f);
     pathB.lineTo(713.055908f, 883.446594f);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TEST_NEW_FAILURES
 static void skpwww_devbridge_com_22(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(4915, 1523);
     path.quadTo(4887.24756f, 1523, 4867.62402f, 1542.6239f);
     path.quadTo(4848, 1562.24768f, 4848, 1590);
     path.quadTo(4848, 1617.75232f, 4867.62402f, 1637.3761f);
     path.quadTo(4887.24756f, 1657, 4915, 1657);
     path.quadTo(4942.75244f, 1657, 4962.37598f, 1637.3761f);
     path.quadTo(4982, 1617.75232f, 4982, 1590);
     path.quadTo(4982, 1562.24768f, 4962.37598f, 1542.6239f);
     path.quadTo(4942.75244f, 1523, 4915, 1523);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(4981.99902f, 1590);
     pathB.quadTo(4981.99902f, 1617.75232f, 4962.375f, 1637.3761f);
     pathB.quadTo(4942.75146f, 1657, 4914.99902f, 1657);
     pathB.quadTo(4887.24658f, 1657, 4867.62305f, 1637.3761f);
     pathB.quadTo(4847.99902f, 1617.75232f, 4847.99902f, 1590);
     pathB.quadTo(4847.99902f, 1562.24768f, 4867.62305f, 1542.6239f);
     pathB.quadTo(4887.24658f, 1523, 4914.99902f, 1523);
     pathB.quadTo(4942.75146f, 1523, 4962.375f, 1542.6239f);
     pathB.quadTo(4981.99902f, 1562.24768f, 4981.99902f, 1590);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    if (FLAGS_runFail) {
+        testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    } else {
+        // INVESTIGATE : why this normal test takes fail case (test has never worked)
+        testPathFailOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    }
 }
 
-// cubic/quad intersection
 static void skpwww_alamdi_com_3(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(10210.8789f, 5315.87891f);
     path.quadTo(10211.7578f, 5315, 10213, 5315);
     path.lineTo(10230, 5315);
     path.quadTo(10231.2422f, 5315, 10232.1211f, 5315.87891f);
     path.quadTo(10233, 5316.75732f, 10233, 5318);
     path.lineTo(10233, 5338);
     path.quadTo(10233, 5339.24268f, 10232.1211f, 5340.12109f);
@@ skipping 12 matching lines @@
     pathB.lineTo(10233, 5338);
     pathB.cubicTo(10233, 5339.10449f, 10231.6572f, 5340, 10230, 5340);
     pathB.lineTo(10213, 5340);
     pathB.cubicTo(10211.3428f, 5340, 10210, 5339.10449f, 10210, 5338);
     pathB.lineTo(10210, 5318);
     pathB.cubicTo(10210, 5316.34326f, 10211.3428f, 5315, 10213, 5315);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-// bumpSpan failed assertion "span->fOppValue >= 0"
 static void skpwww_familysurvivalprotocol_wordpress_com_61(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(143, 14557);
     path.lineTo(165, 14557);
     path.lineTo(165, 14555.9902f);
     path.lineTo(143, 14556);
     path.lineTo(143, 14557);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(143, 14557);
     pathB.lineTo(143, 14555.9902f);
     pathB.lineTo(165, 14556);
     pathB.lineTo(165, 14557);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
 static void skpwww_firstunitedbank_com_19(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(808.585815f, 11673.5859f);
     path.quadTo(809.17157f, 11673, 810, 11673);
     path.lineTo(1032, 11673);
     path.quadTo(1038.21326f, 11673, 1042.60657f, 11677.3936f);
     path.quadTo(1047, 11681.7871f, 1047, 11688);
     path.quadTo(1047, 11682.2012f, 1042.60657f, 11678.1006f);
@@ skipping 70 matching lines @@
     pathB.lineTo(344.333344f, 1465.66675f);
     pathB.cubicTo(344.333344f, 1467.32361f, 342.840942f, 1468.66675f, 341, 1468.66675f);
     pathB.lineTo(81, 1468.66675f);
     pathB.cubicTo(79.15905f, 1468.66675f, 77.6666718f, 1467.32361f, 77.6666718f, 1465.66675f);
     pathB.lineTo(77.6666718f, 1396.66675f);
     pathB.cubicTo(77.6666718f, 1394.82568f, 79.15905f, 1393.33337f, 81, 1393.33337f);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TEST_NEW_FAILURES
-// SkOpSegment.cpp:3915: failed assertion "otherEnd >= 0"
 static void skpwww_shinydemos_com_15(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 310.947968f);
     path.lineTo(771.570374f, 82.5183716f);
     path.lineTo(205.884888f, 648.203857f);
     path.lineTo(448.68103f, 891);
     path.lineTo(641.911255f, 891);
     path.lineTo(1000, 532.911316f);
     path.lineTo(1000, 310.947968f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(771.570374f, 82.5183716f);
     pathB.lineTo(1110.98169f, 421.929626f);
     pathB.lineTo(545.296204f, 987.615051f);
     pathB.lineTo(205.884949f, 648.203796f);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 // SkOpSegment.cpp:4398: failed assertion "!span->fDone"
 static void skpwww_lptemp_com_5(skiatest::Reporter* reporter, const char* filename) {
+    if (/* 0 && */ !FLAGS_runFail) {  // has never worked MUST BE FIXED BEFORE NEXT CHECKIN
+        return;
+    }
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(78.6429825f, 3150.97632f);
     path.quadTo(79.6192932f, 3150, 81.0000076f, 3150);
     path.lineTo(341, 3150);
     path.quadTo(342.380707f, 3150, 343.357025f, 3150.97632f);
     path.quadTo(344.333344f, 3151.95264f, 344.333344f, 3153.33325f);
     path.lineTo(344.333344f, 5205.3335f);
     path.quadTo(344.333344f, 5206.71436f, 343.357025f, 5207.69092f);
     path.quadTo(342.380707f, 5208.66699f, 341, 5208.66699f);
     path.lineTo(81.0000076f, 5208.66699f);
     path.quadTo(79.6192932f, 5208.66699f, 78.6429825f, 5207.69092f);
     path.quadTo(77.6666718f, 5206.71436f, 77.6666718f, 5205.3335f);
     path.lineTo(77.6666718f, 3153.33325f);
     path.quadTo(77.6666718f, 3151.95264f, 78.6429825f, 3150.97632f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kEvenOdd_FillType);
     pathB.moveTo(81, 3150);
     pathB.lineTo(341, 3150);
     pathB.cubicTo(342.840942f, 3150, 344.333344f, 3151.49268f, 344.333344f, 3153.3335f);
     pathB.lineTo(344.333344f, 5205.3335f);
     pathB.cubicTo(344.333344f, 5206.99023f, 342.840942f, 5208.3335f, 341, 5208.3335f);
     pathB.lineTo(81, 5208.3335f);
     pathB.cubicTo(79.15905f, 5208.3335f, 77.6666718f, 5206.99023f, 77.6666718f, 5205.3335f);
     pathB.lineTo(77.6666718f, 3153.3335f);
     pathB.cubicTo(77.6666718f, 3151.49268f, 79.15905f, 3150, 81, 3150);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOpCheck(reporter, path, pathB, kIntersect_PathOp, filename, FLAGS_runFail);
 }
-#endif
 
 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
     TEST(skpwww_lptemp_com_3),
     TEST(skpwww_shinydemos_com_5),
-#if TEST_NEW_FAILURES
     TEST(skpwww_lptemp_com_5),
     TEST(skpwww_shinydemos_com_15),
     TEST(skpwww_familysurvivalprotocol_wordpress_com_61),
     TEST(skpwww_alamdi_com_3),
     TEST(skpwww_devbridge_com_22),
-#endif
     TEST(skpwww_firstunitedbank_com_19),
     TEST(skpwww_googleventures_com_32),
     TEST(skpwww_9to5mac_com_64),
     TEST(skpwww_wartepop_blogspot_com_br_6),
     TEST(skpwww_wartepop_blogspot_com_br_6a),
     TEST(skpwww_cooksnaps_com_32a),
     TEST(skpwww_argus_presse_fr_41),
     TEST(skpwww_cooksnaps_com_17),
     TEST(skpwww_cooksnaps_com_32),
     TEST(skpwww_kitcheninspirations_wordpress_com_66),
@@ skipping 100 matching lines @@
 
 static bool runReverse = false;
 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
 DEF_TEST(PathOpsSkp, reporter) {
 #if DEBUG_SHOW_TEST_NAME
     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
 #endif
     RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
 }