harden and speed up path op unit tests

tests/PathOpsCubicToQuadsTest.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 "PathOpsQuadIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkGeometry.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
 #include "SkReduceOrder.h"
 #include "Test.h"
 
 static void test(skiatest::Reporter* reporter, const SkDCubic* cubics, const char* name,
                  int firstTest, size_t testCount) {
     for (size_t index = firstTest; index < testCount; ++index) {
         const SkDCubic& cubic = cubics[index];
+        SkASSERT(ValidCubic(cubic));
         double precision = cubic.calcPrecision();
         SkTArray<SkDQuad, true> quads;
         CubicToQuads(cubic, precision, quads);
         if (quads.count() != 1 && quads.count() != 2) {
             SkDebugf("%s [%d] cubic to quadratics failed count=%d\n", name, static_cast<int>(index),
                     quads.count());
         }
         REPORTER_ASSERT(reporter, quads.count() == 1);
     }
 }
 
 static void test(skiatest::Reporter* reporter, const SkDQuad* quadTests, const char* name,
                  int firstTest, size_t testCount) {
     for (size_t index = firstTest; index < testCount; ++index) {
         const SkDQuad& quad = quadTests[index];
+        SkASSERT(ValidQuad(quad));
         SkDCubic cubic = quad.toCubic();
         double precision = cubic.calcPrecision();
         SkTArray<SkDQuad, true> quads;
         CubicToQuads(cubic, precision, quads);
         if (quads.count() != 1 && quads.count() != 2) {
             SkDebugf("%s [%d] cubic to quadratics failed count=%d\n", name, static_cast<int>(index),
                     quads.count());
         }
         REPORTER_ASSERT(reporter, quads.count() <= 2);
     }
 }
 
 static void testC(skiatest::Reporter* reporter, const SkDCubic* cubics, const char* name,
                   int firstTest, size_t testCount) {
     // test if computed line end points are valid
     for (size_t index = firstTest; index < testCount; ++index) {
         const SkDCubic& cubic = cubics[index];
+        SkASSERT(ValidCubic(cubic));
         double precision = cubic.calcPrecision();
         SkTArray<SkDQuad, true> quads;
         CubicToQuads(cubic, precision, quads);
         if (!AlmostEqualUlps(cubic[0].fX, quads[0][0].fX)
                 || !AlmostEqualUlps(cubic[0].fY, quads[0][0].fY)) {
             SkDebugf("[%d] unmatched start\n", static_cast<int>(index));
             REPORTER_ASSERT(reporter, 0);
         }
         int last = quads.count() - 1;
         if (!AlmostEqualUlps(cubic[3].fX, quads[last][2].fX)
                 || !AlmostEqualUlps(cubic[3].fY, quads[last][2].fY)) {
             SkDebugf("[%d] unmatched end\n", static_cast<int>(index));
             REPORTER_ASSERT(reporter, 0);
         }
     }
 }
 
 static void testC(skiatest::Reporter* reporter, const SkDCubic(* cubics)[2], const char* name,
                   int firstTest, size_t testCount) {
     for (size_t index = firstTest; index < testCount; ++index) {
         for (int idx2 = 0; idx2 < 2; ++idx2) {
             const SkDCubic& cubic = cubics[index][idx2];
+            SkASSERT(ValidCubic(cubic));
             double precision = cubic.calcPrecision();
             SkTArray<SkDQuad, true> quads;
             CubicToQuads(cubic, precision, quads);
             if (!AlmostEqualUlps(cubic[0].fX, quads[0][0].fX)
                     || !AlmostEqualUlps(cubic[0].fY, quads[0][0].fY)) {
                 SkDebugf("[%d][%d] unmatched start\n", static_cast<int>(index), idx2);
                 REPORTER_ASSERT(reporter, 0);
             }
             int last = quads.count() - 1;
             if (!AlmostEqualUlps(cubic[3].fX, quads[last][2].fX)
@@ skipping 77 matching lines @@
 };
 
 static size_t localsCount = SK_ARRAY_COUNT(locals);
 
 #define DEBUG_CRASH 0
 #define TEST_AVERAGE_END_POINTS 0  // must take const off to test
 extern const bool AVERAGE_END_POINTS;
 
 static void oneOff(skiatest::Reporter* reporter, size_t x) {
     const SkDCubic& cubic = locals[x];
+    SkASSERT(ValidCubic(cubic));
     const SkPoint skcubic[4] = {
             {static_cast<float>(cubic[0].fX), static_cast<float>(cubic[0].fY)},
             {static_cast<float>(cubic[1].fX), static_cast<float>(cubic[1].fY)},
             {static_cast<float>(cubic[2].fX), static_cast<float>(cubic[2].fY)},
             {static_cast<float>(cubic[3].fX), static_cast<float>(cubic[3].fY)}};
     SkScalar skinflect[2];
     int skin = SkFindCubicInflections(skcubic, skinflect);
     if (false) SkDebugf("%s %d %1.9g\n", __FUNCTION__, skin, skinflect[0]);
     SkTArray<SkDQuad, true> quads;
     double precision = cubic.calcPrecision();
@@ skipping 12 matching lines @@
 }
 
 static void PathOpsCubicToQuadsTest(skiatest::Reporter* reporter) {
     CubicToQuads_Test(reporter);
     CubicsToQuadratics_OneOffTest(reporter);
     CubicsToQuadratics_OneOffTests(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS_SHORT(PathOpsCubicToQuadsTest)