fix fuzzers

tests/PathOpsCubicIntersectionTestData.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 <limits>
 
 static const double D = FLT_EPSILON / 2;
 static const double G = FLT_EPSILON / 3;
 static const double N = -FLT_EPSILON / 2;
 static const double M = -FLT_EPSILON / 3;
 
-const SkDCubic pointDegenerates[] = {
+const CubicPts pointDegenerates[] = {
     {{{0, 0}, {0, 0}, {0, 0}, {0, 0}}},
     {{{1, 1}, {1, 1}, {1, 1}, {1, 1}}},
     {{{1 + FLT_EPSILON_HALF, 1}, {1, 1 + FLT_EPSILON_HALF}, {1, 1}, {1, 1}}},
     {{{1 + D, 1}, {1 - D, 1}, {1, 1}, {1, 1}}},
     {{{0, 0}, {0, 0}, {1, 0}, {0, 0}}},
     {{{0, 0}, {1, 0}, {0, 0}, {0, 0}}},
     {{{0, 0}, {0, 0}, {0, 1}, {0, 0}}},
     {{{0, 0}, {0, 1}, {0, 0}, {0, 0}}},
     {{{0, 0}, {0, 0}, {1, 1}, {0, 0}}},
     {{{0, 0}, {1, 1}, {0, 0}, {0, 0}}},
@@ skipping 10 matching lines @@
     {{{0, 0}, {0, 1}, {N, 0}, {0, 0}}},
     {{{0, 0}, {1, 1}, {N, 0}, {0, 0}}},
     {{{0, 0}, {D, 0}, {1, 1}, {0, 0}}},
     {{{0, 0}, {1, 1}, {D, 0}, {0, 0}}},
     {{{0, 0}, {N, 0}, {1, 1}, {0, 0}}},
     {{{1, 1}, {2, 2}, {2, 2+N}, {1, 1}}},
 };
 
 const size_t pointDegenerates_count = SK_ARRAY_COUNT(pointDegenerates);
 
-const SkDCubic notPointDegenerates[] = {
+const CubicPts notPointDegenerates[] = {
     {{{1 + FLT_EPSILON * 8, 1}, {1, FLT_EPSILON * 8}, {1, 1}, {1, 1}}},
     {{{1 + FLT_EPSILON * 8, 1}, {1 - FLT_EPSILON * 8, 1}, {1, 1}, {1, 1}}}
 };
 
 const size_t notPointDegenerates_count =
         SK_ARRAY_COUNT(notPointDegenerates);
 
 // from http://www.truetex.com/bezint.htm
-const SkDCubic tests[][2] = {
+const CubicPts tests[][2] = {
     {  // intersects in one place (data gives bezier clip fits
      {{{0, 45},
       {6.0094158284751593, 51.610357411322688},
       {12.741093228940867, 55.981703949474607},
       {20.021417396476362, 58.652245509710262}}},
      {{{2.2070737699246674, 52.703494107327209},
       {31.591482272629477, 23.811002295222025},
       {76.824588616426425, 44.049473790502674},
       {119.25488947221436, 55.599248272955073}}}
     }, {  // intersects in three places
@@ skipping 34 matching lines @@
     }, {
         {{{104.11546583642826, 370.21352558595504}, {122.96968232592344, 404.54489231839295},
           {169.90881005384728, 425.00067000000007}, {221.33045999999999, 425.00067000000001}}},
         {{{116.32365976159625, 381.71048540582598}, {103.86096590870899, 381.71048540581626},
           {91.394188003200725, 377.17917781762833}, {82.622283093355179, 368.11683661930334}}}
     }
 };
 
 const size_t tests_count = SK_ARRAY_COUNT(tests);
 
-const SkDCubic lines[] = {
+const CubicPts lines[] = {
     {{{0, 0}, {0, 0}, {0, 0}, {1, 0}}},  // 0: horizontal
     {{{1, 0}, {0, 0}, {0, 0}, {0, 0}}},
     {{{1, 0}, {2, 0}, {3, 0}, {4, 0}}},
     {{{0, 0}, {0, 0}, {0, 0}, {0, 1}}},  // 5: vertical
     {{{0, 1}, {0, 0}, {0, 0}, {0, 0}}},
     {{{0, 1}, {0, 2}, {0, 3}, {0, 4}}},
     {{{0, 0}, {0, 0}, {0, 0}, {1, 1}}},  // 10: 3 coincident
     {{{1, 1}, {0, 0}, {0, 0}, {0, 0}}},
     {{{0, 0}, {0, 0}, {1, 1}, {2, 2}}},  // 14: 2 coincident
     {{{0, 0}, {1, 1}, {0, 0}, {2, 2}}},
@@ skipping 15 matching lines @@
     {{{2, 2}, {1, 1}, {4, 4}, {3, 3}}},
     {{{2, 2}, {3, 3}, {1, 1}, {4, 4}}},
     {{{2, 2}, {3, 3}, {4, 4}, {1, 1}}},
     {{{2, 2}, {4, 4}, {1, 1}, {3, 3}}},
     {{{2, 2}, {4, 4}, {3, 3}, {1, 1}}},
 };
 
 const size_t lines_count = SK_ARRAY_COUNT(lines);
 
 // 'not a line' tries to fool the line detection code
-const SkDCubic notLines[] = {
+const CubicPts notLines[] = {
     {{{0, 0}, {0, 0}, {0, 1}, {1, 0}}},
     {{{0, 0}, {0, 1}, {0, 0}, {1, 0}}},
     {{{0, 0}, {0, 1}, {1, 0}, {0, 0}}},
     {{{0, 1}, {0, 0}, {0, 0}, {1, 0}}},
     {{{0, 1}, {0, 0}, {1, 0}, {0, 0}}},
     {{{0, 1}, {1, 0}, {0, 0}, {0, 0}}},
 };
 
 const size_t notLines_count = SK_ARRAY_COUNT(notLines);
 
 static const double E = FLT_EPSILON * 8;
 static const double F = FLT_EPSILON * 8;
 
-const SkDCubic modEpsilonLines[] = {
+const CubicPts modEpsilonLines[] = {
     {{{0, E}, {0, 0}, {0, 0}, {1, 0}}},  // horizontal
     {{{0, 0}, {0, E}, {1, 0}, {0, 0}}},
     {{{0, 0}, {1, 0}, {0, E}, {0, 0}}},
     {{{1, 0}, {0, 0}, {0, 0}, {0, E}}},
     {{{1, E}, {2, 0}, {3, 0}, {4, 0}}},
     {{{E, 0}, {0, 0}, {0, 0}, {0, 1}}},  // vertical
     {{{0, 0}, {E, 0}, {0, 1}, {0, 0}}},
     {{{0, 0}, {0, 1}, {E, 0}, {0, 0}}},
     {{{0, 1}, {0, 0}, {0, 0}, {E, 0}}},
     {{{E, 1}, {0, 2}, {0, 3}, {0, 4}}},
@@ skipping 22 matching lines @@
     {{{2, 2}, {1, 1}, {3+E, 3}, {4, 4}}},
     {{{2, 2}, {1+E, 1}, {4, 4}, {3, 3}}},
     {{{2, 2+E}, {3, 3}, {1, 1}, {4, 4}}},
     {{{2+E, 2}, {3, 3}, {4, 4}, {1, 1}}},
     {{{2, 2}, {4+E, 4}, {1, 1}, {3, 3}}},
     {{{2, 2}, {4, 4}, {3, 3}, {1, 1+E}}},
 };
 
 const size_t modEpsilonLines_count = SK_ARRAY_COUNT(modEpsilonLines);
 
-const SkDCubic lessEpsilonLines[] = {
+const CubicPts lessEpsilonLines[] = {
     {{{0, D}, {0, 0}, {0, 0}, {1, 0}}},  // horizontal
     {{{1, 0}, {0, 0}, {0, 0}, {0, D}}},
     {{{1, D}, {2, 0}, {3, 0}, {4, 0}}},
     {{{D, 0}, {0, 0}, {0, 0}, {0, 1}}},  // vertical
     {{{0, 1}, {0, 0}, {0, 0}, {D, 0}}},
     {{{D, 1}, {0, 2}, {0, 3}, {0, 4}}},
     {{{D, 0}, {0, 0}, {0, 0}, {1, 1}}},  // 3 coincident
     {{{1, 1}, {0, 0}, {0, 0}, {D, 0}}},
     {{{0, D}, {0, 0}, {1, 1}, {2, 2}}},  // 2 coincident
     {{{0, 0}, {1, 1}, {0, D}, {2, 2}}},
@@ skipping 15 matching lines @@
     {{{2, 2}, {1, 1}, {3+D, 3}, {4, 4}}},
     {{{2, 2}, {1+D, 1}, {4, 4}, {3, 3}}},
     {{{2, 2+D}, {3, 3}, {1, 1}, {4, 4}}},
     {{{2+G, 2}, {3, 3}, {4, 4}, {1, 1}}},  // INVESTIGATE: why the epsilon is smaller
     {{{2, 2}, {4+D, 4}, {1, 1}, {3, 3}}},
     {{{2, 2}, {4, 4}, {3, 3}, {1, 1+D}}},
 };
 
 const size_t lessEpsilonLines_count = SK_ARRAY_COUNT(lessEpsilonLines);
 
-const SkDCubic negEpsilonLines[] = {
+const CubicPts negEpsilonLines[] = {
     {{{0, N}, {0, 0}, {0, 0}, {1, 0}}},  // horizontal
     {{{1, 0}, {0, 0}, {0, 0}, {0, N}}},
     {{{1, N}, {2, 0}, {3, 0}, {4, 0}}},
     {{{N, 0}, {0, 0}, {0, 0}, {0, 1}}},  // vertical
     {{{0, 1}, {0, 0}, {0, 0}, {N, 0}}},
     {{{N, 1}, {0, 2}, {0, 3}, {0, 4}}},
     {{{N, 0}, {0, 0}, {0, 0}, {1, 1}}},  // 3 coincident
     {{{1, 1}, {0, 0}, {0, 0}, {N, 0}}},
     {{{0, N}, {0, 0}, {1, 1}, {2, 2}}},  // 2 coincident
     {{{0, 0}, {1, 1}, {0, N}, {2, 2}}},
@@ skipping 14 matching lines @@
     {{{1, 1}, {4, 4}, {3, 3}, {2+M, 2}}},  // INVESTIGATE: why the epsilon is smaller
     {{{2, 2}, {1, 1}, {3+N, 3}, {4, 4}}},
     {{{2, 2}, {1+N, 1}, {4, 4}, {3, 3}}},
     {{{2, 2+N}, {3, 3}, {1, 1}, {4, 4}}},
     {{{2+M, 2}, {3, 3}, {4, 4}, {1, 1}}},  // INVESTIGATE: why the epsilon is smaller
     {{{2, 2}, {4+N, 4}, {1, 1}, {3, 3}}},
     {{{2, 2}, {4, 4}, {3, 3}, {1, 1+N}}},
 };
 
 const size_t negEpsilonLines_count = SK_ARRAY_COUNT(negEpsilonLines);