compute initial winding from projected rays

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 }
+class PathTest_Private {
+public:
+    PathTest_Private(SkPath* path)
+        : fPath(path) {}
+
+    void setPt(int index, SkScalar x, SkScalar y) {
+        fPath->setPt(index, x, y);
+    }
+
+    SkPath* fPath;
+};
+
+static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
+    PathTest_Private testPath(path);
+    for (int index = 0; index < path->countPoints(); ++index) {
+        if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
+            testPath.setPt(index, to.fX, to.fY);
+            return;
+        }
+    }
+}
 
 static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0,1);
     path.cubicTo(0,2, 1,0, 1,0);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0,1);
     pathB.cubicTo(0,1, 1,0, 2,0);
@@ skipping 2427 matching lines @@
     pathB.moveTo(317, 711);
     pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
     pathB.lineTo(327, 838);
     pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
     pathB.lineTo(155, 848);
     pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
     pathB.lineTo(145, 721);
     pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
     pathB.lineTo(317, 711);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void cubicOp92i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 1);
     path.cubicTo(2, 6, 4, 1, 5, 4);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 4);
@@ skipping 1163 matching lines @@
 #include "SkParsePath.h"
 
 static void issue3517(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
 
     const char str[] = "M31.35 57.75L31.35 57.75C31.9 57.7486 32.45 57.7948 33 57.7413C33.55 57.6878 34.1 57.5014 34.65 57.4291C35.2 57.3569 35.75 57.3223 36.3 57.3079C36.85 57.2935 37.4 57.3143 37.95 57.3428C38.5 57.3712 39.05 57.4112 39.6 57.4786C40.15 57.546 40.7 57.7029 41.25 57.7472C41.8 57.7916 42.35 57.7962 42.9 57.7445C43.45 57.6928 44 57.5345 44.55 57.4373C45.1 57.34 45.65 57.2115 46.2 57.1611C46.75 57.1107 47.3 57.1371 47.85 57.1349C48.4 57.1327 48.95 57.144 49.5 57.1478C50.05 57.1516 50.6 57.1553 51.15 57.1579C51.7 57.1605 52.25 57.1601 52.8 57.1634C53.35 57.1667 53.9 57.1731 54.45 57.1776C55 57.182 55.55 57.1916 56.1 57.19C56.65 57.1884 57.2 57.178 57.75 57.168C58.3 57.158 58.85 57.1355 59.4 57.1299C59.95 57.1243 60.5 57.1338 61.05 57.1345C61.6 57.1352 62.15 57.124 62.7 57.134C63.25 57.1441 63.8 57.1731 64.35 57.195C64.9 57.2169 65.45 57.2532 66 57.2655C66.55 57.2778 67.1 57.2647 67.65 57.2687C68.2 57.2728 68.75 57.267 69.3 57.2896C69.85 57.3122 70.4 57.371 70.95 57.4044C71.5 57.4377 72.05 57.4668 72.6 57.4896C73.15 57.5123 73.7 57.545 74.25 57.5408C74.8 57.5365 75.35 57.5068 75.9 57.4641C76.45 57.4213 77 57.3244 77.55 57.2842C78.1 57.244 78.65 57.2163 79.2 57.2228C79.75 57.2293 80.3 57.29 80.85 57.3232C81.4 57.3563 81.95 57.396 82.5 57.4219C83.05 57.4478 83.6 57.4637 84.15 57.4787C84.7 57.4937 85.25 57.5011 85.8 57.5121C86.35 57.523 86.9 57.5411 87.45 57.5444C88 57.5477 88.55 57.5663 89.1 57.5318C89.65 57.4972 90.2 57.3126 90.75 57.337C91.3 57.3613 91.85 57.6088 92.4 57.6776C92.95 57.7465 93.5 57.7379 94.05 57.75C94.6 57.7621 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z";
     SkParsePath::FromSVGString(str, &path);
 
     const char strB[] = "M31.35 57.75L31.35 57.75C31.9 57.7514 32.45 57.7052 33 57.7587C33.55 57.8122 34.1 57.9986 34.65 58.0709C35.2 58.1431 35.75 58.1777 36.3 58.1921C36.85 58.2065 37.4 58.1857 37.95 58.1572C38.5 58.1288 39.05 58.0888 39.6 58.0214C40.15 57.954 40.7 57.7971 41.25 57.7528C41.8 57.7084 42.35 57.7038 42.9 57.7555C43.45 57.8072 44 57.9655 44.55 58.0627C45.1 58.16 45.65 58.2885 46.2 58.3389C46.75 58.3893 47.3 58.3629 47.85 58.3651C48.4 58.3673 48.95 58.356 49.5 58.3522C50.05 58.3484 50.6 58.3447 51.15 58.3421C51.7 58.3395 52.25 58.3399 52.8 58.3366C53.35 58.3333 53.9 58.3269 54.45 58.3224C55 58.318 55.55 58.3084 56.1 58.31C56.65 58.3116 57.2 58.322 57.75 58.332C58.3 58.342 58.85 58.3645 59.4 58.3701C59.95 58.3757 60.5 58.3662 61.05 58.3655C61.6 58.3648 62.15 58.376 62.7 58.366C63.25 58.3559 63.8 58.3269 64.35 58.305C64.9 58.2831 65.45 58.2468 66 58.2345C66.55 58.2222 67.1 58.2353 67.65 58.2313C68.2 58.2272 68.75 58.233 69.3 58.2104C69.85 58.1878 70.4 58.129 70.95 58.0956C71.5 58.0623 72.05 58.0332 72.6 58.0104C73.15 57.9877 73.7 57.955 74.25 57.9592C74.8 57.9635 75.35 57.9932 75.9 58.0359C76.45 58.0787 77 58.1756 77.55 58.2158C78.1 58.256 78.65 58.2837 79.2 58.2772C79.75 58.2707 80.3 58.21 80.85 58.1768C81.4 58.1437 81.95 58.104 82.5 58.0781C83.05 58.0522 83.6 58.0363 84.15 58.0213C84.7 58.0063 85.25 57.9989 85.8 57.9879C86.35 57.977 86.9 57.9589 87.45 57.9556C88 57.9523 88.55 57.9337 89.1 57.9682C89.65 58.0028 90.2 58.1874 90.75 58.163C91.3 58.1387 91.85 57.8912 92.4 57.8224C92.95 57.7535 93.5 57.7621 94.05 57.75C94.6 57.7379 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z";
     SkParsePath::FromSVGString(strB, &pathB);
-    testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
+    testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, FLAGS_runFail);
 }
 
 static void cubicOp119(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0,1);
     path.cubicTo(3,5, 2,1, 3,1);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1,2);
@@ skipping 370 matching lines @@
     SkPath path, pathB;
     path.moveTo(1,2);
     path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
     path.close();
     pathB.moveTo(0,6);
     pathB.cubicTo(-3.16666675f,3.66666675f, 6.33333349f,3.33333349f, 1,2);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-static void loop15(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path, pathB;
-    path.moveTo(2,6);
-    path.cubicTo(1,2, 7.16666698f,6.66666698f, -4.66666651f,7.66666651f);
-    path.close();
-    pathB.moveTo(1,2);
-    pathB.cubicTo(7.16666698f,6.66666698f, -4.66666651f,7.66666651f, 2,6);
-    pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
-}
-
-// lots of loopy interesections -- all points appear to be present -- needs more investigation
-static void loop16(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path, pathB;
-    path.moveTo(1,5);
-    path.cubicTo(0,1, 7.33333302f,5.33333349f, -7,7);
-    path.close();
-    pathB.moveTo(0,1);
-    pathB.cubicTo(7.33333302f,5.33333349f, -7,7, 1,5);
-    pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
-}
-
 static void cubicOp133(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(5,6);
     path.cubicTo(5,6, 5,0, 4,1);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0,5);
     pathB.cubicTo(1,4, 6,5, 6,5);
     pathB.close();
@@ skipping 467 matching lines @@
 static void loops23i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 5);
     path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 1);
     pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void loops24i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 2);
     path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 2);
@@ skipping 18 matching lines @@
 static void loops26i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 6);
     path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 2);
     pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void loops27i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 3);
     path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 3);
@@ skipping 70 matching lines @@
 static void loops33i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 6);
     path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 2);
     pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void loops33iMod(skiatest::Reporter* reporter, const char* filename) {
     SkPoint pts[] = {{2, 6}, {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f},
                      {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f}, {2, 6}};
     bool up = false;
     float offset = 0.0380172729f;
     float step = 7.62939453e-006f;
     bool lastResult = true;
  //   for (int i = 0; i < 30; ++i) {
         SkString name(filename);
  //       name.appendS32(i);
  //       if (i > 0) {
  //           SkDebugf("\n\n<div id=\"%s\">\n", name.c_str());
  //       }
         pts[5].fY = 6.66666698f + offset;
         SkPath path, pathB;
         path.setFillType(SkPath::kWinding_FillType);
         path.moveTo(pts[0]);
         path.cubicTo(pts[1], pts[2], pts[3]);
         path.close();
         pathB.setFillType(SkPath::kWinding_FillType);
         pathB.moveTo(pts[4]);
         pathB.cubicTo(pts[5], pts[6], pts[7]);
         pathB.close();
-        bool result = testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, name.c_str(),
-            FLAGS_runFail);
+        bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
         if (lastResult != result) {
             up = !up;
         }
         step /= 2;
         offset += up ? step : -step;
         lastResult = result;
  //   }
 }
 
 
@@ skipping 113 matching lines @@
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 5);
     pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
     pathB.close();
     SkPath qPath, qPathB;
     CubicPathToQuads(path, &qPath);
     CubicPathToQuads(pathB, &qPathB);
     testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
 }
 
-static void loops41i(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path, pathB;
-    path.setFillType(SkPath::kWinding_FillType);
-    path.moveTo(1, 5);
-    path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
-    path.close();
-    pathB.setFillType(SkPath::kWinding_FillType);
-    pathB.moveTo(0, 1);
-    pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5);
-    pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
-}
-
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
-static void loops42i(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path, pathB;
-    path.setFillType(SkPath::kWinding_FillType);
-    path.moveTo(1, 6);
-    path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
-    path.close();
-    pathB.setFillType(SkPath::kWinding_FillType);
-    pathB.moveTo(0, 2);
-    pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6);
-    pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
-}
-
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
-static void loops43i(skiatest::Reporter* reporter, const char* filename) {
-    SkPath path, pathB;
-    path.setFillType(SkPath::kWinding_FillType);
-    path.moveTo(2, 6);
-    path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
-    path.close();
-    pathB.setFillType(SkPath::kWinding_FillType);
-    pathB.moveTo(1, 2);
-    pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
-    pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
-}
-
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops44i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 5);
     path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 1);
     pathB.cubicTo(7.33333302f, 5.33333349f, -7, 7, 1, 5);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops45i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 6);
     path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 2);
     pathB.cubicTo(7.33333302f, 6.33333302f, -7, 8, 1, 6);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops46i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 6);
     path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 2);
     pathB.cubicTo(8.33333302f, 6.33333302f, -6, 8, 2, 6);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 /*
 FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops47i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 4);
     path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 1);
     pathB.cubicTo(6, 5.83333302f, -4, 8, 2, 4);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops48i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 6);
     path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 1);
     pathB.cubicTo(9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f, 2, 6);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops49i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 2);
     path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 4);
     pathB.cubicTo(-0.166666687f, 2.66666675f, 1.66666675f, 2, 0, 2);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops50i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 3);
     path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 5);
     pathB.cubicTo(-0.166666687f, 3.66666675f, 1.66666675f, 3, 0, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops51i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 2);
     path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(2, 4);
     pathB.cubicTo(0.833333313f, 2.66666675f, 2.66666675f, 2, 1, 2);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops52i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 3);
     path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(2, 5);
     pathB.cubicTo(0.833333313f, 3.66666675f, 2.66666675f, 3, 1, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops53i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 3);
     path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(3, 5);
     pathB.cubicTo(1.83333325f, 3.66666675f, 3.66666651f, 3, 2, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops54i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 2);
     path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 4);
     pathB.cubicTo(0, 3, 1.66666675f, 2, 0, 2);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops55i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 3);
     path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 5);
     pathB.cubicTo(0, 4, 1.66666675f, 3, 0, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops56i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 2);
     path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(2, 4);
     pathB.cubicTo(0.99999994f, 3, 2.66666675f, 2, 1, 2);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops57i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(1, 3);
     path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(2, 5);
     pathB.cubicTo(0.99999994f, 4, 2.66666675f, 3, 1, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
 static void loops58i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(2, 3);
     path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(3, 5);
     pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
     pathB.close();
-    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-/*
-FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346     0 */
+static void loops58iAsQuads(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(2, 3);
+    path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(3, 5);
+    pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
+    pathB.close();
+    SkPath qPath, qPathB;
+    CubicPathToQuads(path, &qPath);
+    CubicPathToQuads(pathB, &qPathB);
+//    SkPoint from = {2.61714339f,1.90228665f};
+//    SkPoint to = {2.617045833359139f,1.9013528935803314f};
+//    path_edit(from, to, &qPathB);
+    testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
+}
+
 static void loops59i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 6);
     path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 2);
     pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
-class PathTest_Private {
-public:
-    PathTest_Private(SkPath* path)
-        : fPath(path) {}
-
-    void setPt(int index, SkScalar x, SkScalar y) {
-        fPath->setPt(index, x, y);
-    }
-
-    SkPath* fPath;
-};
-
-static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
-    PathTest_Private testPath(path);
-    for (int index = 0; index < path->countPoints(); ++index) {
-        if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
-            testPath.setPt(index, to.fX, to.fY);
-            return;
-        }
-    }
-}
-
 static void loops59iasQuads(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 6);
     path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 2);
     pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
     pathB.close();
@@ skipping 12 matching lines @@
     path.moveTo(0, 1);
     path.cubicTo(1, 4, 3, 0, 3, 1);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 3);
     pathB.cubicTo(1, 3, 1, 0, 4, 1);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
 }
 
+void loops61i(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(0, 1);
+    path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(1, 5);
+    pathB.cubicTo(-6.33333302f, 0.666666627f, 8, -1, 0, 1);
+    pathB.close();
+    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+}
+
+static void loops62i(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(0, 2);
+    path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(1, 6);
+    pathB.cubicTo(-6.33333302f, 1.66666663f, 8, 0, 0, 2);
+    pathB.close();
+    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+}
+
+static void loops63i(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(0, 1);
+    path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(2, 4);
+    pathB.cubicTo(-4, -0.833333254f, 6, -3, 0, 1);
+    pathB.close();
+    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
+}
+
+static void cubics44d(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(3, 4);
+    path.cubicTo(2, 5, 3, 1, 6, 2);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(1, 3);
+    pathB.cubicTo(2, 6, 4, 3, 5, 2);
+    pathB.close();
+    testPathOpCheck(reporter, path, pathB, kDifference_SkPathOp, filename, FLAGS_runFail);
+}
+
+static void cubics45u(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(1, 3);
+    path.cubicTo(2, 6, 4, 3, 5, 2);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(3, 4);
+    pathB.cubicTo(2, 5, 3, 1, 6, 2);
+    pathB.close();
+    testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, FLAGS_runFail);
+}
+
 static void (*skipTest)(skiatest::Reporter* , const char* filename) = 0;
-static void (*firstTest)(skiatest::Reporter* , const char* filename) = loops59i;
+static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
+#define TEST(name) { name, #name }
+
 static struct TestDesc tests[] = {
+    TEST(cubics44d),
+    TEST(cubics45u),
+    TEST(loops61i),
+    TEST(loops62i),
+    TEST(loops63i),
+    TEST(loops58iAsQuads),
     TEST(cubics41d),
     TEST(loops59iasQuads),
     TEST(loops59i),
-    TEST(loops41i),
-    TEST(loops42i),
-    TEST(loops43i),
     TEST(loops44i),
     TEST(loops45i),
     TEST(loops46i),
     TEST(loops47i),
     TEST(loops48i),
     TEST(loops49i),
     TEST(loops50i),
     TEST(loops51i),
     TEST(loops52i),
     TEST(loops53i),
@@ skipping 55 matching lines @@
     TEST(loops5i),
     TEST(cubicOp140),
     TEST(cubicOp139),
     TEST(cubics138),
     TEST(cubics137),
     TEST(cubicOp136a),
     TEST(cubicOp136),
     TEST(cubicOp135),
     TEST(cubicOp134),
     TEST(cubicOp133),
-    TEST(loop16),
-    TEST(loop15),
     TEST(loop12),
     TEST(cubicOp132),
     TEST(loop11),
     TEST(loop10),
     TEST(circlesOp3),
     TEST(loop9),
     TEST(loop8),
     TEST(rects5),
     TEST(loop7),
     TEST(cubicOp130a),
@@ skipping 233 matching lines @@
     TEST(cubicOp6d),
     TEST(cubicOp5d),
     TEST(cubicOp3d),
     TEST(cubicOp2d),
     TEST(cubicOp1d),
 };
 
 static const size_t testCount = SK_ARRAY_COUNT(tests);
 
 static struct TestDesc subTests[] = {
-    TEST(loops40i),
-    TEST(loops39i),
-    TEST(loops38i),
-    TEST(loops37i),
-    TEST(loops36i),
-    TEST(loops35i),
-    TEST(loops34i),
-    TEST(loops33i),
-    TEST(loops32i),
-    TEST(loops31i),
-    TEST(loops30i),
-    TEST(loops29i),
-    TEST(loops28i),
-    TEST(loops27i),
-    TEST(loops26i),
-    TEST(loops25i),
-    TEST(loops24i),
-    TEST(loops23i),
-    TEST(loops22i),
-    TEST(loops21i),
-    TEST(loops20i),
-    TEST(cubics20d),
-    TEST(cubics6d),
-    TEST(cubics7d),
-    TEST(cubics8d),
-    TEST(cubics9d),
-    TEST(cubics10u),
-    TEST(cubics11i),
-    TEST(cubics12d),
-    TEST(cubics13d),
-    TEST(cubics14d),
-    TEST(cubics15d),
-    TEST(cubics16i),
-    TEST(cubics17d),
-    TEST(cubics18d),
-    TEST(cubics19d),
-    TEST(cubicOp157),
-    TEST(cubicOp142),
-    TEST(loops4i),
-    TEST(quadRect1),
-    TEST(quadRect2),
-    TEST(quadRect3),
-    TEST(quadRect4),
-    TEST(quadRect5),
-    TEST(quadRect6),
+    TEST(cubics45u),
+    TEST(loops61i),
+    TEST(loops62i),
 };
 
 static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
 
 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0;
 
-static bool runSubTests = false;
+static bool runSubTests = true;
 static bool runSubTestsFirst = true;
 static bool runReverse = false;
 
 DEF_TEST(PathOpsOp, reporter) {
 #if DEBUG_SHOW_TEST_NAME
     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
 #endif
     if (runSubTests && runSubTestsFirst) {
         RunTestSet(reporter, subTests, subTestCount, firstSubTest, NULL, stopTest, runReverse);
     }
     RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse);
     if (runSubTests && !runSubTestsFirst) {
         RunTestSet(reporter, subTests, subTestCount, firstSubTest, NULL, stopTest, runReverse);
     }
 }
 
 static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
     SkPath pathB;
     pathB.addRect(0,0, 300,16);
-    testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
+    testPathOpFailCheck(reporter, path, pathB, kUnion_SkPathOp, filename);
 }
 
 // m 100,0 60,170 -160,-110 200,0 -170,11000000000 z
 static void fuzz433(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1, path2;
     path1.moveTo(100,0);
     path1.lineTo(60,170);
     path1.lineTo(-160,-110);
     path1.lineTo(200,0);
     path1.lineTo(-170,11000000000.0f);
@@ skipping 166 matching lines @@
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 
     SkPath path2(path);
     testPathFailOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 
 static struct TestDesc failTests[] = {
+    TEST(fuzz487a),
     TEST(fuzz433),
     TEST(fuzz1),
     TEST(fuzz714),
-    TEST(fuzz487a),
     TEST(fuzz487b),
     TEST(fuzz433b),
     TEST(bufferOverflow),
 };
 
 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, NULL, NULL, NULL, false);
 }