Revert of pathops version two

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 }
 
@@ skipping 878 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(405.592621f, 909.435547f);
     pathB.lineTo(390.578583f, 867.014099f);
     pathB.lineTo(433, 852.000061f);
     pathB.lineTo(490.435486f, 879.40741f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* this cubic/quad pair
+ c = 430,280 430,278.895416 473.876068,278 528,278
+ q = 430,280 430.009796,277.101196 458.703552,275.050262
+ only intersect at the shared point (430,280)
+ they sort backwards because the tangent from pt[0] to control pt[1]
+ c' = (0.00000000000000000, -1.1045837402343750)
+ q' = (0.0097961425781250000, -2.8988037109375000)
+ suggests that the quad is counterclockwise of the cubic, when the reverse is true
+ the angle code is fooled because the control pt[1] of both the quad and cubic
+ is far away from cubic cntl [2] and quad pt [2].
+ Maybe in angle setup, this instability can be detected to suppress sorting on the initial tangent
+ Or the error term can be passed to NearRay that is magnified by the distance from the next ctrl?
+ */
 static void skpnaoxrane_ru23(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(458.703552f, 275.050262f);
     path.quadTo(487.41687f, 273.000702f, 528, 273);
     path.lineTo(529, 273);
     path.quadTo(530.242371f, 273.000305f, 531.121338f, 273.878693f);
     path.quadTo(531.999695f, 274.75766f, 532, 276);
     path.lineTo(532, 378);
     path.quadTo(531.990173f, 380.898804f, 503.296448f, 382.949738f);
@@ skipping 12 matching lines @@
     pathB.lineTo(532, 378);
     pathB.cubicTo(532, 379.104584f, 488.123932f, 380, 434, 380);
     pathB.lineTo(433, 380);
     pathB.cubicTo(431.34314f, 380, 430, 380, 430, 380);
     pathB.lineTo(430, 280);
     pathB.cubicTo(430, 278.895416f, 473.876068f, 278, 528, 278);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* didn't investigate thoroughly, but looks to be missorting quad and cubic
+    {{468.507751,560.724426}, {467.275146,552.856262}, {465.84668,547.288391}}
+    {{463.779907,542.671143}, {464.829529,542.672974}, {466.946289,550.755676}, {468.507751,560.724426}}
+    decision maker is case 14 leftLessThanRight
+ */
 static void skptcmevents_org23(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(465.503998f, 546);
     path.lineTo(347, 546);
     path.lineTo(347, 632);
     path.lineTo(469.104248f, 632);
     path.quadTo(470.79007f, 627.638672f, 471.833496f, 621.036255f);
     path.quadTo(474.902588f, 601.562866f, 470.591064f, 574.024353f);
     path.lineTo(468.507751f, 560.724426f);
@@ skipping 113 matching lines @@
     pathB.moveTo(154, 671);
     pathB.lineTo(188, 671);
     pathB.cubicTo(190.761429f, 671, 193, 672.790833f, 193, 675);
     pathB.lineTo(193, 710);
     pathB.cubicTo(193, 712.761414f, 190.761429f, 715, 188, 715);
     pathB.lineTo(154, 715);
     pathB.cubicTo(151.238571f, 715, 149, 712.761414f, 149, 710);
     pathB.lineTo(149, 675);
     pathB.cubicTo(149, 672.790833f, 151.238571f, 671, 154, 671);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_PathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 static void skpcyclist_friends_gr52(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(50, 182);
     path.lineTo(1215, 182);
     path.lineTo(1215, 202);
     path.quadTo(1214.99951f, 204.070572f, 1213.53552f, 205.535538f);
     path.quadTo(1212.07056f, 206.999496f, 1210, 207);
     path.lineTo(55, 207);
     path.quadTo(52.9294319f, 206.999496f, 51.4644661f, 205.535538f);
     path.quadTo(50.0004997f, 204.070572f, 50, 202);
     path.lineTo(50, 182);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(50, 183);
     pathB.lineTo(1215, 183);
     pathB.lineTo(1215, 202);
     pathB.cubicTo(1215, 204.761429f, 1212.76147f, 207, 1210, 207);
     pathB.lineTo(55, 207);
     pathB.cubicTo(52.238575f, 207, 50, 204.761429f, 50, 202);
     pathB.lineTo(50, 183);
     pathB.close();
-    // FIXME: this generates quads and cubics that are (correctly) not coincident unlike the old code
-    // however, somewhere the angles are sorted incorrectly and the winding is computed to be -1/-2
-    // but I can't find the error
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* cubic ends just above opp line */
 static void skpwww_fj_p_com_22(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(172, 201);
     path.lineTo(172, 202);
     path.lineTo(220, 202);
     path.cubicTo(221.65686f, 202, 223, 200.65686f, 223, 199);
     path.cubicTo(223, 200.104568f, 221.65686f, 201, 220, 201);
     path.lineTo(172, 201);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(161, 202);
     pathB.lineTo(161, 199);
     pathB.lineTo(223, 199.000015f);
     pathB.lineTo(223, 202);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// pair of lines are not quite coincident, so sorting line/cubic fails (i think)
 static void skpwww_lavoixdunord_fr_11(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(806, 57);
     path.cubicTo(806, 55.3431473f, 807.34314f, 54, 809, 54);
     path.lineTo(930, 54);
     path.cubicTo(931.65686f, 54, 933, 55.3431473f, 933, 57);
     path.lineTo(933, 91);
     path.cubicTo(933, 92.6568527f, 931.65686f, 94, 930, 94);
     path.lineTo(809, 94);
@@ skipping 12 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(806, 54);
     pathB.lineTo(808, 56);
     pathB.lineTo(935.02002f, 56.0200005f);
     pathB.lineTo(933, 54);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// pair of curves have nearly the same initial tangent but are sorting by
+// that alone sorts them incorrectly. Need to detect that tangents are nearly
+// identical and not reliable by themselves
 static void skppptv_com_62(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(173, 5342);
     path.quadTo(171.343536f, 5342.00049f, 170.17157f, 5343.17139f);
     path.quadTo(169.000397f, 5344.34375f, 169, 5346);
     path.lineTo(169, 5372);
     path.lineTo(234, 5372);
     path.lineTo(234, 5346);
     path.quadTo(233.999603f, 5344.34375f, 232.82843f, 5343.17139f);
     path.quadTo(231.656464f, 5342.00049f, 230, 5342);
     path.lineTo(173, 5342);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(173, 5342);
     pathB.lineTo(230, 5342);
     pathB.cubicTo(231.65686f, 5342, 233, 5343.79102f, 233, 5346);
     pathB.lineTo(233, 5372);
     pathB.lineTo(169, 5372);
     pathB.lineTo(169, 5346);
     pathB.cubicTo(169, 5343.79102f, 170.790863f, 5342, 173, 5342);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// nearly identical to lavoixdunord -- to not-quite-coincident lines
 static void skpwww_booking_com_68(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(90, 187);
     path.cubicTo(90, 185.34314f, 91.3431473f, 184, 93, 184);
     path.lineTo(588, 184);
     path.cubicTo(589.65686f, 184, 591, 185.34314f, 591, 187);
     path.lineTo(591, 218);
     path.cubicTo(591, 219.65686f, 589.65686f, 221, 588, 221);
     path.lineTo(93, 221);
@@ skipping 12 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(90, 184);
     pathB.lineTo(92, 186);
     pathB.lineTo(593.02002f, 186.020004f);
     pathB.lineTo(591, 184);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// visually looks like lavoixdunord and www_booking_com
 static void skpwww_despegar_com_mx_272(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(635, 1788);
     path.cubicTo(635, 1786.34314f, 636.34314f, 1785, 638, 1785);
     path.lineTo(832, 1785);
     path.cubicTo(833.65686f, 1785, 835, 1786.34314f, 835, 1788);
     path.lineTo(835, 1812);
     path.cubicTo(835, 1813.65686f, 833.65686f, 1815, 832, 1815);
     path.lineTo(638, 1815);
@@ skipping 339 matching lines @@
     pathB.lineTo(320, 165);
     pathB.cubicTo(321.65686f, 165, 323, 166.34314f, 323, 168);
     pathB.lineTo(323, 192);
     pathB.lineTo(-317, 192);
     pathB.lineTo(-317, 168);
     pathB.cubicTo(-317, 166.34314f, -315.65686f, 165, -314, 165);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* Three edges are partially coincident. Only one of the three knows about the other two.
+   Subsequently, when the angle loop is created, it misses one of the edges.
+   After coincident edges are processed, probably need a check-and-correct that makes sure the
+   coincidences are all self-consistent.
+ */
 static void skpelpais_com_18(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(183, 8507);
     path.lineTo(552, 8506.99023f);
     path.lineTo(552, 8508);
     path.lineTo(183, 8508);
     path.lineTo(183, 8507);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(183, 8508);
     pathB.lineTo(183, 8506.99023f);
     pathB.lineTo(552, 8507);
     pathB.lineTo(552, 8508);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* this generates a pair of lines that are essentially coincident; but the next line at a right
+   angle is not treated as if it intersects at the same point.
+   There are several of options:
+     move the intersection of the right angle line to the coincident point (should 'near' do this?
+     construct another coincident pair from the right angle line to the coincident point
+     treat the intersection as simple and not coincident
+ */
 static void skpnamecheap_com_405(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(140, 1000);
     path.lineTo(140, 842);
     path.lineTo(141, 842);
     path.lineTo(141.14502f, 1000);
     path.lineTo(140, 1000);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(140, 842);
     pathB.lineTo(141.008835f, 837.9646f);
     pathB.lineTo(141.235291f, 1109.05884f);
     pathB.lineTo(140, 1114);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// fails on angle insert -- haven't investigated yet
 static void skpwww_alrakoba_net_62(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(134.34314f, 9802.34277f);
     path.quadTo(132, 9804.68652f, 132, 9808);
     path.lineTo(132, 9822);
     path.quadTo(132, 9825.31348f, 134.34314f, 9827.65723f);
     path.quadTo(136.686295f, 9830, 140, 9830);
     path.lineTo(140.028473f, 9830);
     path.lineTo(139.877213f, 9828.90723f);
     path.quadTo(137.692032f, 9828.5332f, 136.050247f, 9826.65723f);
     path.quadTo(134, 9824.31348f, 134, 9821);
     path.lineTo(134, 9809);
     path.quadTo(134, 9806.10059f, 136.050247f, 9804.0498f);
     path.lineTo(134.34314f, 9802.34277f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(132, 9800);
     pathB.lineTo(135.962357f, 9800);
     pathB.lineTo(140, 9830);
     pathB.lineTo(132, 9830);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+/* asserts in alignSpanState looks like a coincident related bug */
 static void skpwww_cityads_ru_249(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(817.464478f, 11.4644661f);
     path.quadTo(818.928955f, 10, 821, 10);
     path.lineTo(998, 10);
     path.quadTo(999.082947f, 10, 1000, 10.4003992f);
     path.lineTo(1000, 13.3527431f);
     path.quadTo(999.917603f, 13.2607508f, 999.82843f, 13.1715727f);
     path.quadTo(998.65686f, 12, 997, 12);
@@ skipping 16 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1003, 10);
     pathB.lineTo(1000, 13);
     pathB.lineTo(999.969971f, 37.0299988f);
     pathB.lineTo(1003, 34);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// fails on angle insert
 static void skpwww_dealnews_com_315(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(966.464478f, 4261.46436f);
     path.quadTo(965, 4262.92871f, 965, 4265);
     path.lineTo(965, 4276);
     path.quadTo(965, 4278.07129f, 966.464478f, 4279.53564f);
     path.quadTo(967.928955f, 4281, 970, 4281);
     path.lineTo(970.020325f, 4281);
     path.lineTo(969.887512f, 4279.81641f);
     path.quadTo(968.928284f, 4279.48145f, 968.17157f, 4278.53564f);
     path.quadTo(967, 4277.07129f, 967, 4275);
     path.lineTo(967, 4266);
     path.quadTo(967, 4264.44287f, 968.035217f, 4263.31396f);
     path.lineTo(968, 4263);
     path.lineTo(966.464478f, 4261.46436f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(965, 4260);
     pathB.lineTo(967.716675f, 4260);
     pathB.lineTo(970, 4281);
     pathB.lineTo(965, 4281);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// fails in intersections insert
 static void skpwww_inmotionhosting_com_9(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(991.633911f, 1839);
     path.lineTo(964.265015f, 1839);
     path.lineTo(963.734985f, 1893.73242f);
     path.lineTo(991.3703f, 1894);
     path.lineTo(1018.23492f, 1894);
     path.lineTo(1018.76501f, 1839.2627f);
     path.lineTo(991.638184f, 1839);
@@ skipping 24 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1131, 1163);
     pathB.lineTo(-43515.8555f, -177415.594f);
     pathB.lineTo(1129.76465f, 1173.05884f);
     pathB.lineTo(1131, 1178);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// /SkOpContour.cpp:278: failed assertion "!approximately_negative(oEndT - oStartT)
 static void skpwww_hairjobsearch_com_31(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(143.292892f, 0.707106769f);
     path.quadTo(143, 0.414213538f, 143, 0);
     path.lineTo(1123, 0);
     path.quadTo(1123, 0.414213538f, 1122.70715f, 0.707106769f);
     path.quadTo(1122.41418f, 1, 1122, 1);
     path.lineTo(144, 1);
     path.quadTo(143.585785f, 1, 143.292892f, 0.707106769f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(143, 1);
     pathB.lineTo(144, 0);
     pathB.lineTo(1122, 0);
     pathB.lineTo(1123, 1);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue);
 static void skpwww_heartiste_wordpress_com_86(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(741, 9432);
     path.lineTo(761, 9431.99023f);
     path.lineTo(761, 9433);
     path.lineTo(741, 9433);
     path.lineTo(741, 9432);
     path.close();
     SkPath pathB;
@@ skipping 17 matching lines @@
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(165, 343.000031f);
     pathB.lineTo(1000, 343.000031f);
     pathB.lineTo(1000, 364.869904f);
     pathB.lineTo(165, 364.869904f);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue);
 static void skpwww_320kbps_net_2231(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(838, 9125);
     path.lineTo(862, 9124.99023f);
     path.lineTo(862, 9126);
     path.lineTo(838, 9126);
     path.lineTo(838, 9125);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(838, 9126);
     pathB.lineTo(838, 9124.99023f);
     pathB.lineTo(862, 9125);
     pathB.lineTo(862, 9126);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// debugValidateLoop loop sum fails
 static void skpwww_exystence_net_61(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(143, 9075);
     path.lineTo(316, 9075);
     path.lineTo(316, 9073.99023f);
     path.lineTo(143, 9074);
     path.lineTo(143, 9075);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(143, 9075);
     pathB.lineTo(143, 9073.99023f);
     pathB.lineTo(316, 9074);
     pathB.lineTo(316, 9075);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// debugValidateLoop loop sum fails
 static void skpwww_trashness_com_36(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(541.5f, 4835.99512f);
     path.lineTo(91.5f, 4836);
     path.lineTo(91.5f, 4836.5f);
     path.lineTo(541.5f, 4836.5f);
     path.lineTo(541.5f, 4835.99512f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(91.5f, 4836.5f);
     pathB.lineTo(91.5f, 4835.99512f);
     pathB.lineTo(541.5f, 4836);
     pathB.lineTo(541.5f, 4836.5f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkIntersections::lineVertical fUsed >= fMax
 static void skpwww_getgold_jp_731(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(284.878693f, 10134.8789f);
     path.quadTo(284, 10135.7578f, 284, 10137);
     path.lineTo(284, 10216);
     path.quadTo(284, 10217.2422f, 284.878693f, 10218.1211f);
     path.quadTo(285.125122f, 10218.3672f, 285.40213f, 10218.5459f);
     path.lineTo(286, 10138);
     path.lineTo(286, 10136);
     path.lineTo(284.878693f, 10134.8789f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(284, 10134);
     pathB.lineTo(286.05957f, 10129.8809f);
     pathB.lineTo(285.399994f, 10216.2002f);
     pathB.lineTo(284, 10219);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkOpContour::calcPartialCoincidentWinding SkASSERT(!approximately_negative(endT - startT));
 static void skpwww_maturesupertube_com_21(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(3.17157292f, 11831.1719f);
     path.quadTo(4.34314585f, 11830, 6, 11830);
     path.lineTo(1259, 11830);
     path.quadTo(1260.65686f, 11830, 1261.82837f, 11831.1719f);
     path.quadTo(1263, 11832.3428f, 1263, 11834);
     path.lineTo(1263, 11848);
     path.quadTo(1263, 11849.6572f, 1261.82837f, 11850.8281f);
@@ skipping 20 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(2, 11830);
     pathB.lineTo(4.5f, 11832.5f);
     pathB.lineTo(1260.5f, 11832.5f);
     pathB.lineTo(1263, 11830);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// can't find winding of remaining vertical edges
 static void skpwww_hubbyscook_com_22(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 902.329346f);
     path.quadTo(998, 905.250427f, 998, 909);
     path.lineTo(998, 910);
     path.quadTo(998, 913.749573f, 1000, 916.670654f);
     path.lineTo(1000, 902.329346f);
     path.close();
     SkPath pathB;
@@ skipping 27 matching lines @@
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(611, 0);
     pathB.lineTo(1084, 0);
     pathB.lineTo(1084, 469);
     pathB.lineTo(611, 469);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// asserts in bridgeOp simple->isClosed()
 static void skpwww_phototransferapp_com_24(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(85.6091843f, 5.92893219f);
     path.quadTo(89.6041641f, 3, 93.7462997f, 3);
     path.lineTo(1212.74634f, 3);
     path.quadTo(1216.88843f, 3, 1218.75134f, 5.92893219f);
     path.quadTo(1220.61414f, 8.85775471f, 1219.10669f, 12.9996767f);
     path.quadTo(1220.46338f, 9.27196693f, 1218.4939f, 6.63603878f);
     path.quadTo(1216.52441f, 4, 1212.38232f, 4);
@@ skipping 120 matching lines @@
     path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f);
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(474.873322f, 199.293594f);
     pathB.quadTo(478.196686f, 186.890503f, 489.316986f, 180.4702f);
     pathB.lineTo(490.183014f, 179.9702f);
     pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// !simple->isClosed()
 static void skpwww_contextualnewsfeeds_com_346(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(460.257355f, 1202.27808f);
     path.lineTo(460.257355f, 1204.27808f);
     path.quadTo(461.081207f, 1204.27808f, 461.665161f, 1203.69873f);
     path.lineTo(461.67157f, 1203.69238f);
     path.lineTo(466.621307f, 1198.74268f);
     path.quadTo(466.623993f, 1198.73999f, 466.626648f, 1198.7373f);
     path.quadTo(466.914185f, 1198.44604f, 466.914185f, 1198.03552f);
     path.quadTo(466.914215f, 1197.62122f, 466.621307f, 1197.32837f);
     path.lineTo(465.914215f, 1196.62122f);
     path.lineTo(460.257355f, 1202.27808f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(460.257355f, 1205.10657f);
     pathB.lineTo(458.828979f, 1203.67822f);
     pathB.lineTo(465.914215f, 1196.62122f);
     pathB.lineTo(467.32843f, 1198.03552f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// line quad intersection SkIntersections::assert
 static void skpwww_pindosiya_com_99(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(899.17157f, 548.17157f);
     path.quadTo(898, 549.34314f, 898, 551);
     path.lineTo(898, 556);
     path.lineTo(899.027283f, 556);
     path.lineTo(900.02356f, 551.602844f);
     path.quadTo(900.06073f, 551.297058f, 900.156555f, 551.015747f);
     path.lineTo(900.5f, 549.5f);
     path.lineTo(899.17157f, 548.17157f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(898, 547);
     pathB.lineTo(901.086914f, 547);
     pathB.lineTo(899, 556);
     pathB.lineTo(898, 556);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkOpAngle::setSector SkASSERT(fSectorStart >= 0);
 static void skpwww_karnivool_com_au_11(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 1431);
     path.lineTo(0, 775);
     path.lineTo(1265, 775);
     path.lineTo(1265, 1431);
     path.lineTo(0, 1431);
     path.close();
     SkPath pathB;
@@ skipping 102 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(22.5f, 24527.5f);
     pathB.lineTo(22.5f, 24527.248f);
     pathB.lineTo(45, 24527.25f);
     pathB.lineTo(45, 24527.5f);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// joinCoincidence / findT / assert
 static void skpwww_jessicaslens_wordpress_com_222(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 844.329346f);
     path.quadTo(998, 847.250427f, 998, 851);
     path.lineTo(998, 852);
     path.quadTo(998, 855.749573f, 1000, 858.670654f);
     path.lineTo(1000, 844.329346f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(998, 852);
     pathB.lineTo(998, 851);
     pathB.quadTo(998, 846.029419f, 1001.51471f, 842.514709f);
     pathB.quadTo(1005.02942f, 839, 1010, 839);
     pathB.lineTo(1011, 839);
     pathB.quadTo(1015.14215f, 839, 1018.07104f, 842.514709f);
     pathB.quadTo(1021, 846.029419f, 1021, 851);
     pathB.lineTo(1021, 852);
     pathB.quadTo(1021, 856.142151f, 1018.07104f, 859.071045f);
     pathB.quadTo(1015.14215f, 862, 1011, 862);
     pathB.lineTo(1010, 862);
     pathB.quadTo(1005.02942f, 862, 1001.51471f, 859.071045f);
     pathB.quadTo(998, 856.142151f, 998, 852);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
+// joinCoincidence / findT / assert
 static void skpwww_simplysaru_com_40(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 866.329346f);
     path.quadTo(998, 869.250427f, 998, 873);
     path.lineTo(998, 874);
     path.quadTo(998, 877.749573f, 1000, 880.670654f);
     path.lineTo(1000, 866.329346f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(998, 874);
     pathB.lineTo(998, 873);
     pathB.quadTo(998, 868.029419f, 1001.51471f, 864.514709f);
     pathB.quadTo(1005.02942f, 861, 1010, 861);
     pathB.lineTo(1011, 861);
     pathB.quadTo(1015.14215f, 861, 1018.07104f, 864.514709f);
     pathB.quadTo(1021, 868.029419f, 1021, 873);
     pathB.lineTo(1021, 874);
     pathB.quadTo(1021, 878.142151f, 1018.07104f, 881.071045f);
     pathB.quadTo(1015.14215f, 884, 1011, 884);
     pathB.lineTo(1010, 884);
     pathB.quadTo(1005.02942f, 884, 1001.51471f, 881.071045f);
     pathB.quadTo(998, 878.142151f, 998, 874);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
+// cubic-cubic intersection reduce checkLinear assert
 static void skpwww_partsdata_de_53(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(407, 119);
     path.lineTo(407, 28);
     path.lineTo(647, 28);
     path.lineTo(647, 119);
     path.lineTo(407, 119);
     path.close();
     SkPath pathB;
@@ skipping 278 matching lines @@
     pathB.lineTo(630.581177f, 44.7682648f);
     pathB.cubicTo(630.702515f, 44.8293152f, 630.831787f, 44.9108353f, 630.967163f, 45.0124512f);
     pathB.cubicTo(631.149902f, 45.1497116f, 631.322815f, 45.3301926f, 631.480225f, 45.5493507f);
     pathB.cubicTo(631.639038f, 45.7704048f, 631.77478f, 46.0453033f, 631.884399f, 46.3656998f);
     pathB.cubicTo(631.989807f, 46.6754761f, 632.04364f, 47.0436478f, 632.04364f, 47.4595947f);
     pathB.cubicTo(632.042847f, 47.949852f, 631.916565f, 48.3282623f, 631.656494f, 48.6171875f);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// SkOpAngle::setSector SkASSERT(fSectorStart >= 0);
 static void skpwww_seopack_blogspot_com_2153(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(999.892212f, 246);
     path.lineTo(927.340759f, 245.505722f);
     path.quadTo(928.068054f, 246, 929, 246);
     path.lineTo(999.892212f, 246);
     path.close();
     path.moveTo(927.340759f, 245.505722f);
     path.lineTo(926.5f, 245.5f);
     path.lineTo(925.17157f, 246.82843f);
     path.quadTo(926.34314f, 248, 928, 248);
     path.lineTo(1000, 248);
     path.lineTo(1000, 246);
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(924, 248);
     pathB.lineTo(924, 245.472672f);
     pathB.lineTo(1143, 247);
     pathB.lineTo(1143, 248);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// joinCoincidence / findT / assert
 static void skpwww_lokado_de_173(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 896.991394f);
     path.quadTo(999.789917f, 896.718872f, 999.535522f, 896.464478f);
     path.quadTo(998.071045f, 895, 996, 895);
     path.lineTo(956, 895);
     path.quadTo(951.857849f, 895, 948.928955f, 897.928955f);
     path.quadTo(946, 900.857849f, 946, 905);
     path.lineTo(946, 906);
@@ skipping 16 matching lines @@
     pathB.lineTo(1001, 911);
     pathB.quadTo(1001, 913.071045f, 999.535522f, 914.535522f);
     pathB.quadTo(998.071045f, 916, 996, 916);
     pathB.lineTo(956, 916);
     pathB.quadTo(951.857849f, 916, 948.928955f, 913.071045f);
     pathB.quadTo(946, 910.142151f, 946, 906);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
+// !simple->isClosed()
 static void skpwww_wartepop_blogspot_com_br_6(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(90.9763107f, 153.309662f);
     path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
     path.lineTo(124.666664f, 152.333344f);
     path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
     path.quadTo(128, 154.285965f, 128, 155.666672f);
     path.lineTo(128, 163.666672f);
     path.lineTo(90, 163.666672f);
@@ skipping 44 matching lines @@
     pathB.lineTo(127.666672f, 163.666672f);
     pathB.lineTo(127.666672f, 163.666672f);
     pathB.lineTo(127.666672f, 163.666672f);
     pathB.lineTo(90, 163.666672f);
     pathB.lineTo(90, 163.666672f);
     pathB.lineTo(90, 163.666672f);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
+// !simple->isClosed()
 static void skpwww_odia_com_br_26(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(360.740479f, 741.040771f);
     path.quadTo(360.378967f, 741, 360, 741);
     path.quadTo(359.159821f, 741, 358.403076f, 741.200745f);
     path.quadTo(357.649658f, 741.415833f, 356.92746f, 741.846436f);
     path.quadTo(356.600769f, 742.041199f, 356.310211f, 742.262268f);
     path.quadTo(356.025513f, 742.489197f, 355.757355f, 742.757385f);
     path.quadTo(355.16394f, 743.350769f, 354.770874f, 744.027283f);
@@ skipping 63 matching lines @@
     pathB.lineTo(311, 1171);
     pathB.quadTo(311, 1172.24268f, 310.121307f, 1173.12134f);
     pathB.quadTo(309.242645f, 1174, 308, 1174);
     pathB.lineTo(172, 1174);
     pathB.quadTo(171.17157f, 1174, 170.585785f, 1173.12134f);
     pathB.quadTo(170, 1172.24268f, 170, 1171);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
+// hangs
 static void skpwww_catingueiraonline_com_352(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(443, 8292);
     path.lineTo(443, 8140);
     path.lineTo(444, 8140);
     path.lineTo(444.01001f, 8292);
     path.lineTo(443, 8292);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(443, 8140);
     pathB.lineTo(444.01001f, 8140);
     pathB.lineTo(444, 8292);
     pathB.lineTo(443, 8292);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// hangs
 static void skpwww_galaxystwo_com_4(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(10105, 2510);
     path.lineTo(10123, 2509.98999f);
     path.lineTo(10123, 2511);
     path.lineTo(10105, 2511);
     path.lineTo(10105, 2510);
     path.close();
     SkPath pathB;
@@ skipping 703 matching lines @@
     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);
+    }
 }
 
 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);
@@ skipping 68 matching lines @@
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(808, 11703);
     pathB.lineTo(809.5f, 11701.5f);
     pathB.lineTo(1062.91907f, 11687.0811f);
     pathB.lineTo(1047, 11703);
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
+// addSimpleAngle: failed assertion "index == count() - 2"
 static void skpwww_shinydemos_com_5(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(205.884888f, 648.203857f);
     path.lineTo(771.570374f, 82.5183716f);
     path.lineTo(1110.98169f, 421.929626f);
     path.lineTo(545.296143f, 987.615112f);
     path.lineTo(205.884888f, 648.203857f);
     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);
 }
 
+// addTCoincident oPeek = &other->fTs[++oPeekIndex];
 static void skpwww_lptemp_com_3(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(78.6429825f, 1394.30969f);
     path.quadTo(79.6192932f, 1393.33337f, 81.0000076f, 1393.33337f);
     path.lineTo(341, 1393.33337f);
     path.quadTo(342.380707f, 1393.33337f, 343.357025f, 1394.30969f);
     path.quadTo(344.333344f, 1395.28601f, 344.333344f, 1396.66675f);
     path.lineTo(344.333344f, 1465.66663f);
     path.quadTo(344.333344f, 1467.04736f, 343.357025f, 1468.02368f);
@@ skipping 33 matching lines @@
     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);
 }
 
-static void skpwww_educationalcraft_com_4a(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path;
-    path.setFillType(SkPath::kEvenOdd_FillType);
-    path.moveTo(941, 1494);
-    path.lineTo(941, 1464);
-    path.lineTo(985, 1464);
-    path.lineTo(985, 1494);
-    path.lineTo(941, 1494);
-    path.close();
-    SkPath pathB;
-    pathB.setFillType(SkPath::kWinding_FillType);
-
-pathB.moveTo(984.546021f, 1478.31494f);
-pathB.cubicTo(984.546021f, 1478.31494f, 984.543213f, 1478.32239f, 984.537598f, 1478.33655f);
-pathB.cubicTo(984.419006f, 1478.63477f, 983.044373f, 1481.90405f, 980.026001f, 1481.276f);
-pathB.cubicTo(980.026001f, 1481.276f, 980.02594f, 1481.27576f, 980.025879f, 1481.27527f);
-pathB.cubicTo(980.018494f, 1481.22131f, 979.602478f, 1478.38831f, 984.546021f, 1478.31494f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
-
-}
-
-static void (*skipTest)(skiatest::Reporter* , const char* filename) = 0;
 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
-static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
-    TEST(skpwww_educationalcraft_com_4a),
     TEST(skpwww_lptemp_com_3),
     TEST(skpwww_shinydemos_com_5),
     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),
     TEST(skpwww_firstunitedbank_com_19),
     TEST(skpwww_googleventures_com_32),
     TEST(skpwww_9to5mac_com_64),
@@ skipping 99 matching lines @@
     TEST(skpilkoora_com37),
     TEST(skpmm4everfriends_com43),
     TEST(skpflite_com41),
     TEST(skpcheeseandburger_com225),
     TEST(skpeverytechpro_blogspot_com100),
 };
 
 static const size_t testCount = SK_ARRAY_COUNT(tests);
 
 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, skipTest, stopTest, runReverse);
+    RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
 }