fix fuzzers

tests/PathOpsQuadIntersectionTest.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 "PathOpsQuadIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
 #include "SkReduceOrder.h"
 #include "Test.h"
 
 static void standardTestCases(skiatest::Reporter* reporter) {
     bool showSkipped = false;
     for (size_t index = 0; index < quadraticTests_count; ++index) {
-        const SkDQuad& quad1 = quadraticTests[index][0];
+        const QuadPts& q1 = quadraticTests[index][0];
+        SkDQuad quad1;
+        quad1.debugSet(q1.fPts);
         SkASSERT(ValidQuad(quad1));
-        const SkDQuad& quad2 = quadraticTests[index][1];
+        const QuadPts& q2 = quadraticTests[index][1];
+        SkDQuad quad2;
+        quad2.debugSet(q2.fPts);
         SkASSERT(ValidQuad(quad2));
         SkReduceOrder reduce1, reduce2;
         int order1 = reduce1.reduce(quad1);
         int order2 = reduce2.reduce(quad2);
         if (order1 < 3) {
             if (showSkipped) {
                 SkDebugf("[%d] quad1 order=%d\n", static_cast<int>(index), order1);
             }
         }
         if (order2 < 3) {
@@ skipping 15 matching lines @@
                                 __FUNCTION__, static_cast<int>(index), pt, tt1, xy1.fX, xy1.fY,
                                 tt2, xy2.fX, xy2.fY);
                         REPORTER_ASSERT(reporter, 0);
                     }
                 }
             }
         }
     }
 }
 
-static const SkDQuad testSet[] = {
+static const QuadPts testSet[] = {
 {{{-0.001019871095195412636, -0.008523519150912761688}, {-0.005396408028900623322, -0.005396373569965362549}, {-0.02855382487177848816, -0.02855364233255386353}}},
 {{{-0.004567248281091451645, -0.01482933573424816132}, {-0.01142475008964538574, -0.01140109263360500336}, {-0.02852955088019371033, -0.02847047336399555206}}},
 
 {{{1, 1}, {0, 2}, {3, 3}}},
 {{{3, 0}, {0, 1}, {1, 2}}},
 
 {{{0.33333333333333326, 0.81481481481481488}, {0.63395173631977997, 0.68744136726313931}, {1.205684411948591, 0.81344322326274499}}},
 {{{0.33333333333333326, 0.81481481481481488}, {0.63396444791444551, 0.68743368362444768}, {1.205732763658403, 0.81345617746834109}}},
 
 {{{4981.9990234375, 1590}, {4981.9990234375, 1617.7523193359375}, {4962.375, 1637.3760986328125}}},
@@ skipping 253 matching lines @@
     {{{360.048828125, 229.2578125}, {360.048828125, 224.4140625}, {362.607421875, 221.3671875}}},
     {{{362.607421875, 221.3671875}, {365.166015625, 218.3203125}, {369.228515625, 218.3203125}}},
     {{{8, 8}, {10, 10}, {8, -10}}},
     {{{8, 8}, {12, 12}, {14, 4}}},
     {{{8, 8}, {9, 9}, {10, 8}}}
 };
 
 const size_t testSetCount = SK_ARRAY_COUNT(testSet);
 
 static void oneOffTest1(skiatest::Reporter* reporter, size_t outer, size_t inner) {
-    const SkDQuad& quad1 = testSet[outer];
+    const QuadPts& q1 = testSet[outer];
+    SkDQuad quad1;
+    quad1.debugSet(q1.fPts);
     SkASSERT(ValidQuad(quad1));
-    const SkDQuad& quad2 = testSet[inner];
+    const QuadPts& q2 = testSet[inner];
+    SkDQuad quad2;
+    quad2.debugSet(q2.fPts);
     SkASSERT(ValidQuad(quad2));
     SkIntersections intersections;
     intersections.intersect(quad1, quad2);
     for (int pt = 0; pt < intersections.used(); ++pt) {
         double tt1 = intersections[0][pt];
         SkDPoint xy1 = quad1.ptAtT(tt1);
         double tt2 = intersections[1][pt];
         SkDPoint xy2 = quad2.ptAtT(tt2);
         if (!xy1.approximatelyEqual(xy2)) {
             SkDebugf("%s [%d,%d] x!= t1=%g (%g,%g) t2=%g (%g,%g)\n",
                     __FUNCTION__, static_cast<int>(outer), static_cast<int>(inner),
                     tt1, xy1.fX, xy1.fY, tt2, xy2.fX, xy2.fY);
             REPORTER_ASSERT(reporter, 0);
         }
 #if ONE_OFF_DEBUG
         SkDebugf("%s [%d][%d] t1=%1.9g (%1.9g, %1.9g) t2=%1.9g\n", __FUNCTION__,
             outer, inner, tt1, xy1.fX, xy1.fY, tt2);
 #endif
     }
 }
 
 static void oneOffTests(skiatest::Reporter* reporter) {
     for (size_t outer = 0; outer < testSetCount - 1; ++outer) {
         for (size_t inner = outer + 1; inner < testSetCount; ++inner) {
             oneOffTest1(reporter, outer, inner);
         }
     }
 }
 
-static const SkDQuad coincidentTestSet[] = {
+static const QuadPts coincidentTestSet[] = {
     {{{4914.9990234375, 1523}, {4942.75146484375, 1523}, {4962.375, 1542.6239013671875}}},
     {{{4962.3759765625, 1542.6239013671875}, {4942.75244140625, 1523}, {4915, 1523}}},
 #if 0
     {{{97.9337615966796875,100}, {88,112.94264984130859375}, {88,130}}},
     {{{88,130}, {88,124.80951690673828125}, {88.91983795166015625,120}}},
 #endif
     {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
     {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
     {{{8, 8}, {10, 10}, {8, -10}}},
     {{{8, -10}, {10, 10}, {8, 8}}},
 };
 
 static const int coincidentTestSetCount = (int) SK_ARRAY_COUNT(coincidentTestSet);
 
 static void coincidentTestOne(skiatest::Reporter* reporter, int test1, int test2) {
-    const SkDQuad& quad1 = coincidentTestSet[test1];
+    const QuadPts& q1 = coincidentTestSet[test1];
+    SkDQuad quad1;
+    quad1.debugSet(q1.fPts);
     SkASSERT(ValidQuad(quad1));
-    const SkDQuad& quad2 = coincidentTestSet[test2];
+    const QuadPts& q2 = coincidentTestSet[test2];
+    SkDQuad quad2;
+    quad2.debugSet(q2.fPts);
     SkASSERT(ValidQuad(quad2));
     SkIntersections intersections2;
     intersections2.intersect(quad1, quad2);
     REPORTER_ASSERT(reporter, intersections2.debugCoincidentUsed() >= 2);
     REPORTER_ASSERT(reporter, intersections2.used() >= 2);
     for (int pt = 0; pt < intersections2.debugCoincidentUsed(); pt += 2) {
         double tt1 = intersections2[0][pt];
         double tt2 = intersections2[1][pt];
         SkDPoint pt1 = quad1.ptAtT(tt1);
         SkDPoint pt2 = quad2.ptAtT(tt2);
         REPORTER_ASSERT(reporter, pt1.approximatelyEqual(pt2));
     }
 }
 
 static void coincidentTest(skiatest::Reporter* reporter) {
     for (int testIndex = 0; testIndex < coincidentTestSetCount - 1; testIndex += 2) {
         coincidentTestOne(reporter, testIndex, testIndex + 1);
     }
 }
 
 static void intersectionFinder(int test1, int test2) {
-    const SkDQuad& quad1 = testSet[test1];
-    const SkDQuad& quad2 = testSet[test2];
-
+    const QuadPts& q1 = testSet[test1];
+    const QuadPts& q2 = testSet[test2];
+    SkDQuad quad1, quad2;
+    quad1.debugSet(q1.fPts);
+    quad2.debugSet(q2.fPts);
     double t1Seed = 0.5;
     double t2Seed = 0.8;
     double t1Step = 0.1;
     double t2Step = 0.1;
     SkDPoint t1[3], t2[3];
     bool toggle = true;
     do {
         t1[0] = quad1.ptAtT(t1Seed - t1Step);
         t1[1] = quad1.ptAtT(t1Seed);
         t1[2] = quad1.ptAtT(t1Seed + t1Step);
@@ skipping 100 matching lines @@
 
 DEF_TEST(PathOpsQuadBinaryProfile, reporter) {
     if (!FLAGS_veryVerbose) {
             return;
     }
     SkIntersections intersections;
     for (int x = 0; x < 100; ++x) {
         int outer = 0;
         int inner = outer + 1;
         do {
-            const SkDQuad& quad1 = testSet[outer];
-            const SkDQuad& quad2 = testSet[inner];
+            const QuadPts& q1 = testSet[outer];
+            SkDQuad quad1;
+            quad1.debugSet(q1.fPts);
+            const QuadPts& q2 = testSet[inner];
+            SkDQuad quad2;
+            quad2.debugSet(q2.fPts);
             (void) intersections.intersect(quad1, quad2);
             REPORTER_ASSERT(reporter, intersections.used() >= 0);  // make sure code isn't tossed
             inner += 2;
             outer += 2;
         } while (outer < (int) testSetCount);
     }
     for (int x = 0; x < 100; ++x) {
         for (size_t test = 0; test < quadraticTests_count; ++test) {
-            const SkDQuad& quad1 = quadraticTests[test][0];
-            const SkDQuad& quad2 = quadraticTests[test][1];
+            const QuadPts& q1 = quadraticTests[test][0];
+            const QuadPts& q2 = quadraticTests[test][1];
+            SkDQuad quad1, quad2;
+            quad1.debugSet(q1.fPts);
+            quad2.debugSet(q2.fPts);
             (void) intersections.intersect(quad1, quad2);
             REPORTER_ASSERT(reporter, intersections.used() >= 0);  // make sure code isn't tossed
         }
     }
 }