harden and speed up path op unit tests

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];
+        SkASSERT(ValidQuad(quad1));
         const SkDQuad& quad2 = quadraticTests[index][1];
+        SkASSERT(ValidQuad(quad2));
         SkReduceOrder reduce1, reduce2;
         int order1 = reduce1.reduce(quad1, SkReduceOrder::kFill_Style);
         int order2 = reduce2.reduce(quad2, SkReduceOrder::kFill_Style);
         if (order1 < 3) {
             if (showSkipped) {
                 SkDebugf("[%d] quad1 order=%d\n", static_cast<int>(index), order1);
             }
         }
         if (order2 < 3) {
             if (showSkipped) {
@@ skipping 211 matching lines @@
     {{{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];
+    SkASSERT(ValidQuad(quad1));
     const SkDQuad& quad2 = testSet[inner];
+    SkASSERT(ValidQuad(quad2));
     SkIntersections intersections2;
     intersections2.intersect(quad1, quad2);
     for (int pt = 0; pt < intersections2.used(); ++pt) {
         double tt1 = intersections2[0][pt];
         SkDPoint xy1 = quad1.xyAtT(tt1);
         double tt2 = intersections2[1][pt];
         SkDPoint xy2 = quad2.xyAtT(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),
@@ skipping 24 matching lines @@
     {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
     {{{8, 8}, {10, 10}, {8, -10}}},
     {{{8, -10}, {10, 10}, {8, 8}}},
 };
 
 const size_t coincidentTestSetCount = SK_ARRAY_COUNT(coincidentTestSet);
 
 static void coincidentTest(skiatest::Reporter* reporter) {
     for (size_t testIndex = 0; testIndex < coincidentTestSetCount - 1; testIndex += 2) {
         const SkDQuad& quad1 = coincidentTestSet[testIndex];
+        SkASSERT(ValidQuad(quad1));
         const SkDQuad& quad2 = coincidentTestSet[testIndex + 1];
+        SkASSERT(ValidQuad(quad2));
         SkIntersections intersections2;
         intersections2.intersect(quad1, quad2);
         REPORTER_ASSERT(reporter, intersections2.coincidentUsed() == 2);
         REPORTER_ASSERT(reporter, intersections2.used() == 2);
         for (int pt = 0; pt < intersections2.coincidentUsed(); ++pt) {
             double tt1 = intersections2[0][pt];
             double tt2 = intersections2[1][pt];
             REPORTER_ASSERT(reporter, approximately_equal(1, tt1) || approximately_zero(tt1));
             REPORTER_ASSERT(reporter, approximately_equal(1, tt2) || approximately_zero(tt2));
         }
@@ skipping 169 matching lines @@
     standardTestCases(reporter);
     if (false) QuadraticIntersection_IntersectionFinder();
     if (false) QuadraticIntersection_PointFinder();
 }
 
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS_SHORT(PathOpsQuadIntersectionTest)
 
 DEFINE_TESTCLASS_SHORT(PathOpsQuadIntersectionOneOffTest)