update pathops to circle sort

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 }
 
-static void skpcheeseandburger_com225(skiatest::Reporter* reporter) {
+static void skpcheeseandburger_com225(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(555, 468);
     path.lineTo(555, 362);
     path.lineTo(872, 362);
     path.lineTo(872, 468);
     path.lineTo(555, 468);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kWinding_FillType);
@@ skipping 337 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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpeverytechpro_blogspot_com100(skiatest::Reporter* reporter) {
+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);
     path.lineTo(1134, 645);
     path.quadTo(1134, 652.041626f, 1129.02246f, 657.0224f);
     path.quadTo(1124.04163f, 662, 1117, 662);
@@ skipping 10 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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpflite_com41(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpilkoora_com37(skiatest::Reporter* reporter) {
+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);
     path.cubicTo(825.268005f, 143, 819, 149.268005f, 819, 157);
     path.lineTo(819, 926);
     path.lineTo(818, 926);
     path.lineTo(818, 157);
     path.close();
     path.moveTo(1184, 926);
     path.lineTo(1185, 926);
     path.lineTo(1185, 157);
     path.cubicTo(1185, 148.715729f, 1178.2843f, 142, 1170, 142);
     path.lineTo(1093, 142);
     path.lineTo(1093, 143);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpmm4everfriends_com43(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpmtrk_uz27(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpfrauen_magazin_com83(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#define TRY_BROKEN_TESTS 0
-#if TRY_BROKEN_TESTS
-static void skpi_gino_com16(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skppchappy_com_au102(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpsciality_com161(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void skpsudoestenegocios_com186(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpthesuburbanite_com213(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skphostloco_com11(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpsergeychunkevich_com8(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skptracksflow_com9(skiatest::Reporter* reporter) {
+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);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kEvenOdd_FillType);
@@ skipping 10 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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpautobutler_dk29(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skponlinecollege_org144(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpnational_com_au81(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skprentacheat_com30(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpbreakmystyle_com10(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpsd_graphic_net104(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TRY_BROKEN_TESTS
 /* 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) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 /* didn't investigate thoroughly, but looks to be missorting quad and cubic
     {{468.507751,560.724426}, {467.275146,552.856262}, {465.84668,547.288391}}
     {{463.779907,542.671143}, {464.829529,542.672974}, {466.946289,550.755676}, {468.507751,560.724426}}
     decision maker is case 14 leftLessThanRight
  */
-static void skptcmevents_org23(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpredbullskatearcade_es16(skiatest::Reporter* reporter) {
+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);
     path.lineTo(652.258179f, 468.503662f);
     path.lineTo(649.021729f, 531.322754f);
     path.cubicTo(648.75885f, 536.424805f, 652.641479f, 540.423523f, 657.693848f, 540.25415f);
     path.lineTo(923.905029f, 531.329163f);
     path.cubicTo(928.955017f, 531.159851f, 933.262268f, 526.890442f, 933.528809f, 521.791565f);
     path.lineTo(933.529175f, 521.784363f);
     path.lineTo(936.765625f, 458.965302f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpfinanzasdigital_com9(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void skppartainasdemo250_org56(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpmlk_com326(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpcyclist_friends_gr52(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 /* cubic ends just above opp line */
-static void skpwww_fj_p_com_22(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#define TRY_SEPT_BROKEN_TESTS 0
-#if TRY_SEPT_BROKEN_TESTS
 // pair of lines are not quite coincident, so sorting line/cubic fails (i think)
-static void skpwww_lavoixdunord_fr_11(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 // pair of curves have nearly the same initial tangent but are sorting by
 // that alone sorts them incorrectly. Need to detect that tangents are nearly
 // identical and not reliable by themselves
-static void skppptv_com_62(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 // nearly identical to lavoixdunord -- to not-quite-coincident lines
-static void skpwww_booking_com_68(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
 // visually looks like lavoixdunord and www_booking_com
-static void skpwww_despegar_com_mx_272(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void skpwww_joomla_org_23(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpwww_macrumors_com_131(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpwww_leadpages_net_84(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpwww_briian_com_34(skiatest::Reporter* reporter) {
+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);
     path.cubicTo(1196, 781.761414f, 1193.76147f, 784, 1191, 784);
     path.lineTo(848, 784);
     path.cubicTo(845.238586f, 784, 843, 781.761414f, 843, 779);
     path.lineTo(843, 216);
     path.close();
     path.moveTo(844, 217);
     path.cubicTo(844, 214.238571f, 846.238586f, 212, 849, 212);
     path.lineTo(1190, 212);
     path.cubicTo(1192.76147f, 212, 1195, 214.238571f, 1195, 217);
     path.lineTo(1195, 778);
     path.cubicTo(1195, 779.65686f, 1192.76147f, 781, 1190, 781);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-
-static void skpwww_sciality_com_100(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TRY_SEPT_BROKEN_TESTS
-static void skpwww_sciality_com_101(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void skpwww_meb_gov_tr_5(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TRY_SEPT_BROKEN_TESTS
-static void skpwww_meb_gov_tr_6(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void skpgithub_io_25(skiatest::Reporter* reporter) {
+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);
     path.lineTo(1108, 41);
     path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
     path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
     path.lineTo(1004, 44);
     path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f);
     path.quadTo(1001.00012f, 42.2425423f, 1001, 41);
     path.lineTo(1001, 17);
     path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f);
     path.close();
     SkPath pathB;
     pathB.setFillType(SkPath::kInverseWinding_FillType);
     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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpgithub_io_26(skiatest::Reporter* reporter) {
+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);
     path.lineTo(1108, 41);
     path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
     path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
@@ skipping 12 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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-static void skpskpicture14(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#if TRY_SEPT_BROKEN_TESTS
-static void skpskpicture15(skiatest::Reporter* reporter) {
+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);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
-#endif
 
-static void (*firstTest)(skiatest::Reporter* ) = 0;
+/* Three edges are partially coincident. Only one of the three knows about the other two.
+   Subsequently, when the angle loop is created, it misses one of the edges.
+   After coincident edges are processed, probably need a check-and-correct that makes sure the
+   coincidences are all self-consistent.
+ */
+static void skpelpais_com_18(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(183, 8507);
+    path.lineTo(552, 8506.99023f);
+    path.lineTo(552, 8508);
+    path.lineTo(183, 8508);
+    path.lineTo(183, 8507);
+    path.close();
+    SkPath pathB;
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(183, 8508);
+    pathB.lineTo(183, 8506.99023f);
+    pathB.lineTo(552, 8507);
+    pathB.lineTo(552, 8508);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+}
+
+/* this generates a pair of lines that are essentially coincident; but the next line at a right
+   angle is not treated as if it intersects at the same point.
+   There are several of options:
+     move the intersection of the right angle line to the coincident point (should 'near' do this?
+     construct another coincident pair from the right angle line to the coincident point
+     treat the intersection as simple and not coincident
+ */
+static void skpnamecheap_com_405(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(140, 1000);
+    path.lineTo(140, 842);
+    path.lineTo(141, 842);
+    path.lineTo(141.14502f, 1000);
+    path.lineTo(140, 1000);
+    path.close();
+    SkPath pathB;
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(140, 842);
+    pathB.lineTo(141.008835f, 837.9646f);
+    pathB.lineTo(141.235291f, 1109.05884f);
+    pathB.lineTo(140, 1114);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+}
+
+// fails on angle insert -- haven't investigated yet
+static void skpwww_alrakoba_net_62(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(134.34314f, 9802.34277f);
+    path.quadTo(132, 9804.68652f, 132, 9808);
+    path.lineTo(132, 9822);
+    path.quadTo(132, 9825.31348f, 134.34314f, 9827.65723f);
+    path.quadTo(136.686295f, 9830, 140, 9830);
+    path.lineTo(140.028473f, 9830);
+    path.lineTo(139.877213f, 9828.90723f);
+    path.quadTo(137.692032f, 9828.5332f, 136.050247f, 9826.65723f);
+    path.quadTo(134, 9824.31348f, 134, 9821);
+    path.lineTo(134, 9809);
+    path.quadTo(134, 9806.10059f, 136.050247f, 9804.0498f);
+    path.lineTo(134.34314f, 9802.34277f);
+    path.close();
+    SkPath pathB;
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(132, 9800);
+    pathB.lineTo(135.962357f, 9800);
+    pathB.lineTo(140, 9830);
+    pathB.lineTo(132, 9830);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+}
+
+/* asserts in alignSpanState looks like a coincident related bug */
+static void skpwww_cityads_ru_249(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(817.464478f, 11.4644661f);
+    path.quadTo(818.928955f, 10, 821, 10);
+    path.lineTo(998, 10);
+    path.quadTo(999.082947f, 10, 1000, 10.4003992f);
+    path.lineTo(1000, 13.3527431f);
+    path.quadTo(999.917603f, 13.2607508f, 999.82843f, 13.1715727f);
+    path.quadTo(998.65686f, 12, 997, 12);
+    path.lineTo(822, 12);
+    path.quadTo(820.34314f, 12, 819.17157f, 13.1715727f);
+    path.quadTo(818, 14.3431454f, 818, 16);
+    path.lineTo(818, 28);
+    path.quadTo(818, 29.6568546f, 819.17157f, 30.8284264f);
+    path.quadTo(820.34314f, 32, 822, 32);
+    path.lineTo(997, 32);
+    path.quadTo(998.65686f, 32, 999.82843f, 30.8284264f);
+    path.quadTo(999.917603f, 30.7392426f, 1000, 30.6472569f);
+    path.lineTo(1000, 33.5996017f);
+    path.quadTo(999.082947f, 34, 998, 34);
+    path.lineTo(821, 34);
+    path.quadTo(818.928955f, 34, 817.464478f, 32.5355339f);
+    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);
+}
+
+// fails on angle insert
+static void skpwww_dealnews_com_315(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(966.464478f, 4261.46436f);
+    path.quadTo(965, 4262.92871f, 965, 4265);
+    path.lineTo(965, 4276);
+    path.quadTo(965, 4278.07129f, 966.464478f, 4279.53564f);
+    path.quadTo(967.928955f, 4281, 970, 4281);
+    path.lineTo(970.020325f, 4281);
+    path.lineTo(969.887512f, 4279.81641f);
+    path.quadTo(968.928284f, 4279.48145f, 968.17157f, 4278.53564f);
+    path.quadTo(967, 4277.07129f, 967, 4275);
+    path.lineTo(967, 4266);
+    path.quadTo(967, 4264.44287f, 968.035217f, 4263.31396f);
+    path.lineTo(968, 4263);
+    path.lineTo(966.464478f, 4261.46436f);
+    path.close();
+    SkPath pathB;
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(965, 4260);
+    pathB.lineTo(967.716675f, 4260);
+    pathB.lineTo(970, 4281);
+    pathB.lineTo(965, 4281);
+    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
+}
+
+// fails in intersections insert
+static void skpwww_inmotionhosting_com_9(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path;
+    path.setFillType(SkPath::kEvenOdd_FillType);
+    path.moveTo(991.633911f, 1839);
+    path.lineTo(964.265015f, 1839);
+    path.lineTo(963.734985f, 1893.73242f);
+    path.lineTo(991.3703f, 1894);
+    path.lineTo(1018.23492f, 1894);
+    path.lineTo(1018.76501f, 1839.2627f);
+    path.lineTo(991.638184f, 1839);
+    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);
+}
+
+static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
+    TEST(skpnamecheap_com_405),
+    TEST(skpelpais_com_18),
+    TEST(skpwww_cityads_ru_249),
+    TEST(skpwww_alrakoba_net_62),
+    TEST(skpwww_dealnews_com_315),
+    TEST(skpwww_inmotionhosting_com_9),
     TEST(skpskpicture14),
-#if TRY_SEPT_BROKEN_TESTS
     TEST(skpskpicture15),
     TEST(skpwww_meb_gov_tr_6),
     TEST(skpwww_sciality_com_101),
     TEST(skpwww_booking_com_68),  // similar to lavoixdunord
     TEST(skpwww_despegar_com_mx_272),  // similar to lavoixdunord
     TEST(skpwww_lavoixdunord_fr_11),  // not quite coincident, sorting line/cubic fails
     TEST(skppptv_com_62),  // cubic have nearly identical tangents, sort incorrectly
-#endif
-#if TRY_BROKEN_TESTS
     TEST(skppchappy_com_au102),
     TEST(skpsciality_com161),
     TEST(skpi_gino_com16),
     TEST(skpnaoxrane_ru23),  // see test for failure evaluation
     TEST(skptcmevents_org23),  // see test for (partial) failure evaluation
     TEST(skpredbullskatearcade_es16),  // cubic have nearly identical tangents, sort incorrectly
     TEST(skpfinanzasdigital_com9),  // cubic/quad tangents too close to sort
-#endif
     TEST(skpgithub_io_26),
     TEST(skpgithub_io_25),
     TEST(skpwww_meb_gov_tr_5),
     TEST(skpwww_sciality_com_100),
     TEST(skpwww_joomla_org_23),
     TEST(skpwww_macrumors_com_131),
     TEST(skpwww_briian_com_34),
     TEST(skpwww_leadpages_net_84),
     TEST(skpwww_fj_p_com_22),
     TEST(skppartainasdemo250_org56),
@@ skipping 15 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* ) = 0;
+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);
 }