path ops work in progress

tests/PathOpsAngleTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpSegment.h"
 #include "SkTArray.h"
 #include "Test.h"
 
@@ skipping 10 matching lines @@
 /* 8 */    {{0,3}, {0,1}, {2,0}, {1,0}},
 /* 9 */    {{189,7}, {189,5.3431458473205566f}, {190.3431396484375f,4}, {192,4}},
 /* 10 */   {{0,1}, {1,3}, {1,0}, {6,4}},
 /* 11 */   {{0,1}, {2,3}, {2,1}, {4,3}},
 /* 12 */   {{1,2}, {3,4}, {1,0}, {3,2}},
 /* 13 */   {{0,1}, {4,6}, {4,3}, {5,4}},
 /* 14 */   {{806,11419}, {806.962890625f,11419}, {807.76690673828125f,11418.3193359375f}, {807.957275390625f,11417.4130859375f}},
 /* 15 */   {{808,11417}, {808,11418.1044921875f}, {807.10455322265625f,11419}, {806,11419}},
 /* 16 */   {{132,11419}, {130.89543151855469f,11419}, {130,11418.1044921875f}, {130,11417}},
 /* 17 */   {{130.04275512695312f,11417.4130859375f}, {130.23312377929687f,11418.3193359375f}, {131.03707885742187f,11419}, {132,11419}},
+/* 18 */   {{1006.6951293945312f,291}, {1023.263671875f,291}, {1033.8402099609375f,304.43145751953125f}, {1030.318359375f,321}},
 };
 
 static const SkPoint quads[][3] = {
 /* 0 */    {{12.3423996f, 228.342407f}, {10, 230.686295f}, {10, 234}},
 /* 1 */    {{304.24319458007812f,591.75677490234375f}, {306,593.51470947265625f}, {306,596}},
 /* 2 */    {{0,0}, {3,1}, {0,3}},
 /* 3 */    {{0,1}, {3,1}, {0,2}},
 };
 
 static const SkPoint lines[][2] = {
 /* 0 */    {{6, 2}, {2, 4}},
 /* 1 */    {{306,617}, {306,590}},
 /* 2 */    {{306,596}, {306,617}},
 /* 3 */    {{6,4}, {0,1}},
 /* 4 */    {{6,1}, {0,1}},
 /* 5 */    {{1,0}, {0,3}},
 /* 6 */    {{246,4}, {189,4}},
 /* 7 */    {{192,4}, {243,4}},
 /* 8 */    {{4,3}, {0,1}},
 /* 9 */    {{3,2}, {1,2}},
 /* 10 */   {{6,4}, {3,4}},
+/* 11 */   {{979.30487060546875f,561}, {1036.695068359375f,291}},
 };
 
 struct SortSet {
     const SkPoint* ptData;
     int ptCount;
     double tStart;
     double tEnd;
     SkPoint endPt;
 };
 
@@ skipping 123 matching lines @@
     {cubics[15], 4, 0.188518131, 0, {0, 0}},
     {cubics[14], 4, 0.93081374, 0, {0, 0}},
 };
 
 static const SortSet set16[] = {
     {cubics[17], 4, 0.0682619216, 0, {130.042755f,11417.4131f}},
     {cubics[16], 4, 0.812302088, 1, {130,11417}},
     {cubics[17], 4, 0.0682619216, 1, {132,11419}},
 };
 
+static const SortSet set17[] = {
+    {lines[11], 2, 0.888889581, 1, {0, 0}},
+    {cubics[18], 4, 0.999996241, 0, {0, 0}},
+    {lines[11], 2, 0.888889581, 0, {0, 0}},
+    {cubics[18], 4, 0.999996241, 1, {0, 0}},
+};
+
 struct SortSetTests {
     const char* name;
     const SortSet* set;
     size_t count;
     SkPoint startPt;
 };
 
 #define TEST_ENTRY(name) #name, name, SK_ARRAY_COUNT(name)
 
 static const SortSetTests tests[] = {
+    { TEST_ENTRY(set17), {0, 0}},
     { TEST_ENTRY(set16), {130.090179f,11417.5957f} },
 //    { TEST_ENTRY(set15), {0, 0}},
     { TEST_ENTRY(set14), {0, 0}},
     { TEST_ENTRY(set13), {0, 0}},
     { TEST_ENTRY(set12), {0, 0}},
     { TEST_ENTRY(set11), {0, 0}},
     { TEST_ENTRY(set10), {0, 0}},
     { TEST_ENTRY(set9), {0, 0}},
     { TEST_ENTRY(set6a), {3.55555558f,2.77777767f} },
     { TEST_ENTRY(set8a), {1.5f,1} },
@@ skipping 72 matching lines @@
         }
         if (seg->t(tIndex) == set[idx].tEnd) {
             ts[1] = tIndex;
         }
         if (seg->t(tIndex) >= 1) {
             break;
         }
     } while (++tIndex);
 }
 
+static void testOne(skiatest::Reporter* reporter, const SortSetTests& test) {
+    SkTDArray<SkOpAngle> angles;
+    bool unsortable = false;
+    bool unorderable = false;
+    SkTArray<SkOpSegment> segs;
+    for (size_t idx = 0; idx < test.count; ++idx) {
+        int ts[2];
+        const SortSet* set = test.set;
+        SkOpSegment& seg = segs.push_back();
+        setup(set, idx, &seg, ts, test.startPt);
+        SkOpAngle* angle = angles.append();
+        angle->set(&seg, ts[0], ts[1]);
+#if DEBUG_ANGLE
+        angle->setID(idx);
+#endif
+        if (angle->unsortable()) {
+#if DEBUG_ANGLE
+            SkDebugf("%s test[%s]:  angle[%d] unsortable\n", __FUNCTION__, test.name, idx);
+#endif
+            unsortable = true;
+        }
+        if (angle->unorderable()) {
+#if DEBUG_ANGLE
+            SkDebugf("%s test[%s]:  angle[%d] unorderable\n", __FUNCTION__, test.name, idx);
+#endif
+            unorderable = true;
+        }
+        reporter->bumpTestCount();
+    }
+    if (unsortable || unorderable) {
+        return;
+    }
+#if DEBUG_ANGLE
+    SkDebugf("%s test[%s]\n", __FUNCTION__, test.name);
+#endif
+    for (size_t idxL = 0; idxL < test.count; ++idxL) {
+        const SkOpAngle& first = angles[idxL];
+        for (size_t idxG = 0; idxG < test.count; ++idxG) {
+            if (idxL == idxG) {
+                continue;
+            }
+            const SkOpAngle& second = angles[idxG];
+            bool compare = first < second;
+            if (idxL < idxG) {
+                if (!compare) {
+                    SkDebugf("%s test[%s]:  first[%d] > second[%d]\n", __FUNCTION__,
+                            test.name,  idxL,  idxG);
+                    compare = first < second;
+                }
+                REPORTER_ASSERT(reporter, compare);
+            } else {
+                SkASSERT(idxL > idxG);
+                if (compare) {
+                    SkDebugf("%s test[%s]:  first[%d] < second[%d]\n", __FUNCTION__,
+                            test.name,  idxL,  idxG);
+                    compare = first < second;
+                }
+                REPORTER_ASSERT(reporter, !compare);
+            }
+            compare = second < first;
+            if (idxL < idxG) {
+                if (compare) {
+                    SkDebugf("%s test[%s]:  second[%d] < first[%d]\n", __FUNCTION__,
+                            test.name,  idxL,  idxG);
+                    compare = second < first;
+                }
+                REPORTER_ASSERT(reporter, !compare);
+            } else {
+                SkASSERT(idxL > idxG);
+                if (!compare) {
+                    SkDebugf("%s test[%s]:  second[%d] > first[%d]\n", __FUNCTION__,
+                            test.name,  idxL,  idxG);
+                    compare = second < first;
+                }
+                REPORTER_ASSERT(reporter, compare);
+            }
+        }
+    }
+}
+
 static void PathOpsAngleTest(skiatest::Reporter* reporter) {
     for (size_t index = 0; index < SK_ARRAY_COUNT(tests); ++index) {
         const SortSetTests& test = tests[index];
-        SkTDArray<SkOpAngle> angles;
-        bool unsortable = false;
-        bool unorderable = false;
-        SkTArray<SkOpSegment> segs;
-        for (size_t idx = 0; idx < test.count; ++idx) {
-            int ts[2];
-            const SortSet* set = test.set;
-            SkOpSegment& seg = segs.push_back();
-            setup(set, idx, &seg, ts, test.startPt);
-            SkOpAngle* angle = angles.append();
-            angle->set(&seg, ts[0], ts[1]);
-#if DEBUG_ANGLE
-            angle->setID(idx);
-#endif
-           if (angle->unsortable()) {
-#if DEBUG_ANGLE
-                SkDebugf("%s test[%s]:  angle[%d] unsortable\n", __FUNCTION__, test.name, idx);
-#endif
-                unsortable = true;
-            }
-            if (angle->unorderable()) {
-#if DEBUG_ANGLE
-                SkDebugf("%s test[%s]:  angle[%d] unorderable\n", __FUNCTION__, test.name, idx);
-#endif
-                unorderable = true;
-            }
-            reporter->bumpTestCount();
-        }
-        if (unsortable || unorderable) {
-            continue;
-        }
-#if DEBUG_ANGLE
-        SkDebugf("%s test[%s]\n", __FUNCTION__, test.name);
-#endif
-        for (size_t idxL = 0; idxL < test.count; ++idxL) {
-            const SkOpAngle& first = angles[idxL];
-            for (size_t idxG = 0; idxG < test.count; ++idxG) {
-                if (idxL == idxG) {
-                    continue;
-                }
-                const SkOpAngle& second = angles[idxG];
-                bool compare = first < second;
-                if (idxL < idxG) {
-                    if (!compare) {
-                        SkDebugf("%s test[%s]:  first[%d] > second[%d]\n", __FUNCTION__,
-                                test.name,  idxL,  idxG);
-                        compare = first < second;
-                    }
-                    REPORTER_ASSERT(reporter, compare);
-                } else {
-                    SkASSERT(idxL > idxG);
-                    if (compare) {
-                        SkDebugf("%s test[%s]:  first[%d] < second[%d]\n", __FUNCTION__,
-                                test.name,  idxL,  idxG);
-                        compare = first < second;
-                    }
-                    REPORTER_ASSERT(reporter, !compare);
-                }
-                compare = second < first;
-                if (idxL < idxG) {
-                    if (compare) {
-                        SkDebugf("%s test[%s]:  second[%d] < first[%d]\n", __FUNCTION__,
-                                test.name,  idxL,  idxG);
-                        compare = second < first;
-                    }
-                    REPORTER_ASSERT(reporter, !compare);
-                } else {
-                    SkASSERT(idxL > idxG);
-                    if (!compare) {
-                        SkDebugf("%s test[%s]:  second[%d] > first[%d]\n", __FUNCTION__,
-                                test.name,  idxL,  idxG);
-                        compare = second < first;
-                    }
-                    REPORTER_ASSERT(reporter, compare);
-                }
-            }
-        }
+        testOne(reporter, test);
         reporter->bumpTestCount();
     }
 }
 
+static void PathOpsAngleTestOne(skiatest::Reporter* reporter) {
+    size_t index = 0;
+    const SortSetTests& test = tests[index];
+    testOne(reporter, test);
+}
+
 #if 0
 static int find_slop(double x, double y, double rx, double ry) {
     int slopBits = 0;
     bool less1, less2;
     double absX = fabs(x);
     double absY = fabs(y);
     double length = absX < absY ? absX / 2 + absY : absX + absY / 2;
     int exponent;
     (void) frexp(length, &exponent);
     double epsilon = ldexp(FLT_EPSILON, exponent);
@@ skipping 48 matching lines @@
         SkDebugf("%s diamond xy=%1.9g rxy=%1.9g diff=%1.9g factor=%d\n", __FUNCTION__,
                 angle, rAngle, diff, (int) (diff / FLT_EPSILON));
 
     }
 }
 #endif
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS_SHORT(PathOpsAngleTest)
 
+DEFINE_TESTCLASS_SHORT(PathOpsAngleTestOne)
+
 // DEFINE_TESTCLASS_SHORT(PathOpsAngleFindSlop)