path ops -- handle non-finite numbers

tests/PathOpsExtendedTest.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 "PathOpsExtendedTest.h"
 #include "PathOpsThreadedCommon.h"
 #include "SkBitmap.h"
@@ skipping 431 matching lines @@
     outFile.flush();
 }
 
 bool testSimplify(SkPath& path, bool useXor, SkPath& out, PathOpsThreadState& state,
                   const char* pathStr) {
     SkPath::FillType fillType = useXor ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
     path.setFillType(fillType);
     if (gShowPath) {
         showPath(path);
     }
-    Simplify(path, &out);
+    if (!Simplify(path, &out)) {
+        SkDebugf("%s did not expect failure\n", __FUNCTION__);
+        REPORTER_ASSERT(state.fReporter, 0);
+        return false;
+    }
     if (!gComparePaths) {
         return true;
     }
     int result = comparePaths(state.fReporter, path, out, *state.fBitmap);
     if (result && gPathStrAssert) {
         char temp[8192];
         sk_bzero(temp, sizeof(temp));
         SkMemoryWStream stream(temp, sizeof(temp));
         const char* pathPrefix = NULL;
         const char* nameSuffix = NULL;
         if (fillType == SkPath::kEvenOdd_FillType) {
             pathPrefix = "    path.setFillType(SkPath::kEvenOdd_FillType);\n";
             nameSuffix = "x";
         }
         const char testFunction[] = "testSimplifyx(path);";
         outputToStream(pathStr, pathPrefix, nameSuffix, testFunction, false, stream);
         SkDebugf(temp);
         REPORTER_ASSERT(state.fReporter, 0);
     }
     state.fReporter->bumpTestCount();
     return result == 0;
 }
 
 bool testSimplify(skiatest::Reporter* reporter, const SkPath& path) {
 #if FORCE_RELEASE == 0
     showPathData(path);
 #endif
     SkPath out;
-    Simplify(path, &out);
+    if (!Simplify(path, &out)) {
+        SkDebugf("%s did not expect failure\n", __FUNCTION__);
+        REPORTER_ASSERT(reporter, 0);
+        return false;
+    }
     SkBitmap bitmap;
     int result = comparePaths(reporter, path, out, bitmap);
     if (result && gPathStrAssert) {
         REPORTER_ASSERT(reporter, 0);
     }
     reporter->bumpTestCount();
     return result == 0;
 }
 
 bool testPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
                  const SkPathOp shapeOp) {
 #if FORCE_RELEASE == 0
     showPathData(a);
     showOp(shapeOp);
     showPathData(b);
 #endif
     SkPath out;
-    Op(a, b, shapeOp, &out);
+    if (!Op(a, b, shapeOp, &out) ) {
+        SkDebugf("%s did not expect failure\n", __FUNCTION__);
+        REPORTER_ASSERT(reporter, 0);
+        return false;
+    }
     SkPath pathOut, scaledPathOut;
     SkRegion rgnA, rgnB, openClip, rgnOut;
     openClip.setRect(-16000, -16000, 16000, 16000);
     rgnA.setPath(a, openClip);
     rgnB.setPath(b, openClip);
     rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp);
     rgnOut.getBoundaryPath(&pathOut);
 
     SkMatrix scale;
     scaleMatrix(a, b, scale);
@@ skipping 91 matching lines @@
         }
         if (tests[index].fun == stopTest) {
             SkDebugf("lastTest\n");
         }
         if (index == last) {
             break;
         }
         index += reverse ? -1 : 1;
     } while (true);
 }