fix fuzzers

tests/PathOpsCubicIntersectionTest.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 "PathOpsCubicIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkGeometry.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
 #include "SkReduceOrder.h"
 #include "Test.h"
 
 #include <stdlib.h>
 
 const int firstCubicIntersectionTest = 9;
 
 static void standardTestCases(skiatest::Reporter* reporter) {
     for (size_t index = firstCubicIntersectionTest; index < tests_count; ++index) {
         int iIndex = static_cast<int>(index);
-        const SkDCubic& cubic1 = tests[index][0];
-        const SkDCubic& cubic2 = tests[index][1];
+        const CubicPts& cubic1 = tests[index][0];
+        const CubicPts& cubic2 = tests[index][1];
+        SkDCubic c1, c2;
+        c1.debugSet(cubic1.fPts);
+        c2.debugSet(cubic2.fPts);
         SkReduceOrder reduce1, reduce2;
-        int order1 = reduce1.reduce(cubic1, SkReduceOrder::kNo_Quadratics);
-        int order2 = reduce2.reduce(cubic2, SkReduceOrder::kNo_Quadratics);
+        int order1 = reduce1.reduce(c1, SkReduceOrder::kNo_Quadratics);
+        int order2 = reduce2.reduce(c2, SkReduceOrder::kNo_Quadratics);
         const bool showSkipped = false;
         if (order1 < 4) {
             if (showSkipped) {
                 SkDebugf("%s [%d] cubic1 order=%d\n", __FUNCTION__, iIndex, order1);
             }
             continue;
         }
         if (order2 < 4) {
             if (showSkipped) {
                 SkDebugf("%s [%d] cubic2 order=%d\n", __FUNCTION__, iIndex, order2);
             }
             continue;
         }
         SkIntersections tIntersections;
-        tIntersections.intersect(cubic1, cubic2);
+        tIntersections.intersect(c1, c2);
         if (!tIntersections.used()) {
             if (showSkipped) {
                 SkDebugf("%s [%d] no intersection\n", __FUNCTION__, iIndex);
             }
             continue;
         }
         if (tIntersections.isCoincident(0)) {
             if (showSkipped) {
                 SkDebugf("%s [%d] coincident\n", __FUNCTION__, iIndex);
             }
             continue;
         }
         for (int pt = 0; pt < tIntersections.used(); ++pt) {
             double tt1 = tIntersections[0][pt];
-            SkDPoint xy1 = cubic1.ptAtT(tt1);
+            SkDPoint xy1 = c1.ptAtT(tt1);
             double tt2 = tIntersections[1][pt];
-            SkDPoint xy2 = cubic2.ptAtT(tt2);
+            SkDPoint xy2 = c2.ptAtT(tt2);
             if (!xy1.approximatelyEqual(xy2)) {
                 SkDebugf("%s [%d,%d] x!= t1=%g (%g,%g) t2=%g (%g,%g)\n",
                     __FUNCTION__, (int)index, pt, tt1, xy1.fX, xy1.fY, tt2, xy2.fX, xy2.fY);
             }
             REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
         }
         reporter->bumpTestCount();
     }
 }
 
-static const SkDCubic testSet[] = {
+static const CubicPts testSet[] = {
 // FIXME: uncommenting these two will cause this to fail
 // this results in two curves very nearly but not exactly coincident
 #if 0
 {{{67.426548091427676, 37.993772624988935}, {23.483695892376684, 90.476863174921306},
       {35.597065061143162, 79.872482633158796}, {75.38634169631932, 18.244890038969412}}},
 {{{67.4265481, 37.9937726}, {23.4836959, 90.4768632}, {35.5970651, 79.8724826},
       {75.3863417, 18.24489}}},
 #endif
 
 {{{0, 0}, {0, 1}, {1, 1}, {1, 0}}},
@@ skipping 77 matching lines @@
         {16.815615499771951, 20.049704667203923}, {41.866884958868326, 56.735503699973002}}},
 
 {{{18.1312339, 31.6473732}, {95.5711034, 63.5350219}, {92.3283165, 62.0158945},
         {18.5656052, 32.1268808}}},
 {{{97.402018, 35.7169972}, {33.1127443, 25.8935163}, {1.13970027, 54.9424981},
         {56.4860195, 60.529264}}},
 };
 
 const int testSetCount = (int) SK_ARRAY_COUNT(testSet);
 
-static const SkDCubic newTestSet[] = {
+static const CubicPts newTestSet[] = {
 { { { 130.0427549999999997, 11417.41309999999976 },{ 130.2331240000000037, 11418.3192999999992 },{ 131.0370790000000056, 11419 },{ 132, 11419 } } },
 { { { 132, 11419 },{ 130.8954319999999996, 11419 },{ 130, 11418.10449999999946 },{ 130, 11417 } } },
     
 {{{1,3}, {-1.0564518,1.79032254}, {1.45265341,0.229448318}, {1.45381773,0.22913377}}},
 {{{1.45381773,0.22913377}, {1.45425761,0.229014933}, {1.0967741,0.451612949}, {0,1}}},
 
 {{{1.64551306f, 3.57876182f}, {0.298127174f, 3.70454836f}, {-0.809808373f, 6.39524937f}, {-3.66666651f, 13.333334f}}},
 {{{1, 2}, {1, 2}, {-3.66666651f, 13.333334f}, {5, 6}}},
 
 {{{0.0660428554,1.65340209}, {-0.251940489,1.43560803}, {-0.782382965,-0.196299091}, {3.33333325,-0.666666627}}},
@@ skipping 196 matching lines @@
 {{{0, 1}, {0, 1}, {2, 1}, {6, 5}}},
 
 {{{0, 6}, {1, 2}, {1, 0}, {1, 0}}},
 {{{0, 1}, {0, 1}, {6, 0}, {2, 1}}},
 
 {{{0, 2}, {0, 1}, {3, 0}, {1, 0}}},
 {{{0, 3}, {0, 1}, {2, 0}, {1, 0}}},
 };
 
 const int newTestSetCount = (int) SK_ARRAY_COUNT(newTestSet);
-static void oneOff(skiatest::Reporter* reporter, const SkDCubic& cubic1, const SkDCubic& cubic2,
+static void oneOff(skiatest::Reporter* reporter, const CubicPts& cubic1, const CubicPts& cubic2,
         bool coin) {
-    SkASSERT(ValidCubic(cubic1));
-    SkASSERT(ValidCubic(cubic2));
+    SkDCubic c1, c2;
+    c1.debugSet(cubic1.fPts);
+    c2.debugSet(cubic2.fPts);
+    SkASSERT(ValidCubic(c1));
+    SkASSERT(ValidCubic(c2));
 #if ONE_OFF_DEBUG
     SkDebugf("computed quadratics given\n");
     SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
         cubic1[0].fX, cubic1[0].fY, cubic1[1].fX, cubic1[1].fY,
         cubic1[2].fX, cubic1[2].fY, cubic1[3].fX, cubic1[3].fY);
     SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
         cubic2[0].fX, cubic2[0].fY, cubic2[1].fX, cubic2[1].fY,
         cubic2[2].fX, cubic2[2].fY, cubic2[3].fX, cubic2[3].fY);
 #endif
     SkIntersections intersections;
-    intersections.intersect(cubic1, cubic2);
+    intersections.intersect(c1, c2);
 #if DEBUG_T_SECT_DUMP == 3
     SkDebugf("</div>\n\n");
     SkDebugf("<script type=\"text/javascript\">\n\n");
     SkDebugf("var testDivs = [\n");
     for (int index = 1; index <= gDumpTSectNum; ++index) {
         SkDebugf("sect%d,\n", index);
     }
 #endif
     if (coin && intersections.used() < 2) {
         SkDebugf("");
     }
     REPORTER_ASSERT(reporter, !coin || intersections.used() >= 2);
     double tt1, tt2;
     SkDPoint xy1, xy2;
     for (int pt3 = 0; pt3 < intersections.used(); ++pt3) {
         tt1 = intersections[0][pt3];
-        xy1 = cubic1.ptAtT(tt1);
+        xy1 = c1.ptAtT(tt1);
         tt2 = intersections[1][pt3];
-        xy2 = cubic2.ptAtT(tt2);
+        xy2 = c2.ptAtT(tt2);
         const SkDPoint& iPt = intersections.pt(pt3);
 #if ONE_OFF_DEBUG
         SkDebugf("%s t1=%1.9g (%1.9g, %1.9g) (%1.9g, %1.9g) (%1.9g, %1.9g) t2=%1.9g\n",
                 __FUNCTION__, tt1, xy1.fX, xy1.fY, iPt.fX,
                 iPt.fY, xy2.fX, xy2.fY, tt2);
 #endif
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy2.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
     }
     reporter->bumpTestCount();
 }
 
 static void oneOff(skiatest::Reporter* reporter, int outer, int inner) {
-    const SkDCubic& cubic1 = testSet[outer];
-    const SkDCubic& cubic2 = testSet[inner];
+    const CubicPts& cubic1 = testSet[outer];
+    const CubicPts& cubic2 = testSet[inner];
     oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void newOneOff(skiatest::Reporter* reporter, int outer, int inner) {
-    const SkDCubic& cubic1 = newTestSet[outer];
-    const SkDCubic& cubic2 = newTestSet[inner];
+    const CubicPts& cubic1 = newTestSet[outer];
+    const CubicPts& cubic2 = newTestSet[inner];
     oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void testsOneOff(skiatest::Reporter* reporter, int index) {
-    const SkDCubic& cubic1 = tests[index][0];
-    const SkDCubic& cubic2 = tests[index][1];
+    const CubicPts& cubic1 = tests[index][0];
+    const CubicPts& cubic2 = tests[index][1];
     oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void oneOffTests(skiatest::Reporter* reporter) {
     for (int outer = 0; outer < testSetCount - 1; ++outer) {
         for (int inner = outer + 1; inner < testSetCount; ++inner) {
             oneOff(reporter, outer, inner);
         }
     }
     for (int outer = 0; outer < newTestSetCount - 1; ++outer) {
         for (int inner = outer + 1; inner < newTestSetCount; ++inner) {
             newOneOff(reporter, outer, inner);
         }
     }
 }
 
 #define DEBUG_CRASH 0
 
 static void CubicIntersection_RandTest(skiatest::Reporter* reporter) {
     srand(0);
     const int tests = 10000000;
 #if !defined(SK_BUILD_FOR_WIN) && !defined(SK_BUILD_FOR_ANDROID)
     unsigned seed = 0;
 #endif
     for (int test = 0; test < tests; ++test) {
-        SkDCubic cubic1, cubic2;
+        CubicPts cubic1, cubic2;
         for (int i = 0; i < 4; ++i) {
-            cubic1[i].fX = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
-            cubic1[i].fY = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
-            cubic2[i].fX = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
-            cubic2[i].fY = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
+            cubic1.fPts[i].fX = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
+            cubic1.fPts[i].fY = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
+            cubic2.fPts[i].fX = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
+            cubic2.fPts[i].fY = static_cast<double>(SK_RAND(seed)) / RAND_MAX * 100;
         }
     #if DEBUG_CRASH
         char str[1024];
         snprintf(str, sizeof(str),
             "{{{%1.9g, %1.9g}, {%1.9g, %1.9g}, {%1.9g, %1.9g}, {%1.9g, %1.9g}}},\n"
             "{{{%1.9g, %1.9g}, {%1.9g, %1.9g}, {%1.9g, %1.9g}, {%1.9g, %1.9g}}},\n",
                 cubic1[0].fX, cubic1[0].fY,  cubic1[1].fX, cubic1[1].fY, cubic1[2].fX, cubic1[2].fY,
                 cubic1[3].fX, cubic1[3].fY,
                 cubic2[0].fX, cubic2[0].fY,  cubic2[1].fX, cubic2[1].fY, cubic2[2].fX, cubic2[2].fY,
                 cubic2[3].fX, cubic2[3].fY);
     #endif
         SkDRect rect1, rect2;
-        rect1.setBounds(cubic1);
-        rect2.setBounds(cubic2);
+        SkDCubic c1, c2;
+        c1.debugSet(cubic1.fPts);
+        c2.debugSet(cubic2.fPts);
+        rect1.setBounds(c1);
+        rect2.setBounds(c2);
         bool boundsIntersect = rect1.fLeft <= rect2.fRight && rect2.fLeft <= rect2.fRight
                 && rect1.fTop <= rect2.fBottom && rect2.fTop <= rect1.fBottom;
         if (test == -1) {
             SkDebugf("ready...\n");
         }
         SkIntersections intersections2;
-        int newIntersects = intersections2.intersect(cubic1, cubic2);
+        int newIntersects = intersections2.intersect(c1, c2);
         if (!boundsIntersect && newIntersects) {
     #if DEBUG_CRASH
             SkDebugf("%s %d unexpected intersection boundsIntersect=%d "
                     " newIntersects=%d\n%s %s\n", __FUNCTION__, test, boundsIntersect,
                     newIntersects, __FUNCTION__, str);
     #endif
             REPORTER_ASSERT(reporter, 0);
         }
         for (int pt = 0; pt < intersections2.used(); ++pt) {
             double tt1 = intersections2[0][pt];
-            SkDPoint xy1 = cubic1.ptAtT(tt1);
+            SkDPoint xy1 = c1.ptAtT(tt1);
             double tt2 = intersections2[1][pt];
-            SkDPoint xy2 = cubic2.ptAtT(tt2);
+            SkDPoint xy2 = c2.ptAtT(tt2);
             REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
         }
         reporter->bumpTestCount();
     }
 }
 
 static void intersectionFinder(int index0, int index1, double t1Seed, double t2Seed,
         double t1Step, double t2Step) {
-    const SkDCubic& cubic1 = newTestSet[index0];
-    const SkDCubic& cubic2 = newTestSet[index1];
+    const CubicPts& cubic1 = newTestSet[index0];
+    const CubicPts& cubic2 = newTestSet[index1];
     SkDPoint t1[3], t2[3];
     bool toggle = true;
+    SkDCubic c1, c2;
+    c1.debugSet(cubic1.fPts);
+    c2.debugSet(cubic2.fPts);
     do {
-        t1[0] = cubic1.ptAtT(t1Seed - t1Step);
-        t1[1] = cubic1.ptAtT(t1Seed);
-        t1[2] = cubic1.ptAtT(t1Seed + t1Step);
-        t2[0] = cubic2.ptAtT(t2Seed - t2Step);
-        t2[1] = cubic2.ptAtT(t2Seed);
-        t2[2] = cubic2.ptAtT(t2Seed + t2Step);
+        t1[0] = c1.ptAtT(t1Seed - t1Step);
+        t1[1] = c1.ptAtT(t1Seed);
+        t1[2] = c1.ptAtT(t1Seed + t1Step);
+        t2[0] = c2.ptAtT(t2Seed - t2Step);
+        t2[1] = c2.ptAtT(t2Seed);
+        t2[2] = c2.ptAtT(t2Seed + t2Step);
         double dist[3][3];
         dist[1][1] = t1[1].distance(t2[1]);
         int best_i = 1, best_j = 1;
         for (int i = 0; i < 3; ++i) {
             for (int j = 0; j < 3; ++j) {
                 if (i == 1 && j == 1) {
                     continue;
                 }
                 dist[i][j] = t1[i].distance(t2[j]);
                 if (dist[best_i][best_j] > dist[i][j]) {
@@ skipping 20 matching lines @@
             }
         }
     } while (!t1[1].approximatelyEqual(t2[1]));
     t1Step = t2Step = 0.1;
     double t10 = t1Seed - t1Step * 2;
     double t12 = t1Seed + t1Step * 2;
     double t20 = t2Seed - t2Step * 2;
     double t22 = t2Seed + t2Step * 2;
     SkDPoint test;
     while (!approximately_zero(t1Step)) {
-        test = cubic1.ptAtT(t10);
+        test = c1.ptAtT(t10);
         t10 += t1[1].approximatelyEqual(test) ? -t1Step : t1Step;
         t1Step /= 2;
     }
     t1Step = 0.1;
     while (!approximately_zero(t1Step)) {
-        test = cubic1.ptAtT(t12);
+        test = c1.ptAtT(t12);
         t12 -= t1[1].approximatelyEqual(test) ? -t1Step : t1Step;
         t1Step /= 2;
     }
     while (!approximately_zero(t2Step)) {
-        test = cubic2.ptAtT(t20);
+        test = c2.ptAtT(t20);
         t20 += t2[1].approximatelyEqual(test) ? -t2Step : t2Step;
         t2Step /= 2;
     }
     t2Step = 0.1;
     while (!approximately_zero(t2Step)) {
-        test = cubic2.ptAtT(t22);
+        test = c2.ptAtT(t22);
         t22 -= t2[1].approximatelyEqual(test) ? -t2Step : t2Step;
         t2Step /= 2;
     }
 #if ONE_OFF_DEBUG
     SkDebugf("%s t1=(%1.9g<%1.9g<%1.9g) t2=(%1.9g<%1.9g<%1.9g)\n", __FUNCTION__,
         t10, t1Seed, t12, t20, t2Seed, t22);
-    SkDPoint p10 = cubic1.ptAtT(t10);
-    SkDPoint p1Seed = cubic1.ptAtT(t1Seed);
-    SkDPoint p12 = cubic1.ptAtT(t12);
+    SkDPoint p10 = c1.ptAtT(t10);
+    SkDPoint p1Seed = c1.ptAtT(t1Seed);
+    SkDPoint p12 = c1.ptAtT(t12);
     SkDebugf("%s p1=(%1.9g,%1.9g)<(%1.9g,%1.9g)<(%1.9g,%1.9g)\n", __FUNCTION__,
         p10.fX, p10.fY, p1Seed.fX, p1Seed.fY, p12.fX, p12.fY);
-    SkDPoint p20 = cubic2.ptAtT(t20);
-    SkDPoint p2Seed = cubic2.ptAtT(t2Seed);
-    SkDPoint p22 = cubic2.ptAtT(t22);
+    SkDPoint p20 = c2.ptAtT(t20);
+    SkDPoint p2Seed = c2.ptAtT(t2Seed);
+    SkDPoint p22 = c2.ptAtT(t22);
     SkDebugf("%s p2=(%1.9g,%1.9g)<(%1.9g,%1.9g)<(%1.9g,%1.9g)\n", __FUNCTION__,
         p20.fX, p20.fY, p2Seed.fX, p2Seed.fY, p22.fX, p22.fY);
 #endif
 }
 
 static void CubicIntersection_IntersectionFinder() {
 //   double t1Seed = 0.87;
 //   double t2Seed = 0.87;
     double t1Step = 0.000001;
     double t2Step = 0.000001;
     intersectionFinder(0, 1, 0.855895664, 0.864850875, t1Step, t2Step);
     intersectionFinder(0, 1, 0.865207906, 0.865207887, t1Step, t2Step);
     intersectionFinder(0, 1, 0.865213351, 0.865208087, t1Step, t2Step);
 }
 
-static const SkDCubic selfSet[] = {
+static const CubicPts selfSet[] = {
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
     {{{3, 6}, {2, 3}, {4, 0}, {3, 2}}},
     {{{0, 2}, {2, 3}, {5, 1}, {3, 2}}},
     {{{0, 2}, {3, 5}, {5, 0}, {4, 2}}},
     {{{3.34, 8.98}, {1.95, 10.27}, {3.76, 7.65}, {4.96, 10.64}}},
     {{{3.13, 2.74}, {1.08, 4.62}, {3.71, 0.94}, {2.01, 3.81}}},
     {{{6.71, 3.14}, {7.99, 2.75}, {8.27, 1.96}, {6.35, 3.57}}},
     {{{12.81, 7.27}, {7.22, 6.98}, {12.49, 8.97}, {11.42, 6.18}}},
 };
 
 int selfSetCount = (int) SK_ARRAY_COUNT(selfSet);
 
 static void selfOneOff(skiatest::Reporter* reporter, int index) {
-    const SkDCubic& cubic = selfSet[index];
+    const CubicPts& cubic = selfSet[index];
     SkPoint c[4];
     for (int i = 0; i < 4; ++i) {
-        c[i] = cubic[i].asSkPoint();
+        c[i] = cubic.fPts[i].asSkPoint();
     }
     SkScalar loopT;
     SkScalar d[3];
     SkCubicType cubicType = SkClassifyCubic(c, d);
     if (SkDCubic::ComplexBreak(c, &loopT) && cubicType == SkCubicType::kLoop_SkCubicType) {
         SkIntersections i;
         SkPoint twoCubics[7];
         SkChopCubicAt(c, twoCubics, loopT);
         SkDCubic chopped[2];
         chopped[0].set(&twoCubics[0]);
@@ skipping 10 matching lines @@
     }
 }
 
 static void cubicIntersectionSelfTest(skiatest::Reporter* reporter) {
     int firstFail = 0;
     for (int index = firstFail; index < selfSetCount; ++index) {
         selfOneOff(reporter, index);
     }
 }
 
-static const SkDCubic coinSet[] = {
+static const CubicPts coinSet[] = {
     {{{72.350448608398438, 27.966041564941406}, {72.58441162109375, 27.861515045166016},
         {72.818222045898437, 27.756658554077148}, {73.394996643066406, 27.49799919128418}}},
     {{{73.394996643066406, 27.49799919128418}, {72.818222045898437, 27.756658554077148},
         {72.58441162109375, 27.861515045166016}, {72.350448608398438, 27.966041564941406}}},
 
     {{{297.04998779296875, 43.928997039794922}, {297.04998779296875, 43.928997039794922},
         {300.69699096679688, 45.391998291015625}, {306.92498779296875, 43.08599853515625}}},
     {{{297.04998779296875, 43.928997039794922}, {297.04998779296875, 43.928997039794922},
         {300.69699096679688, 45.391998291015625}, {306.92498779296875, 43.08599853515625}}},
 
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
 
     {{{317, 711}, {322.52285766601562, 711}, {327, 715.4771728515625}, {327, 721}}},
     {{{324.07107543945312, 713.928955078125}, {324.4051513671875, 714.26300048828125},
             {324.71566772460937, 714.62060546875}, {325, 714.9990234375}}},
 };
 
 static int coinSetCount = (int) SK_ARRAY_COUNT(coinSet);
 
 static void coinOneOff(skiatest::Reporter* reporter, int index) {
-    const SkDCubic& cubic1 = coinSet[index];
-    const SkDCubic& cubic2 = coinSet[index + 1];
+    const CubicPts& cubic1 = coinSet[index];
+    const CubicPts& cubic2 = coinSet[index + 1];
     oneOff(reporter, cubic1, cubic2, true);
 }
 
 static void cubicIntersectionCoinTest(skiatest::Reporter* reporter) {
     int firstFail = 0;
     for (int index = firstFail; index < coinSetCount; index += 2) {
         coinOneOff(reporter, index);
     }
 }
 
@@ skipping 14 matching lines @@
 }
 
 DEF_TEST(PathOpsCubicIntersection, reporter) {
     oneOffTests(reporter);
     cubicIntersectionSelfTest(reporter);
     cubicIntersectionCoinTest(reporter);
     standardTestCases(reporter);
     if (false) CubicIntersection_IntersectionFinder();
     if (false) CubicIntersection_RandTest(reporter);
 }