fix fuzzers

tests/PathOpsAngleIdeas.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 "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
@@ skipping 59 matching lines @@
     REPORTER_ASSERT(reporter, t >= 0 && t <= 1);
     return i[1][smallest];
 }
 
 static void orderQuads(skiatest::Reporter* reporter, const SkDQuad& quad, double radius,
         SkTArray<double, false>* tArray) {
     double r = radius;
     double s = r * SK_ScalarTanPIOver8;
     double m = r * SK_ScalarRoot2Over2;
     // construct circle from quads
-    const SkDQuad circle[8] = {{{{ r,  0}, { r, -s}, { m, -m}}},
+    const QuadPts circle[8] = {{{{ r,  0}, { r, -s}, { m, -m}}},
                                 {{{ m, -m}, { s, -r}, { 0, -r}}},
                                 {{{ 0, -r}, {-s, -r}, {-m, -m}}},
                                 {{{-m, -m}, {-r, -s}, {-r,  0}}},
                                 {{{-r,  0}, {-r,  s}, {-m,  m}}},
                                 {{{-m,  m}, {-s,  r}, { 0,  r}}},
                                 {{{ 0,  r}, { s,  r}, { m,  m}}},
                                 {{{ m,  m}, { r,  s}, { r,  0}}}};
     for (int octant = 0; octant < 8; ++octant) {
-        double t = testArc(reporter, quad, circle[octant], octant);
+        SkDQuad cQuad;
+        cQuad.debugSet(circle[octant].fPts);
+        double t = testArc(reporter, quad, cQuad, octant);
         if (t < 0) {
             continue;
         }
         for (int index = 0; index < tArray->count(); ++index) {
             double matchT = (*tArray)[index];
             if (approximately_equal(t, matchT)) {
                 goto next;
             }
         }
         tArray->push_back(t);
@@ skipping 225 matching lines @@
                     *upperRange = tRange;
                 }
                 if (lowerRange->tMin > tRange.tMin) {
                     *lowerRange = tRange;
                 }
             }
             r += stepUp ? rStep : -rStep;
             rStep /= 2;
         } while (rStep > FLT_EPSILON);
         if (bestCCW < 0) {
+            if (bestR >= maxRadius) {
+                SkDebugf("");
+            }
             REPORTER_ASSERT(reporter, bestR < maxRadius);
             return false;
         }
         double lastHighR = bestR;
         r = bestR / 2;
         rStep = r / 2;
         do {  // find lower bounds of single result
             TRange tRange;
             bool success = orderTRange(reporter, quad1, quad2, r, &tRange);
             if (success) {
@@ skipping 203 matching lines @@
                 PathOpsAngleTester::EndsIntersect(*seg1->debugLastAngle(),
                 *seg2->debugLastAngle());
         SkASSERT(realEnds == (firstInside ? 1 : 0));
     }
     bruteForce(reporter, quad1, quad2, firstInside);
 }
 
 DEF_TEST(PathOpsAngleOverlapHullsOne, reporter) {
     SkChunkAlloc allocator(4096);
 //    gPathOpsAngleIdeasVerbose = true;
-    const SkDQuad quads[] = {
+    const QuadPts quads[] = {
 {{{939.4808349609375, 914.355224609375}, {-357.7921142578125, 590.842529296875}, {736.8936767578125, -350.717529296875}}},
 {{{939.4808349609375, 914.355224609375}, {-182.85418701171875, 634.4552001953125}, {-509.62615966796875, 576.1182861328125}}}
     };
     for (int index = 0; index < (int) SK_ARRAY_COUNT(quads); index += 2) {
-        testQuadAngles(reporter, quads[index], quads[index + 1], 0, &allocator);
+        SkDQuad quad0, quad1;
+        quad0.debugSet(quads[index].fPts);
+        quad1.debugSet(quads[index + 1].fPts);
+        testQuadAngles(reporter, quad0, quad1, 0, &allocator);
     }
 }
 
 DEF_TEST(PathOpsAngleOverlapHulls, reporter) {
     SkChunkAlloc allocator(4096);
     if (!gPathOpsAngleIdeasVerbose) {  // takes a while to run -- so exclude it by default
         return;
     }
     SkRandom ran;
     for (int index = 0; index < 100000; ++index) {
         if (index % 1000 == 999) SkDebugf(".");
         SkDPoint origin = {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)};
-        SkDQuad quad1 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
+        QuadPts quad1 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
-        if (quad1[0] == quad1[2]) {
+        if (quad1.fPts[0] == quad1.fPts[2]) {
             continue;
         }
-        SkDQuad quad2 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
+        QuadPts quad2 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
-        if (quad2[0] == quad2[2]) {
+        if (quad2.fPts[0] == quad2.fPts[2]) {
             continue;
         }
         SkIntersections i;
-        i.intersect(quad1, quad2);
+        SkDQuad q1, q2;
+        q1.debugSet(quad1.fPts);
+        q2.debugSet(quad2.fPts);
+        i.intersect(q1, q2);
         REPORTER_ASSERT(reporter, i.used() >= 1);
         if (i.used() > 1) {
             continue;
         }
-        testQuadAngles(reporter, quad1, quad2, index, &allocator);
+        testQuadAngles(reporter, q1, q2, index, &allocator);
     }
 }
 
 DEF_TEST(PathOpsAngleBruteT, reporter) {
     if (!gPathOpsAngleIdeasVerbose) {  // takes a while to run -- so exclude it by default
         return;
     }
     SkRandom ran;
     double smaller = SK_Scalar1;
     SkDQuad small[2];
     SkDEBUGCODE(int smallIndex);
     for (int index = 0; index < 100000; ++index) {
         SkDPoint origin = {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)};
-        SkDQuad quad1 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
+        QuadPts quad1 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
-        if (quad1[0] == quad1[2]) {
+        if (quad1.fPts[0] == quad1.fPts[2]) {
             continue;
         }
-        SkDQuad quad2 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
+        QuadPts quad2 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
-        if (quad2[0] == quad2[2]) {
+        if (quad2.fPts[0] == quad2.fPts[2]) {
             continue;
         }
+        SkDQuad q1, q2;
+        q1.debugSet(quad1.fPts);
+        q2.debugSet(quad2.fPts);
         SkIntersections i;
-        i.intersect(quad1, quad2);
+        i.intersect(q1, q2);
         REPORTER_ASSERT(reporter, i.used() >= 1);
         if (i.used() > 1) {
             continue;
         }
         TRange lowerRange, upperRange;
-        bool result = bruteMinT(reporter, quad1, quad2, &lowerRange, &upperRange);
+        bool result = bruteMinT(reporter, q1, q2, &lowerRange, &upperRange);
         REPORTER_ASSERT(reporter, result);
         double min = SkTMin(upperRange.t1, upperRange.t2);
         if (smaller > min) {
-            small[0] = quad1;
-            small[1] = quad2;
+            small[0] = q1;
+            small[1] = q2;
             SkDEBUGCODE(smallIndex = index);
             smaller = min;
         }
     }
 #ifdef SK_DEBUG
     DumpQ(small[0], small[1], smallIndex);
 #endif
 }
 
 DEF_TEST(PathOpsAngleBruteTOne, reporter) {
 //    gPathOpsAngleIdeasVerbose = true;
-    const SkDQuad quads[] = {
+    const QuadPts qPts[] = {
 {{{-770.8492431640625, 948.2369384765625}, {-853.37066650390625, 972.0301513671875}, {-200.62042236328125, -26.7174072265625}}},
 {{{-770.8492431640625, 948.2369384765625}, {513.602783203125, 578.8681640625}, {960.641357421875, -813.69757080078125}}},
 {{{563.8267822265625, -107.4566650390625}, {-44.67724609375, -136.57452392578125}, {492.3856201171875, -268.79644775390625}}},
 {{{563.8267822265625, -107.4566650390625}, {708.049072265625, -100.77789306640625}, {-48.88226318359375, 967.9022216796875}}},
 {{{598.857421875, 846.345458984375}, {-644.095703125, -316.12921142578125}, {-97.64599609375, 20.6158447265625}}},
 {{{598.857421875, 846.345458984375}, {715.7142333984375, 955.3599853515625}, {-919.9478759765625, 691.611328125}}},
     };
     TRange lowerRange, upperRange;
+    SkDQuad quads[SK_ARRAY_COUNT(qPts)];
+    for (int index = 0; index < (int) SK_ARRAY_COUNT(qPts); ++index) {
+        quads[index].debugSet(qPts[index].fPts);
+    }
     bruteMinT(reporter, quads[0], quads[1], &lowerRange, &upperRange);
     bruteMinT(reporter, quads[2], quads[3], &lowerRange, &upperRange);
     bruteMinT(reporter, quads[4], quads[5], &lowerRange, &upperRange);
 }
 
 /*
 The sorting problem happens when the inital tangents are not a true indicator of the curve direction
 Nearly always, the initial tangents do give the right answer,
 so the trick is to figure out when the initial tangent cannot be trusted.
 If the convex hulls of both curves are in the same half plane, and not overlapping, sorting the
 hulls is enough.
 If the hulls overlap, and have the same general direction, then intersect the shorter end point ray
 with the opposing curve, and see on which side of the shorter curve the opposing intersection lies.
 Otherwise, if the control vector is extremely short, likely the point on curve must be computed
 If moving the control point slightly can change the sign of the cross product, either answer could
 be "right".
 We need to determine how short is extremely short. Move the control point a set percentage of
 the largest length to determine how stable the curve is vis-a-vis the initial tangent.
 */
 
-static const SkDQuad extremeTests[][2] = {
+static const QuadPts extremeTests[][2] = {
     {
         {{{-708.0077926931004,-154.61669472244046},
             {-707.9234268635319,-154.30459999551294},
             {505.58447265625,-504.9130859375}}},
         {{{-708.0077926931004,-154.61669472244046},
             {-711.127526325141,-163.9446090624656},
             {-32.39227294921875,-906.3277587890625}}},
     }, {
         {{{-708.0077926931004,-154.61669472244046},
             {-708.2875337527566,-154.36676458635623},
@@ skipping 106 matching lines @@
     SkDVector m2 = mid2 - q2[0];
     REPORTER_ASSERT(reporter, ccw ? m1.crossCheck(m2) < 0 : m1.crossCheck(m2) > 0);
 }
 
 DEF_TEST(PathOpsAngleExtreme, reporter) {
     if (!gPathOpsAngleIdeasVerbose) {  // takes a while to run -- so exclude it by default
         return;
     }
     double maxR = SK_ScalarMax;
     for (int index = 0; index < (int) SK_ARRAY_COUNT(extremeTests); ++index) {
-        const SkDQuad& quad1 = extremeTests[index][0];
-        const SkDQuad& quad2 = extremeTests[index][1];
+        const QuadPts& qu1 = extremeTests[index][0];
+        const QuadPts& qu2 = extremeTests[index][1];
+        SkDQuad quad1, quad2;
+        quad1.debugSet(qu1.fPts);
+        quad2.debugSet(qu2.fPts);
         if (gPathOpsAngleIdeasVerbose) {
             SkDebugf("%s %d\n", __FUNCTION__, index);
         }
         REPORTER_ASSERT(reporter, quad1[0] == quad2[0]);
         SkIntersections i;
         i.intersect(quad1, quad2);
         REPORTER_ASSERT(reporter, i.used() == 1);
         REPORTER_ASSERT(reporter, i.pt(0) == quad1[0]);
         int overlap = quadHullsOverlap(reporter, quad1, quad2);
         REPORTER_ASSERT(reporter, overlap >= 0);
@@ skipping 45 matching lines @@
             step /= 2;
         }
 #ifdef SK_DEBUG
 //        DumpQ(q1, q2, 999);
 #endif
     }
     if (gPathOpsAngleIdeasVerbose) {
         SkDebugf("maxR=%1.9g\n", maxR);
     }
 }