cumulative pathops patch

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 348 matching lines @@
     pathB.cubicTo(717.766663f, 416.906738f, 720.162537f, 415.845551f, 722.354797f, 414.073608f);
     pathB.cubicTo(724.059875f, 412.69397f, 726.55957f, 410.981903f, 730.675537f, 410.124359f);
     pathB.cubicTo(729.75708f, 409.143066f, 729.213013f, 407.993042f, 729.213013f, 406.683289f);
     pathB.cubicTo(729.213013f, 399.630402f, 729.209045f, 396.103455f, 729.209045f, 389.047546f);
     pathB.cubicTo(729.209045f, 387.648956f, 730.577698f, 385.292023f, 730.583679f, 385.149261f);
     pathB.cubicTo(730.583679f, 385.149261f, 720.888306f, 378.762207f, 719.609497f, 378.947906f);
     pathB.cubicTo(719.275085f, 378.996826f, 717.872498f, 381.118164f, 716.868225f, 381.896851f);
     pathB.lineTo(716.868225f, 365.046783f);
     pathB.cubicTo(716.868225f, 363.740021f, 716.960083f, 363.043213f, 717.597961f, 362);
     pathB.cubicTo(715.331848f, 363.104095f, 714.19873f, 363.657166f, 711.928711f, 364.782227f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpeverytechpro_blogspot_com100(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1074.29285f, 627.292786f);
     path.quadTo(1074.58582f, 627, 1075, 627);
     path.lineTo(1117, 627);
     path.quadTo(1124.04163f, 627, 1129.02246f, 631.9776f);
     path.quadTo(1134, 636.958374f, 1134, 644);
@@ skipping 13 matching lines @@
     path.cubicTo(1132, 653.284302f, 1125.2843f, 660, 1117, 660);
     path.lineTo(1076, 660);
     path.lineTo(1076, 629);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1074, 627);
     pathB.lineTo(1075, 628);
     pathB.lineTo(1116.5f, 644.5f);
     pathB.lineTo(1134, 627);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpflite_com41(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(301.464081f, 424);
     path.lineTo(296, 433.46405f);
     path.lineTo(296, 433.810822f);
     path.lineTo(303.25589f, 438);
     path.lineTo(304.729736f, 438);
     path.lineTo(311, 427.139557f);
     path.lineTo(311, 426.305237f);
     path.lineTo(307.007202f, 424);
     path.lineTo(301.464081f, 424);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(302.849854f, 421.599762f);
     pathB.lineTo(311.510101f, 426.599762f);
     pathB.lineTo(304.510101f, 438.724121f);
     pathB.lineTo(295.849854f, 433.724121f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpilkoora_com37(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(818, 157);
     path.cubicTo(818, 148.715729f, 824.715698f, 142, 833, 142);
     path.lineTo(909, 142);
     path.lineTo(909, 143);
     path.lineTo(833, 143);
@@ skipping 11 matching lines @@
     path.lineTo(1170, 143);
     path.cubicTo(1177.73193f, 143, 1184, 149.268005f, 1184, 157);
     path.lineTo(1184, 926);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1185, 142);
     pathB.lineTo(1001.5f, 325.5f);
     pathB.lineTo(1001.5f, 782.5f);
     pathB.lineTo(1185, 966);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpmm4everfriends_com43(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(540.74231f, 215.922546f);
     path.cubicTo(540.893127f, 215.391159f, 541.443909f, 215.090134f, 541.972473f, 215.250168f);
     path.lineTo(581.213318f, 227.131104f);
     path.cubicTo(581.741882f, 227.291153f, 582.048157f, 227.851654f, 581.897339f, 228.383041f);
     path.lineTo(576.708923f, 246.663925f);
     path.cubicTo(576.558167f, 247.195297f, 576.007324f, 247.496338f, 575.47876f, 247.336288f);
     path.lineTo(536.237915f, 235.455353f);
     path.cubicTo(535.709351f, 235.295319f, 535.403137f, 234.734802f, 535.553894f, 234.20343f);
     path.lineTo(540.74231f, 215.922546f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(541.015381f, 214.960388f);
     pathB.lineTo(582.17041f, 227.420883f);
     pathB.lineTo(576.435852f, 247.626068f);
     pathB.lineTo(535.280823f, 235.165573f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpmtrk_uz27(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(33, 787);
     path.lineTo(33, 412);
     path.lineTo(1233, 412);
     path.lineTo(1233, 787);
     path.quadTo(1233, 793.213196f, 1228.60803f, 797.607971f);
     path.quadTo(1224.21326f, 802, 1218, 802);
     path.lineTo(48, 802);
     path.quadTo(41.7867966f, 802, 37.3919983f, 797.607971f);
     path.quadTo(33, 793.213196f, 33, 787);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(33, 412);
     pathB.lineTo(1233, 412);
     pathB.lineTo(1233, 787);
     pathB.quadTo(1233, 793.213196f, 1228.60791f, 797.608032f);
     pathB.quadTo(1224.21313f, 802, 1218, 802);
     pathB.lineTo(48, 802);
     pathB.quadTo(41.7867432f, 802, 37.3919678f, 797.608032f);
     pathB.quadTo(33, 793.213196f, 33, 787);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpfrauen_magazin_com83(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(808, 886);
     path.cubicTo(805.581055f, 886, 803.563293f, 887.717773f, 803.100037f, 890);
     path.lineTo(1122.90002f, 890);
     path.cubicTo(1122.43677f, 887.717773f, 1120.41895f, 886, 1118, 886);
     path.lineTo(808, 886);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(808, 886);
     pathB.lineTo(1118, 886);
     pathB.cubicTo(1120.76147f, 886, 1123, 888.238586f, 1123, 891);
     pathB.lineTo(1123, 1521);
     pathB.cubicTo(1123, 1523.20911f, 1120.76147f, 1525, 1118, 1525);
     pathB.lineTo(808, 1525);
     pathB.cubicTo(805.238586f, 1525, 803, 1523.20911f, 803, 1521);
     pathB.lineTo(803, 891);
     pathB.cubicTo(803, 888.238586f, 805.238586f, 886, 808, 886);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpi_gino_com16(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(184, 734);
     path.quadTo(133.051727f, 734, 97.0258636f, 770.025879f);
     path.quadTo(61, 806.051758f, 61, 857);
     path.quadTo(61, 895.835083f, 81.9317017f, 926);
     path.lineTo(286.068298f, 926);
     path.quadTo(307, 895.835083f, 307, 857);
     path.quadTo(307, 806.051758f, 270.974121f, 770.025879f);
     path.quadTo(234.948273f, 734, 184, 734);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(185, 734);
     pathB.cubicTo(252.93103f, 734, 308, 789.06897f, 308, 857);
     pathB.cubicTo(308, 924.93103f, 252.93103f, 980, 185, 980);
     pathB.lineTo(184, 980);
     pathB.cubicTo(116.068977f, 980, 61, 924.93103f, 61, 857);
     pathB.cubicTo(61, 789.06897f, 116.068977f, 734, 184, 734);
     pathB.lineTo(185, 734);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skppchappy_com_au102(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(363, 493);
     path.cubicTo(360.790863f, 493, 359, 494.790863f, 359, 497);
     path.lineTo(359, 656);
     path.cubicTo(359, 658.209106f, 360.790863f, 660, 363, 660);
     path.lineTo(623.001709f, 660);
     path.cubicTo(624.657776f, 659.999023f, 626, 658.65625f, 626, 657);
     path.lineTo(626, 496);
     path.cubicTo(626, 494.343872f, 624.657959f, 493.00116f, 623.002075f, 493);
     path.lineTo(363, 493);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(362, 494);
     pathB.lineTo(623, 494);
     pathB.cubicTo(624.65686f, 494, 626, 494.895416f, 626, 496);
     pathB.lineTo(626, 657);
     pathB.cubicTo(626, 658.65686f, 624.65686f, 660, 623, 660);
     pathB.lineTo(362, 660);
     pathB.cubicTo(360.34314f, 660, 359, 658.65686f, 359, 657);
     pathB.lineTo(359, 496);
     pathB.cubicTo(359, 494.895416f, 360.34314f, 494, 362, 494);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpsciality_com161(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(656, 728);
     path.cubicTo(653.790833f, 728, 652, 729.790833f, 652, 732);
     path.lineTo(652, 789);
     path.cubicTo(652, 791.209106f, 653.790833f, 793, 656, 793);
     path.lineTo(769.001282f, 793);
     path.cubicTo(770.657532f, 792.999268f, 772, 791.656433f, 772, 790);
     path.lineTo(772, 731);
     path.cubicTo(772, 729.34314f, 770.65686f, 728, 769, 728);
     path.lineTo(656, 728);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(655, 729);
     pathB.lineTo(769, 729);
     pathB.cubicTo(770.65686f, 729, 772, 729.895447f, 772, 731);
     pathB.lineTo(772, 790);
     pathB.cubicTo(772, 791.65686f, 770.65686f, 793, 769, 793);
     pathB.lineTo(655, 793);
     pathB.cubicTo(653.34314f, 793, 652, 791.65686f, 652, 790);
     pathB.lineTo(652, 731);
     pathB.cubicTo(652, 729.895447f, 653.34314f, 729, 655, 729);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpsudoestenegocios_com186(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 495);
     path.lineTo(1.23685242e-14f, 293);
     path.lineTo(44, 293);
     path.quadTo(45.6568527f, 293, 46.8288002f, 294.171204f);
     path.quadTo(48, 295.34314f, 48, 297);
     path.lineTo(48, 491);
     path.quadTo(48, 492.65686f, 46.8288002f, 493.828796f);
     path.quadTo(45.6568527f, 495, 44, 495);
     path.lineTo(0, 495);
     path.close();
     path.moveTo(1, 294);
     path.lineTo(44, 294);
     path.cubicTo(45.6568565f, 294, 47, 295.34314f, 47, 297);
     path.lineTo(47, 491);
     path.cubicTo(47, 492.65686f, 45.6568565f, 494, 44, 494);
     path.lineTo(1, 494);
     path.lineTo(1, 294);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(48, 495);
     pathB.lineTo(24, 471);
     pathB.lineTo(24, 317);
     pathB.lineTo(48, 293);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpthesuburbanite_com213(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(863.439026f, 692);
     path.lineTo(863.283264f, 692);
     path.lineTo(802, 708.420837f);
     path.lineTo(802, 718.773621f);
     path.lineTo(866, 701.624817f);
     path.lineTo(866, 701.557922f);
     path.lineTo(863.439026f, 692);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(783.256775f, 713.443054f);
     pathB.lineTo(863.428589f, 691.96106f);
     pathB.lineTo(866.016724f, 701.620361f);
     pathB.lineTo(785.84491f, 723.102356f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skphostloco_com11(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(6.66133815e-16f, 648);
     path.lineTo(25.8522835f, 648);
     path.quadTo(27.5087376f, 647.999634f, 28.6807098f, 646.82843f);
     path.quadTo(29.8518829f, 645.656433f, 29.8522835f, 644);
     path.lineTo(29.8522835f, 467);
     path.quadTo(29.8518829f, 465.343536f, 28.6807098f, 464.17157f);
     path.quadTo(27.5087376f, 463.000397f, 25.8522835f, 463);
     path.lineTo(2.22044605e-16f, 463);
     path.lineTo(6.66133815e-16f, 648);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(0, 463);
     pathB.lineTo(30, 463);
     pathB.lineTo(30, 648);
     pathB.lineTo(0, 648);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpsergeychunkevich_com8(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);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(37, 374);
     pathB.lineTo(37, 535);
     pathB.cubicTo(37, 536.65686f, 35.6568565f, 538, 34, 538);
     pathB.lineTo(1.02866934e-14f, 538);
     pathB.lineTo(6.12303177e-17f, 371);
     pathB.lineTo(34, 371);
     pathB.cubicTo(35.6568565f, 371, 37, 372.34314f, 37, 374);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skptracksflow_com9(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(16, 56);
     path.lineTo(32, 56);
     path.lineTo(32, 72);
     path.lineTo(16, 72);
     path.lineTo(16, 56);
@@ skipping 13 matching lines @@
     pathB.cubicTo(30.2668133f, 71.875f, 30.5524693f, 71.9992828f, 30.868f, 71.9992828f);
     pathB.cubicTo(31.4994049f, 71.9992828f, 32.0014687f, 71.4909363f, 32.0014687f, 70.8595276f);
     pathB.cubicTo(32.0015335f, 70.5439072f, 31.875f, 70.2623444f, 31.65625f, 70.0555649f);
     pathB.close();
     pathB.moveTo(18.0054054f, 62.0027809f);
     pathB.cubicTo(18.0054054f, 59.7925949f, 19.7970943f, 58.0009079f, 22.0072823f, 58.0009079f);
     pathB.cubicTo(24.2174377f, 58.0009079f, 26.0091248f, 59.7925949f, 26.0091248f, 62.0027809f);
     pathB.cubicTo(26.0091248f, 64.2129364f, 24.2174377f, 66.0046234f, 22.0072803f, 66.0046234f);
     pathB.cubicTo(19.7970943f, 66.0045929f, 18.0054054f, 64.2129059f, 18.0054054f, 62.0027809f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpautobutler_dk29(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);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(21, 162);
     pathB.lineTo(21, 301);
     pathB.lineTo(8.57224448e-15f, 301);
     pathB.lineTo(6.12303177e-17f, 162);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skponlinecollege_org144(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(179, 407);
     path.cubicTo(177.34314f, 407, 176, 408.34314f, 176, 410);
     path.lineTo(176, 436);
     path.cubicTo(176, 437.65686f, 177.34314f, 439, 179, 439);
     path.lineTo(337.002289f, 439);
     path.cubicTo(338.105835f, 438.998779f, 339, 438.103821f, 339, 437);
     path.lineTo(339, 409);
     path.cubicTo(339, 407.896362f, 338.10611f, 407.001526f, 337.002838f, 407);
     path.lineTo(179, 407);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(179, 408);
     pathB.lineTo(337, 408);
     pathB.cubicTo(338.65686f, 408, 340, 408.895416f, 340, 410);
     pathB.lineTo(340, 436);
     pathB.cubicTo(340, 437.65686f, 338.65686f, 439, 337, 439);
     pathB.lineTo(179, 439);
     pathB.cubicTo(177.895432f, 439, 177, 437.65686f, 177, 436);
     pathB.lineTo(177, 410);
     pathB.cubicTo(177, 408.895416f, 177.895432f, 408, 179, 408);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpnational_com_au81(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(807, 817);
     path.quadTo(806.585876f, 817.000122f, 806.292908f, 817.292908f);
     path.quadTo(806.000122f, 817.585876f, 806, 818);
     path.lineTo(806, 881);
     path.lineTo(1111, 881);
     path.lineTo(1111, 818);
     path.quadTo(1110.99988f, 817.585876f, 1110.70715f, 817.292908f);
     path.quadTo(1110.41406f, 817.000122f, 1110, 817);
     path.lineTo(807, 817);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(807, 817);
     pathB.lineTo(1110, 817);
     pathB.cubicTo(1110.55225f, 817, 1111, 817.447693f, 1111, 818);
     pathB.lineTo(1111, 880);
     pathB.lineTo(806, 880);
     pathB.lineTo(806, 818);
     pathB.cubicTo(806, 817.447693f, 806.447693f, 817, 807, 817);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skprentacheat_com30(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(967, 263);
     path.quadTo(966.585876f, 263.000092f, 966.292908f, 263.292908f);
     path.quadTo(966.000122f, 263.585876f, 966, 264);
     path.lineTo(966, 301);
     path.lineTo(1214, 301);
     path.lineTo(1214, 264);
     path.quadTo(1213.99988f, 263.585876f, 1213.70715f, 263.292908f);
     path.quadTo(1213.41406f, 263.000092f, 1213, 263);
     path.lineTo(967, 263);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(967, 263);
     pathB.lineTo(1213, 263);
     pathB.cubicTo(1213.55225f, 263, 1214, 263.447723f, 1214, 264);
     pathB.lineTo(1214, 300);
     pathB.lineTo(966, 300);
     pathB.lineTo(966, 264);
     pathB.cubicTo(966, 263.447723f, 966.447693f, 263, 967, 263);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpbreakmystyle_com10(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(271.032867f, -5.32907052e-15f);
     path.lineTo(56.9671326f, -5.16253706e-15f);
     path.quadTo(52.7835083f, 3.69968891f, 48.7416f, 7.74160004f);
     path.quadTo(1, 55.4831848f, 1, 123);
     path.quadTo(1, 190.516815f, 48.7416f, 238.258392f);
     path.quadTo(96.4831848f, 286, 164, 286);
     path.quadTo(231.516815f, 286, 279.258392f, 238.258392f);
     path.quadTo(327, 190.516815f, 327, 123);
     path.quadTo(327, 55.4831848f, 279.258392f, 7.74160004f);
     path.quadTo(275.216431f, 3.69964004f, 271.032867f, -5.32907052e-15f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(327, 123);
     pathB.quadTo(327, 190.516815f, 279.258392f, 238.258392f);
     pathB.quadTo(231.516815f, 286, 164, 286);
     pathB.quadTo(96.4831848f, 286, 48.7416f, 238.258392f);
     pathB.quadTo(1, 190.516815f, 1, 123);
     pathB.quadTo(1, 55.4831848f, 48.7416f, 7.74160004f);
     pathB.quadTo(96.4831848f, -40, 164, -40);
     pathB.quadTo(231.516815f, -40, 279.258392f, 7.74160004f);
     pathB.quadTo(327, 55.4831848f, 327, 123);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpsd_graphic_net104(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(475.421448f, 836.985962f);
     path.lineTo(461.280975f, 841.990662f);
     path.cubicTo(466.80899f, 857.609802f, 458.62854f, 874.752991f, 443.009399f, 880.281006f);
     path.cubicTo(435.199829f, 883.044983f, 427.009247f, 882.381897f, 420.080048f, 879.075378f);
     path.lineTo(413.620056f, 892.613037f);
     path.quadTo(430.419983f, 900.629761f, 447.96701f, 894.43811f);
     path.quadTo(448.00708f, 894.42395f, 448.014038f, 894.421509f);
     path.quadTo(448.043976f, 894.410889f, 448.061066f, 894.404846f);
     path.quadTo(465.596313f, 888.179932f, 473.613037f, 871.379944f);
     path.quadTo(477.351227f, 863.546143f, 478, 855.549866f);
     path.lineTo(478, 848.804321f);
     path.quadTo(477.528076f, 842.93811f, 475.421448f, 836.985962f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.quadTo(474.58313f, 384.999298f, 434, 385);
     path.lineTo(433, 385);
     path.quadTo(431.75766f, 384.999695f, 430.878693f, 384.121307f);
     path.quadTo(430.000305f, 383.24234f, 430, 382);
     path.lineTo(430, 280);
     path.quadTo(430.009796f, 277.101196f, 458.703552f, 275.050262f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(528, 278);
     pathB.lineTo(529, 278);
     pathB.cubicTo(530.65686f, 278, 532, 278, 532, 278);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.quadTo(467.275146f, 552.856262f, 465.84668f, 547.288391f);
     path.quadTo(465.670349f, 546.601501f, 465.503998f, 546);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(363.052246f, 542.495361f);
     pathB.lineTo(463.779907f, 542.671143f);
     pathB.cubicTo(464.829529f, 542.672974f, 466.946289f, 550.755676f, 468.507751f, 560.724426f);
     pathB.lineTo(470.591064f, 574.024353f);
     pathB.cubicTo(476.26178f, 610.226624f, 471.498932f, 639.557922f, 459.953003f, 639.537781f);
     pathB.lineTo(368.727936f, 639.378601f);
     pathB.cubicTo(351.933868f, 639.349304f, 337.053741f, 631.244324f, 335.492249f, 621.275574f);
     pathB.lineTo(325.968597f, 560.475708f);
     pathB.cubicTo(324.407104f, 550.506958f, 341.01001f, 542.456909f, 363.052246f, 542.495361f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpredbullskatearcade_es16(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(936.765625f, 458.965302f);
     path.cubicTo(937.028442f, 453.863251f, 933.145813f, 449.864502f, 928.093445f, 450.033905f);
     path.lineTo(661.882263f, 458.958862f);
     path.lineTo(661.875366f, 458.959106f);
     path.cubicTo(656.828369f, 459.13205f, 652.525085f, 463.399719f, 652.258545f, 468.496124f);
@@ skipping 10 matching lines @@
     pathB.moveTo(661.882263f, 458.958862f);
     pathB.lineTo(928.093445f, 450.033905f);
     pathB.cubicTo(929.103882f, 450, 929.709961f, 454.108612f, 929.447144f, 459.210663f);
     pathB.lineTo(926.210693f, 522.029724f);
     pathB.cubicTo(926.079224f, 524.58075f, 925.153442f, 526.676208f, 924.143066f, 526.710083f);
     pathB.lineTo(657.931885f, 535.635071f);
     pathB.cubicTo(652.879456f, 535.804443f, 648.890259f, 533.873779f, 649.021729f, 531.322754f);
     pathB.lineTo(652.258179f, 468.503662f);
     pathB.cubicTo(652.520996f, 463.401611f, 656.829834f, 459.128235f, 661.882263f, 458.958862f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpfinanzasdigital_com9(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(156, 126);
     path.quadTo(154.343552f, 126.000397f, 153.17157f, 127.17157f);
     path.quadTo(152.000397f, 128.343552f, 152, 130);
     path.lineTo(152, 174);
     path.lineTo(1114, 174);
     path.lineTo(1114, 130);
     path.quadTo(1113.99963f, 128.343552f, 1112.82837f, 127.17157f);
     path.quadTo(1111.65649f, 126.000397f, 1110, 126);
     path.lineTo(156, 126);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(156, 126);
     pathB.lineTo(1110, 126);
     pathB.cubicTo(1111.65686f, 126, 1113, 127.790863f, 1113, 130);
     pathB.lineTo(1113, 174);
     pathB.lineTo(153, 174);
     pathB.lineTo(153, 130);
     pathB.cubicTo(153, 127.790863f, 154.34314f, 126, 156, 126);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skppartainasdemo250_org56(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(182.000015f, 645);
     path.lineTo(182, 640);
     path.cubicTo(174.322327f, 640, 166.644669f, 637.071045f, 160.786804f, 631.213196f);
     path.cubicTo(149.071075f, 619.497437f, 149.071075f, 600.502563f, 160.786804f, 588.786804f);
     path.lineTo(157.251266f, 585.251221f);
     path.quadTo(147, 595.502502f, 147.000015f, 610);
     path.quadTo(147, 624.482605f, 157.230255f, 634.727722f);
     path.quadTo(157.251251f, 634.748779f, 157.251282f, 634.748779f);
     path.quadTo(157.282852f, 634.780334f, 157.272263f, 634.769775f);
     path.quadTo(167.517334f, 645, 182.000015f, 645);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(182, 659.497498f);
     pathB.lineTo(206.748749f, 634.748718f);
     pathB.lineTo(182.000015f, 610);
     pathB.lineTo(132.502533f, 610);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpmlk_com326(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(154, 670);
     path.cubicTo(151.238571f, 670, 149, 672.238586f, 149, 675);
     path.lineTo(149, 710.001465f);
     path.cubicTo(149.000809f, 712.209961f, 150.791367f, 714, 153, 714);
     path.lineTo(189, 714);
     path.cubicTo(191.209137f, 714, 193, 712.209167f, 193, 710);
     path.lineTo(193, 675);
     path.cubicTo(193, 672.238586f, 190.761429f, 670, 188, 670);
     path.lineTo(154, 670);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     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();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOpCheck(reporter, path, pathB, kIntersect_SkPathOp, filename, FLAGS_runFail);
 }
 
 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();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    // 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_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.cubicTo(807.34314f, 94, 806, 92.6568527f, 806, 91);
     path.lineTo(806, 57);
     path.close();
     path.moveTo(808, 58);
     path.cubicTo(808, 56.8954315f, 808.895447f, 56, 810, 56);
     path.lineTo(929, 56);
     path.cubicTo(930.104553f, 56, 931, 56.8954315f, 931, 58);
     path.lineTo(931, 90);
     path.cubicTo(931, 91.1045685f, 930.104553f, 92, 929, 92);
     path.lineTo(810, 92);
     path.cubicTo(808.895447f, 92, 808, 91.1045685f, 808, 90);
     path.lineTo(808, 58);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.cubicTo(91.3431473f, 221, 90, 219.65686f, 90, 218);
     path.lineTo(90, 187);
     path.close();
     path.moveTo(92, 188);
     path.cubicTo(92, 186.895432f, 92.8954315f, 186, 94, 186);
     path.lineTo(587, 186);
     path.cubicTo(588.104553f, 186, 589, 186.895432f, 589, 188);
     path.lineTo(589, 217);
     path.cubicTo(589, 218.104568f, 588.104553f, 219, 587, 219);
     path.lineTo(94, 219);
     path.cubicTo(92.8954315f, 219, 92, 218.104568f, 92, 217);
     path.lineTo(92, 188);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.cubicTo(636.34314f, 1815, 635, 1813.65686f, 635, 1812);
     path.lineTo(635, 1788);
     path.close();
     path.moveTo(637, 1789);
     path.cubicTo(637, 1787.89539f, 637.895447f, 1787, 639, 1787);
     path.lineTo(831, 1787);
     path.cubicTo(832.104553f, 1787, 833, 1787.89539f, 833, 1789);
     path.lineTo(833, 1811);
     path.cubicTo(833, 1812.10461f, 832.104553f, 1813, 831, 1813);
     path.lineTo(639, 1813);
     path.cubicTo(637.895447f, 1813, 637, 1812.10461f, 637, 1811);
     path.lineTo(637, 1789);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(835, 1785);
     pathB.lineTo(833, 1787);
     pathB.lineTo(832.97998f, 1817.02002f);
     pathB.lineTo(835, 1815);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_joomla_org_23(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(320, 347);
     path.cubicTo(320, 344.238586f, 322.238586f, 342, 325, 342);
     path.lineTo(416, 342);
     path.cubicTo(418.761414f, 342, 421, 344.238586f, 421, 347);
     path.cubicTo(421, 344.790863f, 418.761414f, 343, 416, 343);
     path.lineTo(325, 343);
     path.cubicTo(322.238586f, 343, 320, 344.790863f, 320, 347);
     path.close();
     path.moveTo(320, 378);
     path.cubicTo(320, 380.761414f, 322.238586f, 383, 325, 383);
     path.lineTo(416, 383);
     path.cubicTo(418.761414f, 383, 421, 380.761414f, 421, 378);
     path.cubicTo(421, 380.209137f, 418.761414f, 382, 416, 382);
     path.lineTo(325, 382);
     path.cubicTo(322.238586f, 382, 320, 380.209137f, 320, 378);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(320, 383);
     pathB.lineTo(320, 378);
     pathB.lineTo(421, 378.000031f);
     pathB.lineTo(421, 383);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_macrumors_com_131(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(136, 14089);
     path.lineTo(136, 14056);
     path.lineTo(778, 14056);
     path.lineTo(778, 14089);
     path.quadTo(777.999573f, 14090.6562f, 776.82843f, 14091.8281f);
     path.quadTo(775.656433f, 14093, 774, 14093);
     path.lineTo(140, 14093);
     path.quadTo(138.343552f, 14093, 137.17157f, 14091.8281f);
     path.quadTo(136.000397f, 14090.6562f, 136, 14089);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(136, 14057);
     pathB.lineTo(778, 14057);
     pathB.lineTo(778, 14089);
     pathB.cubicTo(778, 14091.209f, 776.209167f, 14093, 774, 14093);
     pathB.lineTo(140, 14093);
     pathB.cubicTo(137.790863f, 14093, 136, 14091.209f, 136, 14089);
     pathB.lineTo(136, 14057);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_leadpages_net_84(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(377.1716f, 5910.17139f);
     path.cubicTo(376.447723f, 5910.89551f, 376, 5911.89551f, 376, 5913);
     path.lineTo(376, 5972);
     path.cubicTo(376, 5974.20898f, 377.790863f, 5976, 380, 5976);
     path.cubicTo(378.34314f, 5976, 377, 5974.20898f, 377, 5972);
     path.lineTo(377, 5913);
     path.cubicTo(377, 5912.17139f, 377.335785f, 5911.42188f, 377.878693f, 5910.87891f);
     path.lineTo(377.1716f, 5910.17139f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(376, 5909);
     pathB.lineTo(378.481873f, 5909);
     pathB.lineTo(379.999878f, 5976);
     pathB.lineTo(376, 5976);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_briian_com_34(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(843, 216);
     path.cubicTo(843, 213.238571f, 845.238586f, 211, 848, 211);
     path.lineTo(1191, 211);
     path.cubicTo(1193.76147f, 211, 1196, 213.238571f, 1196, 216);
     path.lineTo(1196, 779);
@@ skipping 11 matching lines @@
     path.lineTo(849, 781);
     path.cubicTo(846.238586f, 781, 844, 779.65686f, 844, 778);
     path.lineTo(844, 217);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(843, 784);
     pathB.lineTo(843, 779);
     pathB.lineTo(1196, 779.000061f);
     pathB.lineTo(1196, 784);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_sciality_com_100(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(162, 468);
     path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
     path.lineTo(158, 528);
     path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
     path.lineTo(275, 532);
     path.cubicTo(277.209137f, 532, 279, 530.209106f, 279, 528);
     path.lineTo(279, 472);
     path.cubicTo(279, 469.790863f, 277.209137f, 468, 275, 468);
     path.lineTo(162, 468);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(275, 468);
     pathB.cubicTo(276.65686f, 468, 278, 469.34314f, 278, 471);
     pathB.lineTo(278, 529);
     pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532);
     pathB.lineTo(161, 532);
     pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529);
     pathB.lineTo(158, 471);
     pathB.cubicTo(158, 469.34314f, 159.34314f, 468, 161, 468);
     pathB.lineTo(275, 468);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_sciality_com_101(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(162, 468);
     path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
     path.lineTo(158, 528);
     path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
     path.lineTo(275.009186f, 532);
     path.cubicTo(276.661774f, 531.994995f, 278, 530.653748f, 278, 529);
     path.lineTo(278, 471);
     path.cubicTo(278, 469.346375f, 276.662079f, 468.005249f, 275.009705f, 468);
     path.lineTo(162, 468);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(161, 469);
     pathB.lineTo(275, 469);
     pathB.cubicTo(276.65686f, 469, 278, 469.895416f, 278, 471);
     pathB.lineTo(278, 529);
     pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532);
     pathB.lineTo(161, 532);
     pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529);
     pathB.lineTo(158, 471);
     pathB.cubicTo(158, 469.895416f, 159.34314f, 469, 161, 469);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_meb_gov_tr_5(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(137.34314f, 145.34314f);
     path.quadTo(139.687088f, 143.000793f, 143, 143);
     path.lineTo(242, 143);
     path.quadTo(245.312912f, 143.000793f, 247.65686f, 145.34314f);
     path.quadTo(249.999207f, 147.687088f, 250, 151);
     path.lineTo(250, 177);
     path.lineTo(135, 177);
     path.lineTo(135, 151);
     path.quadTo(135.000793f, 147.687088f, 137.34314f, 145.34314f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(135, 143);
     pathB.lineTo(250, 143);
     pathB.lineTo(250, 177);
     pathB.lineTo(135, 177);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_meb_gov_tr_6(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(143, 143);
     path.quadTo(139.687088f, 143.000793f, 137.34314f, 145.34314f);
     path.quadTo(135.000793f, 147.687088f, 135, 151);
     path.lineTo(135, 177);
     path.lineTo(250, 177);
     path.lineTo(250, 151);
     path.quadTo(249.999207f, 147.687088f, 247.65686f, 145.34314f);
     path.quadTo(245.312912f, 143.000793f, 242, 143);
     path.lineTo(143, 143);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(143, 143);
     pathB.lineTo(242, 143);
     pathB.cubicTo(245.865997f, 143, 249, 146.581726f, 249, 151);
     pathB.lineTo(249, 177);
     pathB.lineTo(135, 177);
     pathB.lineTo(135, 151);
     pathB.cubicTo(135, 146.581726f, 138.581726f, 143, 143, 143);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpgithub_io_25(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1001.87866f, 14.8786793f);
     path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
     path.lineTo(1105, 14);
     path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
     path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
@@ skipping 11 matching lines @@
     pathB.moveTo(1005, 16);
     pathB.lineTo(1104, 16);
     pathB.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18);
     pathB.lineTo(1106, 40);
     pathB.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42);
     pathB.lineTo(1005, 42);
     pathB.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40);
     pathB.lineTo(1003, 18);
     pathB.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpgithub_io_26(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1001.87866f, 14.8786793f);
     path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
     path.lineTo(1105, 14);
     path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
     path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
@@ skipping 15 matching lines @@
     path.lineTo(1005, 42);
     path.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40);
     path.lineTo(1003, 18);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1108, 14);
     pathB.lineTo(1106, 16);
     pathB.lineTo(1105.97998f, 46.0200005f);
     pathB.lineTo(1108, 44);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpskpicture14(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 994);
     path.lineTo(0, 0);
     path.lineTo(512, 0);
     path.lineTo(512, 994);
     path.lineTo(0, 994);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(-317, 168);
     pathB.quadTo(-317, 166.757385f, -316.121338f, 165.878662f);
     pathB.quadTo(-315.242645f, 165, -314, 165);
     pathB.lineTo(320, 165);
     pathB.quadTo(321.242615f, 165, 322.121338f, 165.878662f);
     pathB.quadTo(323, 166.757385f, 323, 168);
     pathB.lineTo(323, 193);
     pathB.lineTo(-317, 193);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpskpicture15(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 193);
     path.lineTo(323, 193);
     path.lineTo(323, 168);
     path.quadTo(323, 166.757385f, 322.121338f, 165.878662f);
     path.quadTo(321.242615f, 165, 320, 165);
     path.lineTo(0, 165);
     path.lineTo(0, 193);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     pathB.moveTo(-314, 165);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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 13 matching lines @@
     path.quadTo(816, 31.0710678f, 816, 29);
     path.lineTo(816, 15);
     path.quadTo(816, 12.9289322f, 817.464478f, 11.4644661f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.lineTo(991.633911f, 1839);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(964.267578f, 1838.73499f);
     pathB.lineTo(1019.26501f, 1839.26758f);
     pathB.lineTo(1018.73242f, 1894.26501f);
     pathB.lineTo(963.734985f, 1893.73242f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_alucinados_net_101(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1129.53552f, 1164.46448f);
     path.lineTo(1128, 1166);
     path.lineTo(1128.12231f, 1166.49548f);
     path.quadTo(1129, 1167.56592f, 1129, 1169);
     path.lineTo(1129, 1170.05054f);
     path.lineTo(1130.34509f, 1175.49878f);
     path.quadTo(1131, 1174.38513f, 1131, 1173);
     path.lineTo(1131, 1168);
     path.quadTo(1131, 1165.92896f, 1129.53552f, 1164.46448f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(741, 9433);
     pathB.lineTo(741, 9431.99023f);
     pathB.lineTo(761, 9432);
     pathB.lineTo(761, 9433);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_argus_presse_fr_41(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1000, 343);
     path.lineTo(165, 343);
     path.lineTo(165, 364.869873f);
     path.lineTo(1000, 364.869873f);
     path.lineTo(1000, 343);
     path.close();
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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 17 matching lines @@
     path.quadTo(3, 11849.2422f, 3, 11848);
     path.lineTo(3, 11834);
     path.quadTo(3, 11832.7578f, 3.87867975f, 11831.8789f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(998, 910);
     pathB.lineTo(998, 909);
     pathB.quadTo(998, 904.029419f, 1001.51471f, 900.514709f);
     pathB.quadTo(1005.02942f, 897, 1010, 897);
     pathB.lineTo(1011, 897);
     pathB.quadTo(1015.14215f, 897, 1018.07104f, 900.514709f);
     pathB.quadTo(1021, 904.029419f, 1021, 909);
     pathB.lineTo(1021, 910);
     pathB.quadTo(1021, 914.142151f, 1018.07104f, 917.071045f);
     pathB.quadTo(1015.14215f, 920, 1011, 920);
     pathB.lineTo(1010, 920);
     pathB.quadTo(1005.02942f, 920, 1001.51471f, 917.071045f);
     pathB.quadTo(998, 914.142151f, 998, 910);
     pathB.close();
-    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
 }
 
 static void skpwww_gruposejaumdivulgador_com_br_4(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(610.5f, 5.78626502e-14f);
     path.lineTo(1083.5f, -6.12303177e-17f);
     path.lineTo(1083.5f, 469);
     path.lineTo(610.5f, 469);
     path.lineTo(610.5f, 5.78626502e-14f);
     path.close();
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.lineTo(93.3823318f, 4);
     path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
     path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
     path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(83.7462997f, 3);
     pathB.lineTo(1222.74634f, 3);
     pathB.lineTo(1219.10657f, 13);
     pathB.lineTo(80.1065979f, 13);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_phototransferapp_com_24x(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(112.74634f, 3);
     path.quadTo(116.88843f, 3, 118.75134f, 5.92893219f);
     path.quadTo(120.61414f, 8.85775471f, 119.10669f, 12.9996767f);
     path.quadTo(120.46338f, 9.27196693f, 118.4939f, 6.63603878f);
     path.quadTo(116.52441f, 4, 112.38232f, 4);
     path.lineTo(93.3823318f, 4);
     path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
     path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
     path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(83.7462997f, 3);
     pathB.lineTo(122.74634f, 3);
     pathB.lineTo(119.10657f, 13);
     pathB.lineTo(80.1065979f, 13);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_helha_be_109(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(117.686981f, 3339.08423f);
     path.lineTo(109.533035f, 3350.72925f);
     path.quadTo(107.120552f, 3354.17456f, 103.879379f, 3354.41821f);
     path.quadTo(100.638504f, 3354.66187f, 98.4674301f, 3351.56177f);
     path.quadTo(100.87973f, 3355.00635f, 104.291222f, 3355.00635f);
     path.quadTo(107.70298f, 3355.00635f, 110.115463f, 3351.56104f);
     path.lineTo(118, 3340.30078f);
     path.lineTo(118, 3339.53125f);
     path.lineTo(117.686981f, 3339.08423f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(118.269409f, 3339.91602f);
     pathB.lineTo(117.686981f, 3339.08423f);
     pathB.lineTo(98.4669647f, 3351.56104f);
     pathB.lineTo(104.291214f, 3359.87891f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_cooksnaps_com_32(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(509.34021f, 176);
     path.lineTo(505, 176);
     path.quadTo(500.964233f, 176, 497.299988f, 176.896912f);
     path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f);
     path.lineTo(489.316986f, 180.4702f);
@@ skipping 31 matching lines @@
     pathB.lineTo(490.183014f, 179.9702f);
     pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f);
     pathB.quadTo(526.109497f, 180.196686f, 532.529785f, 191.316986f);
     pathB.lineTo(533.029785f, 192.183014f);
     pathB.quadTo(539.450134f, 203.303314f, 536.126709f, 215.70639f);
     pathB.quadTo(532.803345f, 228.109497f, 521.683044f, 234.5298f);
     pathB.lineTo(520.817017f, 235.0298f);
     pathB.quadTo(509.696686f, 241.450104f, 497.29361f, 238.126709f);
     pathB.quadTo(484.890533f, 234.803314f, 478.470215f, 223.683014f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_cooksnaps_com_32a(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(497.299988f, 176.896912f);
     path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f);
     path.lineTo(489.316986f, 180.4702f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(32.3243904f, 851);
     pathB.lineTo(459.324402f, 851);
     pathB.lineTo(427, 1081);
     pathB.lineTo(-3.81469727e-06f, 1081);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_tunero_de_24(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1020.79303f, 2252);
     path.quadTo(1018.72198f, 2252, 1016.86798f, 2253.46436f);
     path.quadTo(1015.02032f, 2254.92383f, 1014.4668f, 2256.98584f);
     path.lineTo(1014.46301f, 2257);
     path.lineTo(1011.53705f, 2268);
@@ skipping 18 matching lines @@
     pathB.lineTo(1088.79297f, 2252);
     pathB.quadTo(1090.86414f, 2252, 1091.93909f, 2253.46436f);
     pathB.quadTo(1093.01392f, 2254.92896f, 1092.46301f, 2257);
     pathB.lineTo(1089.53711f, 2268);
     pathB.quadTo(1088.98608f, 2270.07104f, 1087.13208f, 2271.53564f);
     pathB.quadTo(1085.27808f, 2273, 1083.20703f, 2273);
     pathB.lineTo(1015.20703f, 2273);
     pathB.quadTo(1013.13599f, 2273, 1012.06104f, 2271.53564f);
     pathB.quadTo(1010.98615f, 2270.07104f, 1011.53705f, 2268);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_docgelo_com_66(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(22.5f, 24174.5f);
     path.lineTo(185.5f, 24174.498f);
     path.lineTo(185.5f, 24174.75f);
     path.lineTo(22.5f, 24174.75f);
     path.lineTo(22.5f, 24174.5f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(22.5f, 24174.75f);
     pathB.lineTo(22.5f, 24174.498f);
     pathB.lineTo(185.5f, 24174.5f);
     pathB.lineTo(185.5f, 24174.75f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_kpopexplorer_net_22(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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
 }
 
 static void skpwww_artblart_com_8(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(22.5f, 24527.25f);
     path.lineTo(45, 24527.248f);
     path.lineTo(45, 24527.5f);
     path.lineTo(22.5f, 24527.5f);
     path.lineTo(22.5f, 24527.25f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, 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 275 matching lines @@
     pathB.cubicTo(629.594177f, 47.8615112f, 629.494507f, 47.457695f, 629.439453f, 46.9981461f);
     pathB.cubicTo(629.379211f, 46.4874115f, 629.348511f, 45.9550591f, 629.348511f, 45.4158859f);
     pathB.cubicTo(629.348511f, 45.2031708f, 629.351929f, 44.9870453f, 629.357971f, 44.7682648f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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 13 matching lines @@
     pathB.lineTo(996, 896);
     pathB.quadTo(998.071045f, 896, 999.535522f, 897.17157f);
     pathB.quadTo(1001, 898.34314f, 1001, 900);
     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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, 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);
     path.lineTo(90, 155.666672f);
     path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(90, 163.666672f);
     pathB.lineTo(90, 155.666672f);
     pathB.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
     pathB.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
     pathB.lineTo(124.666672f, 152.333344f);
     pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f);
     pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f);
     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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
 }
 
 static void skpwww_wartepop_blogspot_com_br_6a(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.666672f, 152.333344f);
     path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
     path.quadTo(128, 154.285965f, 128, 155.666672f);
@@ skipping 11 matching lines @@
     pathB.lineTo(124.666672f, 152.333344f);
     pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f);
     pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f);
     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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, 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 24 matching lines @@
     path.quadTo(362.286835f, 741.389526f, 361.471497f, 741.183289f);
     path.quadTo(361.102509f, 741.089966f, 360.740479f, 741.040771f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(355.654724f, 739.711792f);
     pathB.lineTo(367.288269f, 742.654724f);
     pathB.lineTo(364.345337f, 754.288269f);
     pathB.lineTo(352.711792f, 751.345337f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_evolvehq_com_210(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(172, 972);
     path.quadTo(170.757355f, 972, 169.878677f, 972.878662f);
     path.quadTo(169, 973.757385f, 169, 975);
     path.lineTo(169, 1171);
     path.quadTo(169, 1172.24268f, 169.878677f, 1173.12134f);
@@ skipping 15 matching lines @@
     pathB.lineTo(308, 973);
     pathB.quadTo(309.242645f, 973, 310.121307f, 973.585815f);
     pathB.quadTo(311, 974.17157f, 311, 975);
     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);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(10105, 2511);
     pathB.lineTo(10105, 2509.98999f);
     pathB.lineTo(10123, 2510);
     pathB.lineTo(10123, 2511);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_thaienews_blogspot_com_36(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(429.994995f, 6268);
     path.lineTo(430, 2187);
     path.lineTo(430.5f, 2187);
     path.lineTo(430.5f, 6268);
     path.lineTo(429.994995f, 6268);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(430.5f, 2187);
     pathB.lineTo(429.994995f, 2187);
     pathB.lineTo(430, 6268);
     pathB.lineTo(430.5f, 6268);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_fashionscandal_com_94(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(25.9107456f, 272.577423f);
     path.quadTo(26.1548233f, 272.333344f, 26.5000019f, 272.333344f);
     path.lineTo(131.166672f, 272.333344f);
     path.quadTo(131.511841f, 272.333344f, 131.75592f, 272.577423f);
     path.quadTo(132, 272.821503f, 132, 273.166687f);
@@ skipping 15 matching lines @@
     pathB.lineTo(131.166672f, 272.5f);
     pathB.quadTo(131.442825f, 272.5f, 131.638077f, 272.695251f);
     pathB.quadTo(131.833344f, 272.890533f, 131.833344f, 273.166656f);
     pathB.lineTo(131.833344f, 417.166656f);
     pathB.quadTo(131.833344f, 417.511841f, 131.638077f, 417.75592f);
     pathB.quadTo(131.442825f, 418, 131.166672f, 418);
     pathB.lineTo(26.5f, 418);
     pathB.quadTo(26.2238579f, 418, 26.0285969f, 417.75592f);
     pathB.quadTo(25.833334f, 417.511841f, 25.833334f, 417.166656f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
+    testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
 }
 
 static void skpwww_kenlevine_blogspot_com_28(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(276, 9506);
     path.lineTo(276, 7531);
     path.lineTo(277, 7531);
     path.lineTo(277.01001f, 9506);
     path.lineTo(276, 9506);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(276, 7531);
     pathB.lineTo(277.01001f, 7531);
     pathB.lineTo(277, 9506);
     pathB.lineTo(276, 9506);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_defense_studies_blogspot_com_64(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(276, 9600);
     path.lineTo(276, 7703);
     path.lineTo(277, 7703);
     path.lineTo(277.01001f, 9600);
     path.lineTo(276, 9600);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(276, 7703);
     pathB.lineTo(277.01001f, 7703);
     pathB.lineTo(277, 9600);
     pathB.lineTo(276, 9600);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_uniquefx_net_442(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(960, 306);
     path.lineTo(960, 305);
     path.lineTo(1000, 305);
     path.lineTo(1000, 306.708527f);
     path.lineTo(960, 306);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(960, 305);
     pathB.lineTo(958.997253f, 306.002747f);
     pathB.lineTo(1017, 307);
     pathB.lineTo(1019, 305);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_kitcheninspirations_wordpress_com_32(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(47.1666679f, 19651.334f);
     path.lineTo(65.8333359f, 19651.332f);
     path.lineTo(65.8333359f, 19651.5f);
     path.lineTo(47.1666679f, 19651.5f);
     path.lineTo(47.1666679f, 19651.334f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(47.1666679f, 19651.5f);
     pathB.lineTo(47.1666679f, 19651.332f);
     pathB.lineTo(65.8333359f, 19651.334f);
     pathB.lineTo(65.8333359f, 19651.5f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_educationalcraft_com_4(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);
@@ skipping 157 matching lines @@
     pathB.cubicTo(979.481995f, 1470.27405f, 977.138f, 1468.82605f, 979.197998f, 1465.50598f);
     pathB.close();
     pathB.moveTo(980.900024f, 1474.328f);
     pathB.cubicTo(980.900024f, 1474.328f, 978.893005f, 1471.95703f, 981.791016f, 1469.48706f);
     pathB.cubicTo(981.791016f, 1469.48596f, 983.358032f, 1472.729f, 980.900024f, 1474.328f);
     pathB.close();
     pathB.moveTo(980.968994f, 1478.18005f);
     pathB.cubicTo(980.968994f, 1478.18005f, 979.718018f, 1475.66199f, 983.632019f, 1473.87805f);
     pathB.cubicTo(983.632019f, 1473.87805f, 984.229004f, 1477.80103f, 980.968994f, 1478.18005f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_narayana_publishers_com_194(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1083.34314f, 445.65686f);
     path.quadTo(1081, 443.313721f, 1081, 440);
     path.lineTo(1257, 440);
     path.quadTo(1257, 443.313721f, 1254.65686f, 445.65686f);
     path.quadTo(1252.31372f, 448, 1249, 448);
     path.lineTo(1089, 448);
     path.quadTo(1085.68628f, 448, 1083.34314f, 445.65686f);
     path.close();
     path.moveTo(1083, 441);
     path.lineTo(1255, 441);
     path.quadTo(1255, 443.071075f, 1253.53552f, 444.535522f);
     path.quadTo(1252.07104f, 446, 1250, 446);
     path.lineTo(1088, 446);
     path.quadTo(1085.92896f, 446, 1084.46448f, 444.535522f);
     path.quadTo(1083, 443.071075f, 1083, 441);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1081, 440);
     pathB.lineTo(1082, 440);
     pathB.lineTo(1090.01001f, 448);
     pathB.lineTo(1081, 448);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_cooksnaps_com_17(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(170.340179f, 176);
     path.lineTo(166, 176);
     path.quadTo(161.964188f, 176, 158.299957f, 176.896912f);
     path.quadTo(154.678162f, 177.952271f, 151.183014f, 179.9702f);
     path.lineTo(150.316986f, 180.4702f);
@@ skipping 28 matching lines @@
     pathB.lineTo(151.183014f, 179.9702f);
     pathB.quadTo(162.303314f, 173.549896f, 174.706406f, 176.873276f);
     pathB.quadTo(187.109497f, 180.196686f, 193.5298f, 191.316986f);
     pathB.lineTo(194.0298f, 192.183014f);
     pathB.quadTo(200.450104f, 203.303314f, 197.126709f, 215.70639f);
     pathB.quadTo(193.803314f, 228.109497f, 182.683014f, 234.5298f);
     pathB.lineTo(181.816986f, 235.0298f);
     pathB.quadTo(170.696686f, 241.450104f, 158.293594f, 238.126709f);
     pathB.quadTo(145.890503f, 234.803314f, 139.4702f, 223.683014f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_swapspacesystems_com_5(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(819.050781f, 5539.72412f);
     path.quadTo(819.651672f, 5539.1543f, 820.479858f, 5539.17578f);
     path.lineTo(1191.35278f, 5548.8877f);
     path.quadTo(1192.18091f, 5548.90918f, 1192.7511f, 5549.50977f);
     path.quadTo(1193.32141f, 5550.11133f, 1193.29968f, 5550.93945f);
     path.lineTo(1186.57214f, 5807.85107f);
     path.quadTo(1186.55054f, 5808.6792f, 1185.94958f, 5809.24951f);
     path.quadTo(1185.34863f, 5809.81982f, 1184.52051f, 5809.79834f);
     path.lineTo(813.647705f, 5800.08643f);
     path.quadTo(812.819519f, 5800.06494f, 812.249268f, 5799.46387f);
     path.quadTo(811.679016f, 5798.86279f, 811.700684f, 5798.03467f);
     path.lineTo(818.428162f, 5541.12305f);
     path.quadTo(818.44989f, 5540.29492f, 819.050781f, 5539.72412f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(818.48053f, 5539.12354f);
     pathB.lineTo(1193.35205f, 5548.93994f);
     pathB.lineTo(1186.5199f, 5809.85059f);
     pathB.lineTo(811.648376f, 5800.03418f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_kitcheninspirations_wordpress_com_66(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(47.1666679f, 27820.668f);
     path.lineTo(60.8333359f, 27820.668f);
     path.lineTo(60.8333359f, 27820.498f);
     path.lineTo(47.1666679f, 27820.5f);
     path.lineTo(47.1666679f, 27820.668f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(47.1666679f, 27820.668f);
     pathB.lineTo(47.1666679f, 27820.498f);
     pathB.lineTo(60.8333359f, 27820.5f);
     pathB.lineTo(60.8333359f, 27820.668f);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_etiqadd_com_2464(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(630.378662f, 1293.42896f);
     path.quadTo(631.257385f, 1292.55029f, 632.5f, 1292.55029f);
     path.quadTo(633.742615f, 1292.55029f, 634.621338f, 1293.42896f);
     path.lineTo(639.571045f, 1298.37866f);
     path.quadTo(640.449768f, 1299.25732f, 640.449707f, 1300.5f);
     path.quadTo(640.449768f, 1301.74268f, 639.571045f, 1302.62134f);
     path.lineTo(634.621338f, 1307.57104f);
     path.quadTo(633.742615f, 1308.44971f, 632.5f, 1308.44971f);
     path.quadTo(631.257385f, 1308.44971f, 630.378662f, 1307.57104f);
     path.lineTo(625.428955f, 1302.62134f);
     path.quadTo(624.550232f, 1301.74268f, 624.550293f, 1300.5f);
     path.quadTo(624.550232f, 1299.25732f, 625.428955f, 1298.37866f);
     path.lineTo(630.378662f, 1293.42896f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(632.5f, 1291.30762f);
     pathB.lineTo(641.692383f, 1300.5f);
     pathB.lineTo(632.5f, 1309.69238f);
     pathB.lineTo(623.307617f, 1300.5f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_narayana_verlag_de_194(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1083.34314f, 513.65686f);
     path.quadTo(1081, 511.313721f, 1081, 508);
     path.lineTo(1257, 508);
     path.quadTo(1257, 511.313721f, 1254.65686f, 513.65686f);
     path.quadTo(1252.31372f, 516, 1249, 516);
     path.lineTo(1089, 516);
     path.quadTo(1085.68628f, 516, 1083.34314f, 513.65686f);
     path.close();
     path.moveTo(1083, 509);
     path.lineTo(1255, 509);
     path.quadTo(1255, 511.071075f, 1253.53552f, 512.535522f);
     path.quadTo(1252.07104f, 514, 1250, 514);
     path.lineTo(1088, 514);
     path.quadTo(1085.92896f, 514, 1084.46448f, 512.535522f);
     path.quadTo(1083, 511.071075f, 1083, 509);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1081, 508);
     pathB.lineTo(1082, 508);
     pathB.lineTo(1090.01001f, 516);
     pathB.lineTo(1081, 516);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_americascup_com_108(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(999.454102f, 689.17157f);
     path.quadTo(1001.172f, 688, 1002.82886f, 688);
     path.lineTo(1013.82886f, 688);
     path.lineTo(1002.17114f, 713);
     path.lineTo(991.171143f, 713);
     path.quadTo(989.514282f, 713, 988.889038f, 711.82843f);
     path.quadTo(988.263794f, 710.65686f, 989.036377f, 709);
     path.lineTo(996.963623f, 692);
     path.quadTo(997.736206f, 690.34314f, 999.454102f, 689.17157f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(998.828857f, 688);
     pathB.lineTo(1013.82886f, 688);
     pathB.lineTo(1002.17114f, 713);
     pathB.lineTo(987.171143f, 713);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_vantageproduction_com_109(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(794.514709f, 759.485291f);
     path.quadTo(791, 755.970581f, 791, 751);
     path.lineTo(1133, 751);
     path.quadTo(1133, 755.970581f, 1129.48523f, 759.485291f);
     path.quadTo(1125.97058f, 763, 1121, 763);
     path.lineTo(803, 763);
     path.quadTo(798.029419f, 763, 794.514709f, 759.485291f);
     path.close();
     path.moveTo(793, 752);
     path.lineTo(1131, 752);
     path.quadTo(1131, 755.727905f, 1128.36401f, 758.363953f);
     path.quadTo(1125.72791f, 761, 1122, 761);
     path.lineTo(802, 761);
     path.quadTo(798.272095f, 761, 795.636047f, 758.363953f);
     path.quadTo(793, 755.727905f, 793, 752);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(791, 751);
     pathB.lineTo(792, 751);
     pathB.lineTo(804.01001f, 763);
     pathB.lineTo(791, 763);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_aceinfographics_com_106(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(166.878677f, 7638.87891f);
     path.quadTo(166, 7639.75732f, 166, 7641);
     path.lineTo(166, 11577);
     path.quadTo(166, 11578.2422f, 166.878677f, 11579.1211f);
     path.quadTo(167.388f, 11579.6309f, 168.019989f, 11579.8447f);
     path.lineTo(168.019974f, 11576.2979f);
     path.quadTo(168, 11576.1533f, 168, 11576);
     path.lineTo(168, 7642);
     path.lineTo(168.000015f, 7641.99316f);
     path.lineTo(168, 7640);
     path.lineTo(166.878677f, 7638.87891f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(166, 7638);
     pathB.lineTo(168.020004f, 7635.97998f);
     pathB.lineTo(168, 11578);
     pathB.lineTo(166, 11580);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_tcmevents_org_13(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(465.951904f, 547.960144f);
     path.quadTo(465.66571f, 546.867371f, 465.404938f, 546);
     path.lineTo(465.504089f, 546);
     path.quadTo(465.670349f, 546.601257f, 465.84668f, 547.288391f);
     path.quadTo(467.274506f, 552.852356f, 468.506836f, 560.718567f);
     path.quadTo(467.336121f, 553.24585f, 465.951904f, 547.960144f);
     path.close();
     path.moveTo(470.591064f, 574.024353f);
     path.quadTo(474.844055f, 601.176025f, 471.728271f, 620.364502f);
     path.quadTo(470.567017f, 627.515991f, 468.635742f, 632);
     path.lineTo(469.106812f, 632);
     path.quadTo(470.791504f, 627.638672f, 471.833496f, 621.036255f);
     path.quadTo(474.905701f, 601.569519f, 470.591064f, 574.024353f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(322.992462f, 541.475708f);
     pathB.lineTo(465.531616f, 541.724426f);
     pathB.lineTo(468.507751f, 560.724426f);
     pathB.lineTo(325.968597f, 560.475708f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_paseoitaigara_com_br_56(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(633.147217f, 1247);
     path.lineTo(718, 1162.14722f);
     path.lineTo(802.852783f, 1247);
     path.lineTo(718, 1331.85278f);
     path.lineTo(633.147217f, 1247);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(635.268494f, 1244.87866f);
     pathB.lineTo(715.878662f, 1164.26855f);
     pathB.quadTo(716.757385f, 1163.38989f, 718, 1163.38989f);
     pathB.quadTo(719.242615f, 1163.38989f, 720.121338f, 1164.26855f);
     pathB.lineTo(800.731506f, 1244.87866f);
     pathB.quadTo(801.610168f, 1245.75732f, 801.610168f, 1247);
     pathB.quadTo(801.610229f, 1248.24268f, 800.731445f, 1249.12134f);
     pathB.lineTo(720.121338f, 1329.73145f);
     pathB.quadTo(719.242676f, 1330.61011f, 718, 1330.61011f);
     pathB.quadTo(716.757385f, 1330.61011f, 715.878723f, 1329.73145f);
     pathB.lineTo(635.268555f, 1249.12134f);
     pathB.quadTo(634.389832f, 1248.24268f, 634.389832f, 1247);
     pathB.quadTo(634.389832f, 1245.75732f, 635.268494f, 1244.87866f);
     pathB.close();
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_mortgagemarketguide_com_109(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(816.514709f, 781.485291f);
     path.quadTo(813, 777.970581f, 813, 773);
     path.lineTo(1133, 773);
     path.quadTo(1133, 777.970581f, 1129.48523f, 781.485291f);
     path.quadTo(1125.97058f, 785, 1121, 785);
     path.lineTo(825, 785);
     path.quadTo(820.029419f, 785, 816.514709f, 781.485291f);
     path.close();
     path.moveTo(815, 774);
     path.lineTo(1131, 774);
     path.quadTo(1131, 777.727905f, 1128.36401f, 780.363953f);
     path.quadTo(1125.72791f, 783, 1122, 783);
     path.lineTo(824, 783);
     path.quadTo(820.272095f, 783, 817.636047f, 780.363953f);
     path.quadTo(815, 777.727905f, 815, 774);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(813, 773);
     pathB.lineTo(814, 773);
     pathB.lineTo(826.01001f, 785);
     pathB.lineTo(813, 785);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_9to5mac_com_64(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(365, 5101);
     path.lineTo(365, 5082);
     path.lineTo(366, 5083);
     path.lineTo(367, 5092.96631f);
     path.lineTo(367, 5100);
     path.quadTo(367, 5101.50537f, 367.967712f, 5102.61084f);
     path.lineTo(368.278717f, 5105.71045f);
     path.quadTo(367.277618f, 5105.34863f, 366.464478f, 5104.53564f);
     path.quadTo(365, 5103.07129f, 365, 5101);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(365, 5082);
     pathB.lineTo(365.848175f, 5081.15186f);
     pathB.lineTo(368, 5103);
     pathB.lineTo(365, 5106);
-    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 static void skpwww_googleventures_com_32(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(725.911682f, 898.767456f);
     path.lineTo(741.232544f, 885.911682f);
     path.lineTo(754.088318f, 901.232544f);
     path.lineTo(738.767456f, 914.088318f);
     path.lineTo(725.911682f, 898.767456f);
     path.close();
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 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();
-    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);
-    }
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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 11 matching lines @@
     pathB.moveTo(10213, 5315);
     pathB.lineTo(10230, 5315);
     pathB.cubicTo(10231.6572f, 5315, 10233, 5316.34326f, 10233, 5318);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 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);
@@ skipping 15 matching lines @@
     path.quadTo(808, 11701.8281f, 808, 11701);
     path.lineTo(808, 11675);
     path.quadTo(808, 11674.1719f, 808.585815f, 11673.5859f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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);
     path.quadTo(342.380707f, 1469, 341, 1469);
     path.lineTo(81.0000076f, 1469);
     path.quadTo(79.6192932f, 1469, 78.6429825f, 1468.02368f);
     path.quadTo(77.6666718f, 1467.04736f, 77.6666718f, 1465.66663f);
     path.lineTo(77.6666718f, 1396.66675f);
     path.quadTo(77.6666718f, 1395.28601f, 78.6429825f, 1394.30969f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kEvenOdd_FillType);
     pathB.moveTo(81, 1393.33337f);
     pathB.lineTo(341, 1393.33337f);
     pathB.cubicTo(342.840942f, 1393.33337f, 344.333344f, 1394.82568f, 344.333344f, 1396.66675f);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
 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);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, 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();
-    testPathOpCheck(reporter, path, pathB, kIntersect_PathOp, filename, FLAGS_runFail);
+    testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
 }
 
+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_SkPathOp, 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, stopTest, runReverse);
+    RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse);
 }