Revert of harden pathops for pathological test

tests/PathOpsBattles.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsExtendedTest.h"
 #include "PathOpsTestCommon.h"
 
 #define TEST(name) { name, #name }
@@ skipping 1255 matching lines @@
 path.cubicTo(SkBits2Float(0x423d8e5d), SkBits2Float(0xc2135c44), SkBits2Float(0x423949dc), SkBits2Float(0xc218b118), SkBits2Float(0x4234ccac), SkBits2Float(0xc21dd57e));
 path.lineTo(SkBits2Float(0x427a1b1e), SkBits2Float(0xc25a5642));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp46(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc26fffff));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41bfbd07), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423b0ef1), SkBits2Float(0xc2914772), SkBits2Float(0x427a1b1e), SkBits2Float(0xc25a5642));
 path.cubicTo(SkBits2Float(0x4280286a), SkBits2Float(0xc253393c), SkBits2Float(0x42831c11), SkBits2Float(0xc24bd939), SkBits2Float(0x4285e673), SkBits2Float(0xc2443b5f));
 path.lineTo(SkBits2Float(0x42419733), SkBits2Float(0xc20ddaba));
 path.cubicTo(SkBits2Float(0x423d8e5d), SkBits2Float(0xc2135c44), SkBits2Float(0x423949dc), SkBits2Float(0xc218b118), SkBits2Float(0x4234ccac), SkBits2Float(0xc21dd57e));
 path.lineTo(SkBits2Float(0x4234ccaa), SkBits2Float(0xc21dd57d));
 path.cubicTo(SkBits2Float(0x42073912), SkBits2Float(0xc2520ac5), SkBits2Float(0x418a9b2a), SkBits2Float(0xc26fffff), SkBits2Float(0x3697ff52), SkBits2Float(0xc26fffff));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x4285e672), SkBits2Float(0xc2443b5f));
 path.cubicTo(SkBits2Float(0x42b50145), SkBits2Float(0xc1875361), SkBits2Float(0x42afc74e), SkBits2Float(0x41db6d5e), SkBits2Float(0x4272e616), SkBits2Float(0x426253de));
 path.lineTo(SkBits2Float(0x422f96e8), SkBits2Float(0x42239c3e));
 path.cubicTo(SkBits2Float(0x427e233c), SkBits2Float(0x419e9f42), SkBits2Float(0x4282d8d3), SkBits2Float(0xc143a6d1), SkBits2Float(0x42419734), SkBits2Float(0xc20ddabb));
 path.lineTo(SkBits2Float(0x4285e672), SkBits2Float(0xc2443b5f));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp47(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41d59904), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424f13ae), SkBits2Float(0xc28c4fb7), SkBits2Float(0x4286bb70), SkBits2Float(0xc241f0ca));
 path.lineTo(SkBits2Float(0x4242cb24), SkBits2Float(0xc20c32b1));
 path.cubicTo(SkBits2Float(0x4215b1b4), SkBits2Float(0xc24adc20), SkBits2Float(0x419a6875), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
@@ skipping 170 matching lines @@
 path.cubicTo(SkBits2Float(0x426ae754), SkBits2Float(0xc148f95c), SkBits2Float(0x42688e2a), SkBits2Float(0xc170bcb0), SkBits2Float(0x426594dd), SkBits2Float(0xc18be3fd));
 path.lineTo(SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183e9));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp54(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x421216db), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4289817d), SkBits2Float(0xc26c814f), SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183ed));
 path.lineTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595d));
 path.lineTo(SkBits2Float(0x426c9cb2), SkBits2Float(0xc120bbfa));
 path.cubicTo(SkBits2Float(0x426ae754), SkBits2Float(0xc148f95c), SkBits2Float(0x42688e2a), SkBits2Float(0xc170bcb0), SkBits2Float(0x426594dd), SkBits2Float(0xc18be3fd));
 path.lineTo(SkBits2Float(0x426594dc), SkBits2Float(0xc18be3fc));
 path.cubicTo(SkBits2Float(0x4246cdba), SkBits2Float(0xc22af7b1), SkBits2Float(0x41d336a3), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595e));
 path.cubicTo(SkBits2Float(0x42ad725e), SkBits2Float(0x416ed313), SkBits2Float(0x42982fa2), SkBits2Float(0x4230cc44), SkBits2Float(0x42575fca), SkBits2Float(0x427ca963));
 path.cubicTo(SkBits2Float(0x41fcc0a1), SkBits2Float(0x42a44341), SkBits2Float(0x3f80ed4e), SkBits2Float(0x42affc4e), SkBits2Float(0xc1d56b7f), SkBits2Float(0x429d3115));
 path.lineTo(SkBits2Float(0xc19a478e), SkBits2Float(0x426343e2));
 path.cubicTo(SkBits2Float(0x3f3a6666), SkBits2Float(0x427e6fe0), SkBits2Float(0x41b6b66f), SkBits2Float(0x426d7d04), SkBits2Float(0x421bb135), SkBits2Float(0x4236a5a5));
 path.cubicTo(SkBits2Float(0x425c0733), SkBits2Float(0x41ff9c8c), SkBits2Float(0x427ac435), SkBits2Float(0x412ca4f2), SkBits2Float(0x426c9cb3), SkBits2Float(0xc120bbf8));
 path.lineTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595e));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp55(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x4220aa02), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42952310), SkBits2Float(0xc258f48d), SkBits2Float(0x42a35f68), SkBits2Float(0xc16b5614));
 path.lineTo(SkBits2Float(0x426c3395), SkBits2Float(0xc12a1f61));
 path.cubicTo(SkBits2Float(0x42579ea8), SkBits2Float(0xc21cd5ce), SkBits2Float(0x41e84916), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
@@ skipping 93 matching lines @@
 path.cubicTo(SkBits2Float(0x4228a0e3), SkBits2Float(0x424550a9), SkBits2Float(0x426a177b), SkBits2Float(0x41e03b19), SkBits2Float(0x426f9fb0), SkBits2Float(0x4056ee3a));
 path.lineTo(SkBits2Float(0x42a5bd62), SkBits2Float(0x4094a90c));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp59(skiatest::Reporter* reporter, const char* filename) {  // hung
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x423693bc), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42a57249), SkBits2Float(0xc2389374), SkBits2Float(0x42a5ff3a), SkBits2Float(0xbf002494));
 path.lineTo(SkBits2Float(0x426ffee2), SkBits2Float(0xbeb944c3));
 path.cubicTo(SkBits2Float(0x426f331d), SkBits2Float(0xc2056daf), SkBits2Float(0x4203fbc4), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
@@ skipping 81 matching lines @@
 path.cubicTo(SkBits2Float(0x4002419e), SkBits2Float(0xc26fdcaf), SkBits2Float(0x3ffc5fdb), SkBits2Float(0xc26fdedc), SkBits2Float(0x3ff43c61), SkBits2Float(0xc26fe0ed));
 path.lineTo(SkBits2Float(0x4028ee15), SkBits2Float(0xc2a5ea81));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp63(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3f614848), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fe14683), SkBits2Float(0xc2a5f8d5), SkBits2Float(0x4028ee15), SkBits2Float(0xc2a5ea81));
 path.cubicTo(SkBits2Float(0x402e8f25), SkBits2Float(0xc2a5e912), SkBits2Float(0x40343026), SkBits2Float(0xc2a5e791), SkBits2Float(0x4039d111), SkBits2Float(0xc2a5e5fd));
 path.lineTo(SkBits2Float(0x4006533c), SkBits2Float(0xc26fda66));
 path.cubicTo(SkBits2Float(0x400241a2), SkBits2Float(0xc26fdcaf), SkBits2Float(0x3ffc5fea), SkBits2Float(0xc26fdedc), SkBits2Float(0x3ff43c76), SkBits2Float(0xc26fe0ec));
 path.cubicTo(SkBits2Float(0x3fa2d98a), SkBits2Float(0xc26ff5a4), SkBits2Float(0x3f22dad5), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.close();
 path.moveTo(SkBits2Float(0x40186abb), SkBits2Float(0xc295b297));
 path.lineTo(SkBits2Float(0x3ff43c61), SkBits2Float(0xc26fe0ed));
 path.lineTo(SkBits2Float(0x3ff43c77), SkBits2Float(0xc26fe0ed));
 path.lineTo(SkBits2Float(0x40186abb), SkBits2Float(0xc295b297));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x4039d102), SkBits2Float(0xc2a5e5fe));
 path.cubicTo(SkBits2Float(0x408a83ff), SkBits2Float(0xc2a5cc72), SkBits2Float(0x40b8130f), SkBits2Float(0xc2a5a01a), SkBits2Float(0x40e58a06), SkBits2Float(0xc2a56100));
 path.lineTo(SkBits2Float(0x40a5ee90), SkBits2Float(0xc26f1a20));
 path.cubicTo(SkBits2Float(0x408510de), SkBits2Float(0xc26f755e), SkBits2Float(0x40484386), SkBits2Float(0xc26fb57a), SkBits2Float(0x40065347), SkBits2Float(0xc26fda68));
 path.lineTo(SkBits2Float(0x4039d102), SkBits2Float(0xc2a5e5fe));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp64(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3faf587e), SkBits2Float(0xc2a5ffff), SkBits2Float(0x402f5505), SkBits2Float(0xc2a5eea1), SkBits2Float(0x408372de), SkBits2Float(0xc2a5cbeb));
 path.lineTo(SkBits2Float(0x403e0bd0), SkBits2Float(0xc26fb4b6));
 path.cubicTo(SkBits2Float(0x3ffd7de6), SkBits2Float(0xc26fe6e6), SkBits2Float(0x3f7d82fb), SkBits2Float(0xc2700000), SkBits2Float(0x363f7eb2), SkBits2Float(0xc2700000));
@@ skipping 527 matching lines @@
 path.cubicTo(SkBits2Float(0x3ff54c2d), SkBits2Float(0xc26fe0b0), SkBits2Float(0x3feda268), SkBits2Float(0xc26fe29e), SkBits2Float(0x3fe5f88e), SkBits2Float(0xc26fe474));
 path.lineTo(SkBits2Float(0x401f1027), SkBits2Float(0xc2a5ecf2));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp85(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3f541e8b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fd41d19), SkBits2Float(0xc2a5f9a6), SkBits2Float(0x401f1027), SkBits2Float(0xc2a5ecf2));
 path.cubicTo(SkBits2Float(0x40245d21), SkBits2Float(0xc2a5ebac), SkBits2Float(0x4029aa04), SkBits2Float(0xc2a5ea57), SkBits2Float(0x402ef6d6), SkBits2Float(0xc2a5e8f1));
 path.lineTo(SkBits2Float(0x3ffcf5ba), SkBits2Float(0xc26fdeaa));
 path.cubicTo(SkBits2Float(0x3ff54c2d), SkBits2Float(0xc26fe0b0), SkBits2Float(0x3feda268), SkBits2Float(0xc26fe29e), SkBits2Float(0x3fe5f882), SkBits2Float(0xc26fe473));
 path.cubicTo(SkBits2Float(0x3f9955cf), SkBits2Float(0xc26ff6d2), SkBits2Float(0x3f1956dc), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.close();
@@ skipping 1636 matching lines @@
 path.cubicTo(SkBits2Float(0x42583d5c), SkBits2Float(0x4206f5b6), SkBits2Float(0x4279fe97), SkBits2Float(0x41470ec8), SkBits2Float(0x426d6866), SkBits2Float(0xc10cb6eb));
 path.lineTo(SkBits2Float(0x42a43502), SkBits2Float(0xc142a7bb));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp148(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42216831), SkBits2Float(0xc2a60000), SkBits2Float(0x4295b6bc), SkBits2Float(0xc257ea44), SkBits2Float(0x42a38b53), SkBits2Float(0xc1639572));
 path.lineTo(SkBits2Float(0x426c7311), SkBits2Float(0xc12484b9));
 path.cubicTo(SkBits2Float(0x42587424), SkBits2Float(0xc21c154e), SkBits2Float(0x41e95c08), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
 path.cubicTo(SkBits2Float(0x42a4def8), SkBits2Float(0xc1269090), SkBits2Float(0x42a5a99a), SkBits2Float(0xc0d1c16f), SkBits2Float(0x42a5e9be), SkBits2Float(0xc02be63c));
 path.lineTo(SkBits2Float(0x426fdfd2), SkBits2Float(0xbff8877d));
 path.cubicTo(SkBits2Float(0x426f8319), SkBits2Float(0xc097a16e), SkBits2Float(0x426e5e22), SkBits2Float(0xc0f0d105), SkBits2Float(0x426c7311), SkBits2Float(0xc12484ba));
 path.lineTo(SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp149(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42216831), SkBits2Float(0xc2a60000), SkBits2Float(0x4295b6bc), SkBits2Float(0xc257ea44), SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
 path.lineTo(SkBits2Float(0x426c7311), SkBits2Float(0xc12484ba));
@@ skipping 67 matching lines @@
 path.cubicTo(SkBits2Float(0x42236d8c), SkBits2Float(0x424a3945), SkBits2Float(0x4267ebda), SkBits2Float(0x41eb1462), SkBits2Float(0x426f56cb), SkBits2Float(0x408e661a));
 path.lineTo(SkBits2Float(0x42a58af6), SkBits2Float(0x40c4fc3d));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp152(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41b12ed4), SkBits2Float(0xc2a60000), SkBits2Float(0x422d822c), SkBits2Float(0xc2944bde), SkBits2Float(0x426bdb91), SkBits2Float(0xc269a7f3));
 path.cubicTo(SkBits2Float(0x42951a7b), SkBits2Float(0xc22ab829), SkBits2Float(0x42a66879), SkBits2Float(0xc1aaf2b1), SkBits2Float(0x42a5fe21), SkBits2Float(0x3f4744a4));
 path.lineTo(SkBits2Float(0x426ffd4c), SkBits2Float(0x3f100c99));
 path.cubicTo(SkBits2Float(0x4270970c), SkBits2Float(0xc177275d), SkBits2Float(0x4257923d), SkBits2Float(0xc1f6d2bd), SkBits2Float(0x422a7fe2), SkBits2Float(0xc228e872));
 path.cubicTo(SkBits2Float(0x41fadb0b), SkBits2Float(0xc2566785), SkBits2Float(0x41801584), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x42a5fe22), SkBits2Float(0x3f4744a1));
 path.cubicTo(SkBits2Float(0x42a5e921), SkBits2Float(0x40a4df91), SkBits2Float(0x42a52322), SkBits2Float(0x411841f7), SkBits2Float(0x42a3adfe), SkBits2Float(0x415d43d0));
 path.lineTo(SkBits2Float(0x426ca531), SkBits2Float(0x411ff355));
 path.cubicTo(SkBits2Float(0x426ec0ad), SkBits2Float(0x40dc21ae), SkBits2Float(0x426fdeef), SkBits2Float(0x406e5efe), SkBits2Float(0x426ffd4d), SkBits2Float(0x3f100c9b));
 path.lineTo(SkBits2Float(0x42a5fe22), SkBits2Float(0x3f4744a1));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp153(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41b12ed4), SkBits2Float(0xc2a60000), SkBits2Float(0x422d822c), SkBits2Float(0xc2944bde), SkBits2Float(0x426bdb91), SkBits2Float(0xc269a7f3));
 path.cubicTo(SkBits2Float(0x42951a7b), SkBits2Float(0xc22ab829), SkBits2Float(0x42a66879), SkBits2Float(0xc1aaf2b1), SkBits2Float(0x42a5fe21), SkBits2Float(0x3f4744a0));
@@ skipping 99 matching lines @@
 path.cubicTo(SkBits2Float(0x4266acd9), SkBits2Float(0x41876566), SkBits2Float(0x426a370e), SkBits2Float(0x4158ca4c), SkBits2Float(0x426c905b), SkBits2Float(0x4121ddaf));
 path.lineTo(SkBits2Float(0x42a39f93), SkBits2Float(0x415fea20));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp157(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41c3ae1a), SkBits2Float(0xc2a60000), SkBits2Float(0x423eb2d3), SkBits2Float(0xc2906c00), SkBits2Float(0x427dc7c2), SkBits2Float(0xc2560e13));
 path.cubicTo(SkBits2Float(0x429e6e58), SkBits2Float(0xc20b4426), SkBits2Float(0x42abdf2b), SkBits2Float(0xc121d7a8), SkBits2Float(0x42a39f93), SkBits2Float(0x415fea20));
 path.lineTo(SkBits2Float(0x42a39f93), SkBits2Float(0x415fea21));
 path.cubicTo(SkBits2Float(0x42a1ffad), SkBits2Float(0x4195f252), SkBits2Float(0x429f8ce1), SkBits2Float(0x41bb4c45), SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969a));
 path.lineTo(SkBits2Float(0x4261fbff), SkBits2Float(0x41a1a14e));
 path.cubicTo(SkBits2Float(0x4266acd9), SkBits2Float(0x41876566), SkBits2Float(0x426a370e), SkBits2Float(0x4158ca4c), SkBits2Float(0x426c905b), SkBits2Float(0x4121ddaf));
 path.lineTo(SkBits2Float(0x426c905a), SkBits2Float(0x4121ddae));
 path.cubicTo(SkBits2Float(0x42787d42), SkBits2Float(0xc0e9fd34), SkBits2Float(0x42650e94), SkBits2Float(0xc1c95949), SkBits2Float(0x423774a6), SkBits2Float(0xc21abd13));
 path.cubicTo(SkBits2Float(0x4209dab9), SkBits2Float(0xc250cd81), SkBits2Float(0x418d749b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969b));
 path.cubicTo(SkBits2Float(0x4280e391), SkBits2Float(0x4284903f), SkBits2Float(0x41c7a851), SkBits2Float(0x42b2072e), SkBits2Float(0xc1713833), SkBits2Float(0x42a33d14));
 path.cubicTo(SkBits2Float(0xc25c7040), SkBits2Float(0x429472fb), SkBits2Float(0xc2a7bda2), SkBits2Float(0x421b8b2e), SkBits2Float(0xc2a5f5d6), SkBits2Float(0xbfe85110));
 path.lineTo(SkBits2Float(0xc26ff14f), SkBits2Float(0xbfa7f00b));
 path.cubicTo(SkBits2Float(0xc272844c), SkBits2Float(0x41e0e1f3), SkBits2Float(0xc21f5a65), SkBits2Float(0x4256a019), SkBits2Float(0xc12e6015), SkBits2Float(0x426c01f9));
 path.cubicTo(SkBits2Float(0x419054b7), SkBits2Float(0x4280b1ec), SkBits2Float(0x423a5877), SkBits2Float(0x423fa872), SkBits2Float(0x4261fc02), SkBits2Float(0x41a1a142));
 path.lineTo(SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969b));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp158(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41cb677f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4245cb36), SkBits2Float(0xc28eb15b), SkBits2Float(0x42825fc2), SkBits2Float(0xc24d8299));
 path.cubicTo(SkBits2Float(0x42a1d9e8), SkBits2Float(0xc1fb44f8), SkBits2Float(0x42ad4967), SkBits2Float(0xc0aa7cf8), SkBits2Float(0x42a1679f), SkBits2Float(0x419b26cf));
 path.lineTo(SkBits2Float(0x42695b36), SkBits2Float(0x416050ca));
@@ skipping 127 matching lines @@
 path.cubicTo(SkBits2Float(0x42540374), SkBits2Float(0x41e3114e), SkBits2Float(0x425ae4ae), SkBits2Float(0x41c7409b), SkBits2Float(0x426062bc), SkBits2Float(0x41aa4e76));
 path.lineTo(SkBits2Float(0x429b3339), SkBits2Float(0x41eb9733));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp163(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41da3d7f), SkBits2Float(0xc2a60000), SkBits2Float(0x425345ee), SkBits2Float(0xc28b3082), SkBits2Float(0x4288a01b), SkBits2Float(0xc23c9177));
 path.cubicTo(SkBits2Float(0x42a79d3f), SkBits2Float(0xc1c583d9), SkBits2Float(0x42ae8eeb), SkBits2Float(0x407c6461), SkBits2Float(0x429b3339), SkBits2Float(0x41eb9733));
 path.cubicTo(SkBits2Float(0x429766b3), SkBits2Float(0x4209d0f3), SkBits2Float(0x4292a485), SkBits2Float(0x421d0e17), SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e33));
 path.lineTo(SkBits2Float(0x424bd7ac), SkBits2Float(0x41fd5d06));
 path.cubicTo(SkBits2Float(0x42540374), SkBits2Float(0x41e3114e), SkBits2Float(0x425ae4ae), SkBits2Float(0x41c7409b), SkBits2Float(0x426062bb), SkBits2Float(0x41aa4e75));
 path.cubicTo(SkBits2Float(0x427c5f9a), SkBits2Float(0x403673d5), SkBits2Float(0x4272557b), SkBits2Float(0xc18ec82c), SkBits2Float(0x424587e0), SkBits2Float(0xc208507b));
 path.cubicTo(SkBits2Float(0x4218ba46), SkBits2Float(0xc2493ce1), SkBits2Float(0x419dc399), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e36));
 path.cubicTo(SkBits2Float(0x42397b9c), SkBits2Float(0x42a54202), SkBits2Float(0xc0931849), SkBits2Float(0x42bd474f), SkBits2Float(0xc22e0fe8), SkBits2Float(0x428d5ab7));
 path.cubicTo(SkBits2Float(0xc2a4de63), SkBits2Float(0x423adc3f), SkBits2Float(0xc2bd50df), SkBits2Float(0xc08673c0), SkBits2Float(0xc28db7cd), SkBits2Float(0xc22ce1b4));
 path.lineTo(SkBits2Float(0xc24ce4bb), SkBits2Float(0xc1f9f306));
 path.cubicTo(SkBits2Float(0xc288db72), SkBits2Float(0xc0426216), SkBits2Float(0xc26e5ec8), SkBits2Float(0x42071590), SkBits2Float(0xc1fba9c9), SkBits2Float(0x424c5fa5));
 path.cubicTo(SkBits2Float(0xc054b001), SkBits2Float(0x4288d4dc), SkBits2Float(0x420615fc), SkBits2Float(0x426eee67), SkBits2Float(0x424bd7af), SkBits2Float(0x41fd5d01));
 path.lineTo(SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e36));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp164(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41e183ec), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4259cec4), SkBits2Float(0xc2896274), SkBits2Float(0x428b79bc), SkBits2Float(0xc2340753));
 path.cubicTo(SkBits2Float(0x42aa0c16), SkBits2Float(0xc1aa937d), SkBits2Float(0x42ae7c71), SkBits2Float(0x41080a55), SkBits2Float(0x42974339), SkBits2Float(0x4208c1d5));
 path.lineTo(SkBits2Float(0x425ab161), SkBits2Float(0x41c5b8a2));
@@ skipping 493 matching lines @@
 path.cubicTo(SkBits2Float(0x42240a35), SkBits2Float(0x42301b25), SkBits2Float(0x4230c051), SkBits2Float(0x4223582f), SkBits2Float(0x423beb8c), SkBits2Float(0x421548fc));
 path.lineTo(SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d5));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp181(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41fed5d1), SkBits2Float(0xc2a60000), SkBits2Float(0x4273981d), SkBits2Float(0xc28189e8), SkBits2Float(0x42957e40), SkBits2Float(0xc210547e));
 path.cubicTo(SkBits2Float(0x42b13073), SkBits2Float(0xc0eca961), SkBits2Float(0x42a99b35), SkBits2Float(0x41d57c6c), SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d5));
 path.cubicTo(SkBits2Float(0x4274817d), SkBits2Float(0x4261f5b7), SkBits2Float(0x4262ebfa), SkBits2Float(0x42739d02), SkBits2Float(0x424f88b8), SkBits2Float(0x428191ef));
 path.lineTo(SkBits2Float(0x4216064f), SkBits2Float(0x423b5489));
 path.cubicTo(SkBits2Float(0x42240a35), SkBits2Float(0x42301b25), SkBits2Float(0x4230c051), SkBits2Float(0x4223582f), SkBits2Float(0x423beb8b), SkBits2Float(0x421548fc));
 path.cubicTo(SkBits2Float(0x427536c2), SkBits2Float(0x419a53c7), SkBits2Float(0x428016af), SkBits2Float(0xc0ab14a9), SkBits2Float(0x4258227d), SkBits2Float(0xc1d0ab83));
 path.cubicTo(SkBits2Float(0x4230179a), SkBits2Float(0xc23b48ee), SkBits2Float(0x41b837da), SkBits2Float(0xc2700002), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x424f88ba), SkBits2Float(0x428191f0));
 path.cubicTo(SkBits2Float(0x41c732b7), SkBits2Float(0x42acca52), SkBits2Float(0xc14a7268), SkBits2Float(0x42b208b4), SkBits2Float(0xc22982dc), SkBits2Float(0x428ebb75));
 path.cubicTo(SkBits2Float(0xc2903490), SkBits2Float(0x4256dc6c), SkBits2Float(0xc2af8c6f), SkBits2Float(0x419be833), SkBits2Float(0xc2a36e37), SkBits2Float(0xc168c0a6));
 path.cubicTo(SkBits2Float(0xc2974fff), SkBits2Float(0xc242546a), SkBits2Float(0xc2448acf), SkBits2Float(0xc29698ac), SkBits2Float(0xc17253d7), SkBits2Float(0xc2a33682));
 path.lineTo(SkBits2Float(0xc12f2d38), SkBits2Float(0xc26bf872));
 path.cubicTo(SkBits2Float(0xc20e1427), SkBits2Float(0xc259bacc), SkBits2Float(0xc25ac3d7), SkBits2Float(0xc20c7ab2), SkBits2Float(0xc26c48f7), SkBits2Float(0xc1284130));
 path.cubicTo(SkBits2Float(0xc27dce17), SkBits2Float(0x41616864), SkBits2Float(0xc2507d50), SkBits2Float(0x421b5239), SkBits2Float(0xc1f51386), SkBits2Float(0x424e5c1e));
 path.cubicTo(SkBits2Float(0xc11258cd), SkBits2Float(0x4280b301), SkBits2Float(0x418fffac), SkBits2Float(0x4279d13a), SkBits2Float(0x42160652), SkBits2Float(0x423b5488));
 path.lineTo(SkBits2Float(0x424f88ba), SkBits2Float(0x428191f0));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp182(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x420048ef), SkBits2Float(0xc2a60000), SkBits2Float(0x4275172d), SkBits2Float(0xc2810bd2), SkBits2Float(0x429602e3), SkBits2Float(0xc20e29dc));
 path.cubicTo(SkBits2Float(0x42b17a30), SkBits2Float(0xc0d1e0a1), SkBits2Float(0x42a9174e), SkBits2Float(0x41ddef9e), SkBits2Float(0x4280787d), SkBits2Float(0x4252400e));
 path.lineTo(SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf6));
@@ skipping 11 matching lines @@
 path.cubicTo(SkBits2Float(0x42214ef3), SkBits2Float(0x42329f82), SkBits2Float(0x422e4bcd), SkBits2Float(0x4225f96c), SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf7));
 path.lineTo(SkBits2Float(0x4280787d), SkBits2Float(0x42524010));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp183(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x420048ef), SkBits2Float(0xc2a60000), SkBits2Float(0x4275172d), SkBits2Float(0xc2810bd2), SkBits2Float(0x429602e3), SkBits2Float(0xc20e29dc));
 path.cubicTo(SkBits2Float(0x42b17a30), SkBits2Float(0xc0d1e0a1), SkBits2Float(0x42a9174e), SkBits2Float(0x41ddef9e), SkBits2Float(0x4280787d), SkBits2Float(0x42524010));
 path.cubicTo(SkBits2Float(0x42711c0e), SkBits2Float(0x42659909), SkBits2Float(0x425f24ad), SkBits2Float(0x42771864), SkBits2Float(0x424b624a), SkBits2Float(0x4283347a));
 path.lineTo(SkBits2Float(0x42130648), SkBits2Float(0x423db1a5));
 path.cubicTo(SkBits2Float(0x42214ef3), SkBits2Float(0x42329f82), SkBits2Float(0x422e4bcd), SkBits2Float(0x4225f96c), SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf6));
 path.cubicTo(SkBits2Float(0x4274780f), SkBits2Float(0x41a06f8c), SkBits2Float(0x42804bfe), SkBits2Float(0xc097b7f0), SkBits2Float(0x4258e240), SkBits2Float(0xc1cd899e));
 path.cubicTo(SkBits2Float(0x42312c84), SkBits2Float(0xc23a929f), SkBits2Float(0x41b978e3), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x424b624a), SkBits2Float(0x42833479));
 path.cubicTo(SkBits2Float(0x41baac2f), SkBits2Float(0x42adda12), SkBits2Float(0xc168f6a7), SkBits2Float(0x42b1a2b3), SkBits2Float(0xc2303c92), SkBits2Float(0x428cae5c));
 path.cubicTo(SkBits2Float(0xc2931dbe), SkBits2Float(0x424f7409), SkBits2Float(0xc2b0c9d8), SkBits2Float(0x41878abe), SkBits2Float(0xc2a26e7f), SkBits2Float(0xc188ef9a));
 path.cubicTo(SkBits2Float(0xc2941327), SkBits2Float(0xc24cb4f5), SkBits2Float(0xc2397a7c), SkBits2Float(0xc29a4742), SkBits2Float(0xc13ec328), SkBits2Float(0xc2a44746));
 path.lineTo(SkBits2Float(0xc109e67a), SkBits2Float(0xc26d82d0));
 path.cubicTo(SkBits2Float(0xc20614b0), SkBits2Float(0xc25f0d94), SkBits2Float(0xc2561585), SkBits2Float(0xc213fb18), SkBits2Float(0xc26ad744), SkBits2Float(0xc145fabb));
 path.cubicTo(SkBits2Float(0xc27f9901), SkBits2Float(0x4143f6e8), SkBits2Float(0xc254b2af), SkBits2Float(0x4215f75b), SkBits2Float(0xc1feccbb), SkBits2Float(0x424b64f3));
 path.cubicTo(SkBits2Float(0xc128682f), SkBits2Float(0x42806945), SkBits2Float(0x4186f1ba), SkBits2Float(0x427b5a1e), SkBits2Float(0x4213064f), SkBits2Float(0x423db1a2));
 path.lineTo(SkBits2Float(0x424b624a), SkBits2Float(0x42833479));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp184(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42011b87), SkBits2Float(0xc2a5fffe), SkBits2Float(0x427681ab), SkBits2Float(0xc280937a), SkBits2Float(0x42967eb3), SkBits2Float(0xc20c1a94));
 path.cubicTo(SkBits2Float(0x42b1bc91), SkBits2Float(0xc0b87191), SkBits2Float(0x42a89454), SkBits2Float(0x41e5ed6f), SkBits2Float(0x427e0902), SkBits2Float(0x4255c0a2));
 path.lineTo(SkBits2Float(0x4237a3d0), SkBits2Float(0x421a8517));
@@ skipping 310 matching lines @@
 path.cubicTo(SkBits2Float(0x3f30e6e7), SkBits2Float(0xc26ffc2e), SkBits2Float(0x3f05138e), SkBits2Float(0xc26ffdf2), SkBits2Float(0x3eb27fc6), SkBits2Float(0xc26ffef7));
 path.lineTo(SkBits2Float(0x3ef6ec9b), SkBits2Float(0xc2a5ff48));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp195(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3f0607d9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f860760), SkBits2Float(0xc2a5fd76), SkBits2Float(0x3fc90825), SkBits2Float(0xc2a5f863));
 path.lineTo(SkBits2Float(0x3f9152f7), SkBits2Float(0xc26ff500));
 path.cubicTo(SkBits2Float(0x3f41c6b2), SkBits2Float(0xc26ffc55), SkBits2Float(0x3ec1c794), SkBits2Float(0xc26fffff), SkBits2Float(0x36a51f4a), SkBits2Float(0xc26fffff));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
 path.cubicTo(SkBits2Float(0x3fcfbb75), SkBits2Float(0xc2a5f7e2), SkBits2Float(0x3fd66eab), SkBits2Float(0xc2a5f75a), SkBits2Float(0x3fdd21d8), SkBits2Float(0xc2a5f6cb));
 path.lineTo(SkBits2Float(0x3f9fdac0), SkBits2Float(0xc26ff2b1));
 path.cubicTo(SkBits2Float(0x3f9b02da), SkBits2Float(0xc26ff37f), SkBits2Float(0x3f962add), SkBits2Float(0xc26ff444), SkBits2Float(0x3f9152da), SkBits2Float(0xc26ff500));
 path.lineTo(SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp196(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x36a51f4a), SkBits2Float(0xc26fffff));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3f0607d1), SkBits2Float(0xc2a60000), SkBits2Float(0x3f860758), SkBits2Float(0xc2a5fd76), SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
 
@@ skipping 31 matching lines @@
 path.cubicTo(SkBits2Float(0x4039d5dd), SkBits2Float(0xc26fb815), SkBits2Float(0x40340849), SkBits2Float(0xc26fbc83), SkBits2Float(0x402e3a8d), SkBits2Float(0xc26fc0bb));
 path.lineTo(SkBits2Float(0x4071043c), SkBits2Float(0xc2a5d43c));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp198(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x369bbf59), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3fa0bd4b), SkBits2Float(0xc2a60000), SkBits2Float(0x4020bab6), SkBits2Float(0xc2a5f168), SkBits2Float(0x4071043c), SkBits2Float(0xc2a5d43c));
 path.lineTo(SkBits2Float(0x40710446), SkBits2Float(0xc2a5d43c));
 path.cubicTo(SkBits2Float(0x40790b7f), SkBits2Float(0xc2a5d151), SkBits2Float(0x40808945), SkBits2Float(0xc2a5ce41), SkBits2Float(0x40848cac), SkBits2Float(0xc2a5cb0c));
 path.lineTo(SkBits2Float(0x403fa34c), SkBits2Float(0xc26fb371));
 path.quadTo(SkBits2Float(0x4036ef2a), SkBits2Float(0xc26fba67), SkBits2Float(0x402e3a95), SkBits2Float(0xc26fc0bb));
 path.lineTo(SkBits2Float(0x402e3a94), SkBits2Float(0xc26fc0ba));
 path.cubicTo(SkBits2Float(0x3fe86158), SkBits2Float(0xc26feae9), SkBits2Float(0x3f686554), SkBits2Float(0xc2700000), SkBits2Float(0x369bbf59), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x40848cae), SkBits2Float(0xc2a5cb0c));
 path.cubicTo(SkBits2Float(0x40c597bc), SkBits2Float(0xc2a5970c), SkBits2Float(0x41033f43), SkBits2Float(0xc2a53cca), SkBits2Float(0x41238fb3), SkBits2Float(0xc2a4bc74));
 path.lineTo(SkBits2Float(0x40ec7963), SkBits2Float(0xc26e2c38));
 path.cubicTo(SkBits2Float(0x40bdc13f), SkBits2Float(0xc26ee5c4), SkBits2Float(0x408ed689), SkBits2Float(0xc26f6843), SkBits2Float(0x403fa341), SkBits2Float(0xc26fb372));
 path.lineTo(SkBits2Float(0x40848cae), SkBits2Float(0xc2a5cb0c));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp199(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x3ffdfad4), SkBits2Float(0xc2a60000), SkBits2Float(0x407df074), SkBits2Float(0xc2a5db92), SkBits2Float(0x40be4d32), SkBits2Float(0xc2a592c7));
 path.lineTo(SkBits2Float(0x40899143), SkBits2Float(0xc26f6217));
 path.cubicTo(SkBits2Float(0x40379219), SkBits2Float(0xc26fcb54), SkBits2Float(0x3fb799b8), SkBits2Float(0xc26fffff), SkBits2Float(0x3673fea3), SkBits2Float(0xc26fffff));
@@ skipping 809 matching lines @@
 path.cubicTo(SkBits2Float(0x4264c2a3), SkBits2Float(0xc192666d), SkBits2Float(0x4261b27b), SkBits2Float(0xc1a45204), SkBits2Float(0x425e1cfb), SkBits2Float(0xc1b5d506));
 path.lineTo(SkBits2Float(0x4299a0d8), SkBits2Float(0xc1fb88d0));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp230(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x4206c976), SkBits2Float(0xc2a60000), SkBits2Float(0x42801937), SkBits2Float(0xc27a823c), SkBits2Float(0x4299a0d8), SkBits2Float(0xc1fb88d0));
 path.cubicTo(SkBits2Float(0x429c1b73), SkBits2Float(0xc1e34f53), SkBits2Float(0x429e39d2), SkBits2Float(0xc1ca8528), SkBits2Float(0x429ff920), SkBits2Float(0xc1b14b8c));
 path.lineTo(SkBits2Float(0x42674955), SkBits2Float(0xc1802a45));
 path.cubicTo(SkBits2Float(0x4264c2a3), SkBits2Float(0xc192666d), SkBits2Float(0x4261b27b), SkBits2Float(0xc1a45204), SkBits2Float(0x425e1cfa), SkBits2Float(0xc1b5d505));
 path.cubicTo(SkBits2Float(0x423933e1), SkBits2Float(0xc2351735), SkBits2Float(0x41c2df6b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x429ff91f), SkBits2Float(0xc1b14b8a));
 path.cubicTo(SkBits2Float(0x42ae673b), SkBits2Float(0x40783c41), SkBits2Float(0x42a293c2), SkBits2Float(0x41fe6960), SkBits2Float(0x4280464e), SkBits2Float(0x4252ba7b));
 path.cubicTo(SkBits2Float(0x423bf1b3), SkBits2Float(0x42932023), SkBits2Float(0x41a5f32c), SkBits2Float(0x42a99309), SkBits2Float(0xc0c67989), SkBits2Float(0x42a5892f));
 path.lineTo(SkBits2Float(0xc08f79c7), SkBits2Float(0x426f5437));
 path.cubicTo(SkBits2Float(0x416fed74), SkBits2Float(0x42752af2), SkBits2Float(0x4207dcfc), SkBits2Float(0x4254b62d), SkBits2Float(0x42397512), SkBits2Float(0x42185575));
 path.cubicTo(SkBits2Float(0x426b0d26), SkBits2Float(0x41b7e97d), SkBits2Float(0x427c2639), SkBits2Float(0x40337286), SkBits2Float(0x42674956), SkBits2Float(0xc1802a46));
 path.lineTo(SkBits2Float(0x429ff91f), SkBits2Float(0xc1b14b8a));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp231(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x421472e7), SkBits2Float(0xc2a5ffff), SkBits2Float(0x428b6da4), SkBits2Float(0xc26973d7), SkBits2Float(0x429fb179), SkBits2Float(0xc1b54986));
 path.lineTo(SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
 path.cubicTo(SkBits2Float(0x42499544), SkBits2Float(0xc228c2c8), SkBits2Float(0x41d69ff6), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
@@ skipping 149 matching lines @@
 path.cubicTo(SkBits2Float(0x4221adc8), SkBits2Float(0x424bd107), SkBits2Float(0x42672d88), SkBits2Float(0x41eea576), SkBits2Float(0x426f3a3c), SkBits2Float(0x4099edfe));
 path.lineTo(SkBits2Float(0x42a57735), SkBits2Float(0x40d4ef9d));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp237(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41b25a1b), SkBits2Float(0xc2a60000), SkBits2Float(0x422e9a51), SkBits2Float(0xc294100b), SkBits2Float(0x426d0a79), SkBits2Float(0xc26874a1));
 path.cubicTo(SkBits2Float(0x4295bd51), SkBits2Float(0xc228c92e), SkBits2Float(0x42a6d6d5), SkBits2Float(0xc1a5596e), SkBits2Float(0x42a5f7e5), SkBits2Float(0x3fcf7f4c));
 path.lineTo(SkBits2Float(0x426ff448), SkBits2Float(0x3f95ff69));
 path.cubicTo(SkBits2Float(0x4271369b), SkBits2Float(0xc16f0f30), SkBits2Float(0x42587daa), SkBits2Float(0xc1f4071e), SkBits2Float(0x422b5ada), SkBits2Float(0xc2280a4b));
 path.cubicTo(SkBits2Float(0x41fc7014), SkBits2Float(0xc2561107), SkBits2Float(0x4180eddd), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
@@ skipping 538 matching lines @@
 path.cubicTo(SkBits2Float(0x423b9c18), SkBits2Float(0x42169f65), SkBits2Float(0x4245bae4), SkBits2Float(0x42091136), SkBits2Float(0x424e5858), SkBits2Float(0x41f5204d));
 path.lineTo(SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bad));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp256(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41eeb164), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42658277), SkBits2Float(0xc285f892), SkBits2Float(0x42904565), SkBits2Float(0xc22437b5));
 path.cubicTo(SkBits2Float(0x42adc98d), SkBits2Float(0xc171f917), SkBits2Float(0x42ad3226), SkBits2Float(0x4185deb4), SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bad));
 path.lineTo(SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bae));
 path.cubicTo(SkBits2Float(0x4288c365), SkBits2Float(0x423d9c16), SkBits2Float(0x4281c36f), SkBits2Float(0x42505c7e), SkBits2Float(0x4273ad50), SkBits2Float(0x42617d52));
 path.lineTo(SkBits2Float(0x423026ec), SkBits2Float(0x42230126));
 path.cubicTo(SkBits2Float(0x423b9c18), SkBits2Float(0x42169f65), SkBits2Float(0x4245bae4), SkBits2Float(0x42091136), SkBits2Float(0x424e5858), SkBits2Float(0x41f5204d));
 path.cubicTo(SkBits2Float(0x427a675e), SkBits2Float(0x41418c02), SkBits2Float(0x427b4242), SkBits2Float(0xc12eeb9b), SkBits2Float(0x425095b0), SkBits2Float(0xc1ed6c50));
 path.cubicTo(SkBits2Float(0x4225e91e), SkBits2Float(0xc241b169), SkBits2Float(0x41ac8c92), SkBits2Float(0xc2700000), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x4273ad4f), SkBits2Float(0x42617d52));
 path.cubicTo(SkBits2Float(0x421bc173), SkBits2Float(0x42a0404f), SkBits2Float(0x40a50405), SkBits2Float(0x42b1dfaa), SkBits2Float(0xc1cd0022), SkBits2Float(0x429de3fd));
 path.cubicTo(SkBits2Float(0xc261a0a2), SkBits2Float(0x4289e850), SkBits2Float(0xc29d25ee), SkBits2Float(0x4227ed4e), SkBits2Float(0xc2a4d3d8), SkBits2Float(0x411d8f80));
 path.cubicTo(SkBits2Float(0xc2ac81c3), SkBits2Float(0xc1b24b1c), SkBits2Float(0xc28e216c), SkBits2Float(0xc256e38c), SkBits2Float(0xc22e0453), SkBits2Float(0xc28d5ec3));
 path.lineTo(SkBits2Float(0xc1fb9743), SkBits2Float(0xc24c63fd));
 path.cubicTo(SkBits2Float(0xc24d7d6b), SkBits2Float(0xc21b575f), SkBits2Float(0xc279684a), SkBits2Float(0xc180e302), SkBits2Float(0xc26e4dff), SkBits2Float(0x40e3cc4e));
 path.cubicTo(SkBits2Float(0xc26333b4), SkBits2Float(0x41f2c929), SkBits2Float(0xc2231aa4), SkBits2Float(0x42476256), SkBits2Float(0xc1943166), SkBits2Float(0x4264467e));
 path.cubicTo(SkBits2Float(0x406e93d1), SkBits2Float(0x42809553), SkBits2Float(0x41e1305a), SkBits2Float(0x4267b03c), SkBits2Float(0x423026ed), SkBits2Float(0x42230127));
 path.lineTo(SkBits2Float(0x4273ad4f), SkBits2Float(0x42617d52));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp257(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x41f2d268), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426923a2), SkBits2Float(0xc284dd06), SkBits2Float(0x4291aced), SkBits2Float(0xc21f2e53));
 path.cubicTo(SkBits2Float(0x42aec809), SkBits2Float(0xc1528a66), SkBits2Float(0x42ac7c90), SkBits2Float(0x419a60b1), SkBits2Float(0x428bb0fe), SkBits2Float(0x42335ba0));
 path.lineTo(SkBits2Float(0x4249f6a4), SkBits2Float(0x4201a806));
@@ skipping 346 matching lines @@
 path.cubicTo(SkBits2Float(0xc1270bd9), SkBits2Float(0x42806e40), SkBits2Float(0x41878138), SkBits2Float(0x427b4278), SkBits2Float(0x421335f8), SkBits2Float(0x423d8ca8));
 path.lineTo(SkBits2Float(0x424ba440), SkBits2Float(0x42831ae2));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp269(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42011047), SkBits2Float(0xc2a60000), SkBits2Float(0x42766e56), SkBits2Float(0xc28099ef), SkBits2Float(0x42967824), SkBits2Float(0xc20c36c8));
 path.cubicTo(SkBits2Float(0x42b1b91c), SkBits2Float(0xc0b9cd9b), SkBits2Float(0x42a89b7a), SkBits2Float(0x41e5804f), SkBits2Float(0x427e310b), SkBits2Float(0x42559106));
 path.lineTo(SkBits2Float(0x4237c0bf), SkBits2Float(0x421a62ac));
 path.cubicTo(SkBits2Float(0x4273c506), SkBits2Float(0x41a5e791), SkBits2Float(0x4280797a), SkBits2Float(0xc08650bf), SkBits2Float(0x42598bc5), SkBits2Float(0xc1cab811));
 path.cubicTo(SkBits2Float(0x42322494), SkBits2Float(0xc239edfa), SkBits2Float(0x41ba9913), SkBits2Float(0xc2700002), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x427e3109), SkBits2Float(0x42559108));
 path.cubicTo(SkBits2Float(0x426e0477), SkBits2Float(0x4268d13b), SkBits2Float(0x425bb575), SkBits2Float(0x427a2b1d), SkBits2Float(0x42479e2a), SkBits2Float(0x4284a4a0));
 path.lineTo(SkBits2Float(0x42104d52), SkBits2Float(0x423fc5ea));
 path.cubicTo(SkBits2Float(0x421ed35e), SkBits2Float(0x4234d83a), SkBits2Float(0x422c0f91), SkBits2Float(0x42284d3a), SkBits2Float(0x4237c0bf), SkBits2Float(0x421a62ad));
 path.lineTo(SkBits2Float(0x427e3109), SkBits2Float(0x42559108));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp270(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42011047), SkBits2Float(0xc2a60000), SkBits2Float(0x42766e56), SkBits2Float(0xc28099ef), SkBits2Float(0x42967824), SkBits2Float(0xc20c36c8));
 path.cubicTo(SkBits2Float(0x42b1b91c), SkBits2Float(0xc0b9cd9b), SkBits2Float(0x42a89b7a), SkBits2Float(0x41e5804f), SkBits2Float(0x427e310b), SkBits2Float(0x42559106));
@@ skipping 74 matching lines @@
 path.cubicTo(SkBits2Float(0xc14c6303), SkBits2Float(0x427fa162), SkBits2Float(0x4170087f), SkBits2Float(0x427dafb7), SkBits2Float(0x420e0af6), SkBits2Float(0x424173d2));
 path.lineTo(SkBits2Float(0x42447e16), SkBits2Float(0x4285cdfb));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp273(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42023f77), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427876e4), SkBits2Float(0xc27fd6f4), SkBits2Float(0x42972728), SkBits2Float(0xc2093dbb));
 path.cubicTo(SkBits2Float(0x42b212de), SkBits2Float(0xc0952410), SkBits2Float(0x42a7d55b), SkBits2Float(0x41f0f791), SkBits2Float(0x4279eebf), SkBits2Float(0x425a890b));
 path.lineTo(SkBits2Float(0x4234ac95), SkBits2Float(0x421dfa35));
 path.cubicTo(SkBits2Float(0x4272a697), SkBits2Float(0x41ae3171), SkBits2Float(0x4280ba5e), SkBits2Float(0xc057a00f), SkBits2Float(0x425a88d0), SkBits2Float(0xc1c66bc2));
 path.cubicTo(SkBits2Float(0x42339ce5), SkBits2Float(0xc238f1c1), SkBits2Float(0x41bc4f6b), SkBits2Float(0xc2700002), SkBits2Float(0xb630015d), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x4279eebd), SkBits2Float(0x425a890e));
 path.cubicTo(SkBits2Float(0x42693cf3), SkBits2Float(0x426da0dc), SkBits2Float(0x42566929), SkBits2Float(0x427ebed8), SkBits2Float(0x4241d1ac), SkBits2Float(0x4286c6a2));
 path.lineTo(SkBits2Float(0x420c1c33), SkBits2Float(0x4242db53));
 path.cubicTo(SkBits2Float(0x421afee9), SkBits2Float(0x42382742), SkBits2Float(0x42289b18), SkBits2Float(0x422bc78f), SkBits2Float(0x4234ac94), SkBits2Float(0x421dfa34));
 path.lineTo(SkBits2Float(0x4279eebd), SkBits2Float(0x425a890e));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp274(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0xb630015d), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42023f77), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427876e4), SkBits2Float(0xc27fd6f4), SkBits2Float(0x42972728), SkBits2Float(0xc2093dbb));
 path.cubicTo(SkBits2Float(0x42b212de), SkBits2Float(0xc0952410), SkBits2Float(0x42a7d55b), SkBits2Float(0x41f0f791), SkBits2Float(0x4279eebf), SkBits2Float(0x425a890b));
@@ skipping 260 matching lines @@
 path.cubicTo(SkBits2Float(0xc175dd55), SkBits2Float(0x427ddd08), SkBits2Float(0x414d1bd1), SkBits2Float(0x42800ed7), SkBits2Float(0x420828d0), SkBits2Float(0x4245a338));
 path.lineTo(SkBits2Float(0x423c5a8f), SkBits2Float(0x4288b30a));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp283(skiatest::Reporter* reporter, const char* filename) {
+    if (!FLAGS_runFail) {
+        return;  // draws wrong
+    }
     SkPath path;
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42036bf7), SkBits2Float(0xc2a60000), SkBits2Float(0x427a7934), SkBits2Float(0xc27e7a35), SkBits2Float(0x4297d0ad), SkBits2Float(0xc2064926));
 path.cubicTo(SkBits2Float(0x42b264c0), SkBits2Float(0xc061818a), SkBits2Float(0x42a70569), SkBits2Float(0x41fc47ee), SkBits2Float(0x42759f2d), SkBits2Float(0x425f5e99));
 path.lineTo(SkBits2Float(0x42318ed2), SkBits2Float(0x422178d2));
 path.cubicTo(SkBits2Float(0x427179f2), SkBits2Float(0x41b65f2f), SkBits2Float(0x4280f58f), SkBits2Float(0xc0230424), SkBits2Float(0x425b7de6), SkBits2Float(0xc1c225e6));
 path.cubicTo(SkBits2Float(0x423510af), SkBits2Float(0xc237f5a4), SkBits2Float(0x41be01e5), SkBits2Float(0xc26fffff), SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
 path.close();
 
     SkPath path1(path);
     path.reset();
     path.setFillType((SkPath::FillType) 0);
 path.moveTo(SkBits2Float(0x42759f2b), SkBits2Float(0x425f5e9b));
 path.cubicTo(SkBits2Float(0x42646988), SkBits2Float(0x42724b20), SkBits2Float(0x425112cb), SkBits2Float(0x42819524), SkBits2Float(0x423bfd7a), SkBits2Float(0x4288d30e));
 path.lineTo(SkBits2Float(0x4207e580), SkBits2Float(0x4245d187));
 path.cubicTo(SkBits2Float(0x4217232e), SkBits2Float(0x423b592c), SkBits2Float(0x42251e07), SkBits2Float(0x422f26e4), SkBits2Float(0x42318ed3), SkBits2Float(0x422178d2));
 path.lineTo(SkBits2Float(0x42759f2b), SkBits2Float(0x425f5e9b));
 path.close();
 
     SkPath path2(path);
-    testPathOpCheck(reporter, path1, path2, (SkPathOp) 2, filename, FLAGS_runFail);
+    testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 // op end success 1
 
 static void battleOp284(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType((SkPath::FillType) 1);
 path.moveTo(SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
 path.cubicTo(SkBits2Float(0x42036bf7), SkBits2Float(0xc2a60000), SkBits2Float(0x427a7934), SkBits2Float(0xc27e7a35), SkBits2Float(0x4297d0ad), SkBits2Float(0xc2064926));
 path.cubicTo(SkBits2Float(0x42b264c0), SkBits2Float(0xc061818a), SkBits2Float(0x42a70569), SkBits2Float(0x41fc47ee), SkBits2Float(0x42759f2d), SkBits2Float(0x425f5e99));
@@ skipping 2802 matching lines @@
 path.cubicTo(SkBits2Float(0x3dbed1a5), SkBits2Float(0xc2a5fffa), SkBits2Float(0x3dfda9cc), SkBits2Float(0xc2a5fff4), SkBits2Float(0x3e1e40f8), SkBits2Float(0xc2a5ffed));
 path.lineTo(SkBits2Float(0x3de4ce81), SkBits2Float(0xc26fffe5));
 path.cubicTo(SkBits2Float(0x3db75eff), SkBits2Float(0xc26ffff0), SkBits2Float(0x3d89f101), SkBits2Float(0xc26ffff8), SkBits2Float(0x3d390604), SkBits2Float(0xc26ffffc));
 path.lineTo(SkBits2Float(0x3d7ff566), SkBits2Float(0xc2a5fffd));
 path.close();
 
     SkPath path2(path);
     testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
 }
 
-static void (*firstTest)(skiatest::Reporter* , const char* filename) = battleOp352;
+static void (*firstTest)(skiatest::Reporter* , const char* filename) = battleOp6001;
 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
     TEST(battleOp1),
     TEST(battleOp2),
     TEST(battleOp3),
     TEST(battleOp4),
     TEST(battleOp5),
     TEST(battleOp6),
     TEST(battleOp7),
@@ skipping 32 matching lines @@
     TEST(battleOp37),
     TEST(battleOp38),
     TEST(battleOp39),
     TEST(battleOp40),
 
     TEST(battleOp41),
     TEST(battleOp42),
     TEST(battleOp43),
     TEST(battleOp44),
     TEST(battleOp45),
+    TEST(battleOp46),  // draws wrong : dropped an outer cubic incorrectly
+    // if assembly rewrite was done, the error would be hidden
     TEST(battleOp47),
     TEST(battleOp48),
     TEST(battleOp49),
     TEST(battleOp50),
 
     TEST(battleOp51),
     TEST(battleOp52),
     TEST(battleOp53),
+    TEST(battleOp54),  // draws wrong
     TEST(battleOp55),
     TEST(battleOp56),
     TEST(battleOp57),
     TEST(battleOp58),
-    TEST(battleOp59),
+    TEST(battleOp59),  // draws wrong
     TEST(battleOp60),
 
     TEST(battleOp61),
     TEST(battleOp62),
+    TEST(battleOp63),  // draws wrong
     TEST(battleOp64),
     TEST(battleOp65),
     TEST(battleOp66),
     TEST(battleOp67),
     TEST(battleOp68),
     TEST(battleOp69),
     TEST(battleOp70),
 
     TEST(battleOp71),
     TEST(battleOp72),
     TEST(battleOp73),
     TEST(battleOp74),
     TEST(battleOp75),
     TEST(battleOp76),
     TEST(battleOp77),
     TEST(battleOp78),
     TEST(battleOp79),
     TEST(battleOp80),
 
     TEST(battleOp81),
     TEST(battleOp82),
     TEST(battleOp83),
     TEST(battleOp84),
-    TEST(battleOp85),
+    TEST(battleOp85),  // draws wrong
     TEST(battleOp86),
     TEST(battleOp87),
     TEST(battleOp88),
     TEST(battleOp89),
     TEST(battleOp90),
 
     TEST(battleOp91),
     TEST(battleOp92),
     TEST(battleOp93),
     TEST(battleOp94),
@@ skipping 48 matching lines @@
     TEST(battleOp139),
     TEST(battleOp140),
 
     TEST(battleOp141),
     TEST(battleOp142),
     TEST(battleOp143),
     TEST(battleOp144),
     TEST(battleOp145),
     TEST(battleOp146),
     TEST(battleOp147),
+    TEST(battleOp148),  // draws wrong
     TEST(battleOp149),
     TEST(battleOp150),
 
     TEST(battleOp151),
+    TEST(battleOp152),
     TEST(battleOp153),
     TEST(battleOp154),
     TEST(battleOp155),
     TEST(battleOp156),
+    TEST(battleOp157),
     TEST(battleOp158),
     TEST(battleOp159),
     TEST(battleOp160),
 
     TEST(battleOp161),
     TEST(battleOp162),
+    TEST(battleOp163),
     TEST(battleOp164),
     TEST(battleOp165),
     TEST(battleOp166),
     TEST(battleOp167),
     TEST(battleOp168),
     TEST(battleOp169),
     TEST(battleOp170),
 
     TEST(battleOp171),
     TEST(battleOp172),
     TEST(battleOp173),
     TEST(battleOp174),
     TEST(battleOp175),
     TEST(battleOp176),
     TEST(battleOp177),
     TEST(battleOp178),
     TEST(battleOp179),
     TEST(battleOp180),
 
+    TEST(battleOp181),
     TEST(battleOp182),
+    TEST(battleOp183),
     TEST(battleOp184),
     TEST(battleOp185),
     TEST(battleOp186),
     TEST(battleOp187),
     TEST(battleOp188),
     TEST(battleOp189),
     TEST(battleOp190),
 
     TEST(battleOp191),
     TEST(battleOp192),
     TEST(battleOp193),
     TEST(battleOp194),
+    TEST(battleOp195),
     TEST(battleOp196),
     TEST(battleOp197),
+    TEST(battleOp198),
     TEST(battleOp199),
     TEST(battleOp200),
 
     TEST(battleOp201),
     TEST(battleOp202),
     TEST(battleOp203),
     TEST(battleOp204),
     TEST(battleOp205),
     TEST(battleOp206),
     TEST(battleOp207),
@@ skipping 14 matching lines @@
 
     TEST(battleOp221),
     TEST(battleOp222),
     TEST(battleOp223),
     TEST(battleOp224),
     TEST(battleOp225),
     TEST(battleOp226),
     TEST(battleOp227),
     TEST(battleOp228),
     TEST(battleOp229),
+    TEST(battleOp230),
 
     TEST(battleOp231),
     TEST(battleOp232),
     TEST(battleOp233),
     TEST(battleOp234),
     TEST(battleOp235),
     TEST(battleOp236),
     TEST(battleOp237),
     TEST(battleOp238),
     TEST(battleOp239),
     TEST(battleOp240),
 
     TEST(battleOp241),
     TEST(battleOp242),
     TEST(battleOp243),
     TEST(battleOp244),
     TEST(battleOp245),
     TEST(battleOp246),
     TEST(battleOp247),
     TEST(battleOp248),
     TEST(battleOp249),
     TEST(battleOp250),
 
     TEST(battleOp251),
     TEST(battleOp252),
     TEST(battleOp253),
     TEST(battleOp254),
     TEST(battleOp255),
+    TEST(battleOp256),
     TEST(battleOp257),
     TEST(battleOp258),
     TEST(battleOp259),
     TEST(battleOp260),
 
     TEST(battleOp261),
     TEST(battleOp262),
     TEST(battleOp263),
     TEST(battleOp264),
     TEST(battleOp265),
     TEST(battleOp266),
     TEST(battleOp267),
     TEST(battleOp268),
+    TEST(battleOp269),
     TEST(battleOp270),
 
     TEST(battleOp271),
     TEST(battleOp272),
+    TEST(battleOp273),
     TEST(battleOp274),
     TEST(battleOp275),
     TEST(battleOp276),
     TEST(battleOp277),
     TEST(battleOp278),
     TEST(battleOp279),
     TEST(battleOp280),
 
     TEST(battleOp281),
     TEST(battleOp282),
+    TEST(battleOp283),
     TEST(battleOp284),
     TEST(battleOp285),
     TEST(battleOp286),
     TEST(battleOp287),
     TEST(battleOp288),
     TEST(battleOp289),
     TEST(battleOp290),
 
     TEST(battleOp291),
     TEST(battleOp292),
@@ skipping 93 matching lines @@
 
     TEST(battleOp5193),
     TEST(battleOp5194),
 
     TEST(battleOp6000),
     TEST(battleOp6001),
 
     TEST(issue414409c),
     TEST(issue414409b),
     TEST(issue414409),
-
-    // these draw wrong
-    TEST(battleOp46),  // dropped an outer cubic incorrectly
-                       // if assembly rewrite was done, the error would be hidden
-    TEST(battleOp54),
-    TEST(battleOp63),
-    TEST(battleOp152),
-    TEST(battleOp157),
-    TEST(battleOp163),
-    TEST(battleOp181),
-    TEST(battleOp183),
-    TEST(battleOp195),
-    TEST(battleOp198),
-    TEST(battleOp230),
-    TEST(battleOp256),
-    TEST(battleOp269),
-    TEST(battleOp273),
-    TEST(battleOp148),
-    TEST(battleOp283),
 };
 
 
 static const size_t testCount = SK_ARRAY_COUNT(tests);
 
 static bool runReverse = false;
 
 DEF_TEST(PathOpsBattle, reporter) {
 #if DEBUG_SHOW_TEST_NAME
     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
 #endif
     RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
 }