fix last skp bug

tests/PathOpsOpTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsExtendedTest.h"
+#include "PathOpsTestCommon.h"
 
 #define TEST(name) { name, #name }
 
 static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0,1);
     path.cubicTo(0,2, 1,0, 1,0);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
@@ skipping 1807 matching lines @@
     pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
     pathB.lineTo(96, 289);
     pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
     pathB.lineTo(91, 127);
     pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
     pathB.lineTo(258, 122);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#define ISSUE_1417_WORKING_ON_LINUX_32 0  // fails only in release linux skia_arch_width=32
-#if ISSUE_1417_WORKING_ON_LINUX_32
 static void issue1417(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1;
     path1.moveTo(122.58908843994140625f, 82.2836456298828125f);
     path1.quadTo(129.8215789794921875f, 80, 138, 80);
     path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f);
     path1.lineTo(161.1764678955078125f, 100);
     path1.lineTo(161.1764678955078125f, 100);
     path1.lineTo(115.29412078857421875f, 100);
     path1.lineTo(115.29412078857421875f, 100);
     path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
@@ skipping 91 matching lines @@
     path2.lineTo(132.2864990234375f, 169.6969757080078125f);
     path2.lineTo(132.2864990234375f, 169.6969757080078125f);
     path2.lineTo(118.68194580078125f, 160.343841552734375f);
     path2.lineTo(118.68194580078125f, 160.343841552734375f);
     path2.lineTo(113.232177734375f, 173.5789947509765625f);
     path2.lineTo(113.232177734375f, 173.5789947509765625f);
     path2.close();
 
     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
 }
-#endif
 
 static void issue1418(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1;
     path1.moveTo(0, 0);
     path1.lineTo(1, 0);
     path1.lineTo(1, 0);
     path1.lineTo(1, 1);
     path1.lineTo(1, 1);
     path1.lineTo(0, 1);
     path1.lineTo(0, 1);
@@ skipping 99 matching lines @@
     pathB.lineTo(1, 3);
     pathB.close();
     pathB.moveTo(2, 2);
     pathB.lineTo(3, 2);
     pathB.lineTo(3, 3);
     pathB.lineTo(2, 3);
     pathB.close();
     testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
 }
 
-#define ISSUE_1435_FIXED 0
-#if ISSUE_1435_FIXED
 // this fails to generate two interior line segments 
 // an earlier pathops succeeded, but still failed to generate one interior line segment
 // (but was saved by assemble, which works around a single line missing segment)
 static void issue1435(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1;
     path1.moveTo(160, 60);
     path1.lineTo(220, 230);
     path1.lineTo(60, 120);
     path1.lineTo(260, 120);
     path1.lineTo(90, 230);
@@ skipping 33 matching lines @@
     path2.moveTo(195.830978f, 161.521133f);
     path2.lineTo(207.878281f, 153.725815f);
     path2.quadTo(208, 151.888062f, 208, 150);
     path2.quadTo(208, 132.942657f, 198.066238f, 120);
     path2.lineTo(181.176468f, 120);
     path2.lineTo(195.830978f, 161.521133f);
     path2.close();
     path2.setFillType(SkPath::kEvenOdd_FillType);
     testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
 }
-#endif
 
 static void skpkkiste_to716(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(1173, 284);
     path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
     path.lineTo(1174, 123.999496f);
     path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
     path.lineTo(1173, 284);
     path.close();
@@ skipping 595 matching lines @@
     pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
     pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
     pathB.lineTo(194, 1041);
     pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
     pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
     pathB.lineTo(195, 785);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
 
-#define SKPS_WORKING 0
-#if SKPS_WORKING
+#define QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION 0
+#if QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION
 // this fails because cubic/quad misses an intersection (failure is isolated in c/q int test)
 static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) {
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(945, 597);
     path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
     path.quadTo(870, 640.93396f, 870, 672);
     path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
     path.quadTo(913.93396f, 747, 945, 747);
     path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
@@ skipping 519 matching lines @@
     path.moveTo(2,4);
     path.cubicTo(2,3, 6,4, 1,0);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(4,6);
     pathB.cubicTo(0,1, 4,2, 3,2);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
-// triggers untested calcLoopSpanCount code path
-#if 0
 static void cubicOp113(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.moveTo(2,4);
     path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
     path.close();
     pathB.moveTo(3,5);
     pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
     pathB.close();
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
-#endif
 
+#define CUBIC_OP_114 0
+#if CUBIC_OP_114
 static void cubicOp114(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kWinding_FillType);
     path.moveTo(0, 1);
     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
     path.close();
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.moveTo(1, 3);
     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
     pathB.close();
     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 }
+#endif
+
+static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) {
+    SkPath path, pathB;
+    path.setFillType(SkPath::kWinding_FillType);
+    path.moveTo(0, 1);
+    path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
+    path.close();
+    pathB.setFillType(SkPath::kWinding_FillType);
+    pathB.moveTo(1, 3);
+    pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
+    pathB.close();
+    SkPath qPath, qPathB;
+    CubicPathToQuads(path, &qPath);
+    CubicPathToQuads(pathB, &qPathB);
+    testPathOp(reporter, qPath, qPathB, kIntersect_PathOp, filename);
+}
 
 static void quadOp10i(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.moveTo(0, 0);
     path.quadTo(1, 8, 3, 5);
     path.lineTo(8, 1);
     path.close();
     pathB.moveTo(0, 0);
     pathB.quadTo(8, 1, 4, 8);
     pathB.close();
@@ skipping 31 matching lines @@
     path2.cubicTo(36.71843719482421875, 0.8886508941650390625,
                   35.123386383056640625, 0.554015457630157470703125,
                   34.511409759521484375, -0.1152553558349609375);
     path2.cubicTo(33.899425506591796875, -0.7845261096954345703125,
                   34.53484344482421875, -5.6777553558349609375,
                   34.53484344482421875, -5.6777553558349609375);
     path2.close();
     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
 }
 
-#define TEST_2540 0
-#if TEST_2540  // FIXME: extends cubic arm for sorting, marks extension with wrong winding?
 static void issue2540(skiatest::Reporter* reporter, const char* filename) {
     SkPath path1;
     path1.moveTo(26.5054988861083984375, 85.73960113525390625);
     path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875);
     path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625);
     path1.lineTo(23.1654987335205078125, 89.72879791259765625);
     path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875);
     path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375);
     path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625);
     path1.close();
 
     SkPath path2;
     path2.moveTo(-25.077999114990234375, 124.9120025634765625);
     path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125);
     path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625);
     path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625);
     path2.close();
     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
 }
-#endif
 
 static void rects1(skiatest::Reporter* reporter, const char* filename) {
     SkPath path, pathB;
     path.setFillType(SkPath::kEvenOdd_FillType);
     path.moveTo(0, 0);
     path.lineTo(1, 0);
     path.lineTo(1, 1);
     path.lineTo(0, 1);
     path.close();
     path.moveTo(0, 0);
@@ skipping 61 matching lines @@
     pathB.setFillType(SkPath::kWinding_FillType);
     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 }
 
 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static struct TestDesc tests[] = {
+#if CUBIC_OP_114  // FIXME: curve with inflection is ordered the wrong way
+    TEST(cubicOp114),
+#endif
+    TEST(cubicOp114asQuad),
     TEST(rects4),
     TEST(rects3),
     TEST(rects2),
     TEST(rects1),
-#if TEST_2540  // FIXME: extends cubic arm for sorting, marks extension with wrong winding?
     TEST(issue2540),
-#endif
     TEST(issue2504),
     TEST(kari1),
     TEST(quadOp10i),
-#if 0  // FIXME: serpentine curve is ordered the wrong way
-    TEST(cubicOp114),
-#endif
-#if 0  // FIXME: currently failing
     TEST(cubicOp113),
-#endif
-#if SKPS_WORKING
+#if QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION
     // fails because a cubic/quadratic intersection is missed
     // the internal quad/quad is far enough away from the real cubic/quad that it is rejected
     TEST(skpcarrot_is24),
 #endif
-#if ISSUE_1417_WORKING_ON_LINUX_32
     TEST(issue1417),
-#endif
     TEST(cubicOp112),
     TEST(skpadspert_net23),
     TEST(skpadspert_de11),
     TEST(findFirst1),
     TEST(xOp2i),
     TEST(xOp3i),
     TEST(xOp1u),
     TEST(xOp1i),
     TEST(cubicOp111),
     TEST(cubicOp110),
     TEST(cubicOp109),
     TEST(cubicOp108),
     TEST(cubicOp107),
     TEST(cubicOp106),
     TEST(cubicOp105),
     TEST(cubicOp104),
     TEST(cubicOp103),
     TEST(cubicOp102),
     TEST(cubicOp101),
     TEST(cubicOp100),
     TEST(cubicOp99),
-#if ISSUE_1435_FIXED
     TEST(issue1435),
-#endif
     TEST(cubicOp98x),
     TEST(cubicOp97x),
     TEST(skpcarpetplanet_ru22),  // cubic/cubic intersect detects unwanted coincidence
     TEST(cubicOp96d),
     TEST(cubicOp95u),
     TEST(skpadbox_lt15),
     TEST(skpagentxsites_com55),
     TEST(skpadventistmission_org572),
     TEST(skpadoption_org196),
     TEST(skpbambootheme_com12),
@@ skipping 157 matching lines @@
     TEST(cubicOp6d),
     TEST(cubicOp5d),
     TEST(cubicOp3d),
     TEST(cubicOp2d),
     TEST(cubicOp1d),
 };
 
 static const size_t testCount = SK_ARRAY_COUNT(tests);
 
 static struct TestDesc subTests[] = {
-    TEST(cubicOp114),
     TEST(cubicOp58d),
     TEST(cubicOp53d),
 };
 
 static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
 
 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0;
 
 static bool runSubTests = false;
 static bool runSubTestsFirst = false;
@@ skipping 25 matching lines @@
 };
 
 static const size_t failTestCount = SK_ARRAY_COUNT(failTests);
 
 DEF_TEST(PathOpsFailOp, reporter) {
 #if DEBUG_SHOW_TEST_NAME
     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
 #endif
     RunTestSet(reporter, failTests, failTestCount, 0, 0, false);
 }