pathops coincidence and security rewrite

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"
 #include "SkCanvas.h"
 #include "SkForceLinking.h"
 #include "SkMatrix.h"
 #include "SkMutex.h"
 #include "SkPaint.h"
 #include "SkRTConf.h"
 #include "SkStream.h"
 
 #include <stdlib.h>
 
 #ifdef SK_BUILD_FOR_MAC
 #include <sys/sysctl.h>
 #endif
 
+bool OpDebug(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result
+             SkDEBUGPARAMS(bool skipAssert)
+             SkDEBUGPARAMS(const char* testName));
+
+bool SimplifyDebug(const SkPath& one, SkPath* result
+                   SkDEBUGPARAMS(bool skipAssert)
+                   SkDEBUGPARAMS(const char* testName));
+
+
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_bool2(runFail, f, false, "run tests known to fail.");
 DEFINE_bool2(runBinary, f, false, "run tests known to fail binary sect.");
 
 static const char marker[] =
     "</div>\n"
     "\n"
     "<script type=\"text/javascript\">\n"
     "\n"
     "var testDivs = [\n";
 
 static const char* opStrs[] = {
     "kDifference_SkPathOp",
     "kIntersect_SkPathOp",
     "kUnion_SkPathOp",
-    "kXor_PathOp",
+    "kXOR_PathOp",
     "kReverseDifference_SkPathOp",
 };
 
 static const char* opSuffixes[] = {
     "d",
     "i",
     "u",
     "o",
+    "r",
 };
 
 #if DEBUG_SHOW_TEST_NAME
 static void showPathData(const SkPath& path) {
     SkPath::RawIter iter(path);
     uint8_t verb;
     SkPoint pts[4];
     SkPoint firstPt = {0, 0}, lastPt = {0, 0};
     bool firstPtSet = false;
     bool lastPtSet = true;
@@ skipping 376 matching lines @@
         }
         const char testFunction[] = "testSimplify(reporter, path);";
         outputToStream(pathStr, pathPrefix, nameSuffix, testFunction, false, stream);
         SkDebugf("%s", temp);
         REPORTER_ASSERT(state.fReporter, 0);
     }
     state.fReporter->bumpTestCount();
     return result == 0;
 }
 
+enum class ExpectSuccess {
+    kNo,
+    kYes
+};
+
+enum class SkipAssert {
+    kNo,
+    kYes
+};
+
+enum class ExpectMatch {
+    kNo,
+    kYes
+};
+
 static bool inner_simplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename,
-        bool checkFail) {
+        ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) {
 #if 0 && DEBUG_SHOW_TEST_NAME
     showPathData(path);
 #endif
     SkPath out;
-    if (!Simplify(path, &out)) {
-        SkDebugf("%s did not expect %s failure\n", __FUNCTION__, filename);
-        REPORTER_ASSERT(reporter, 0);
+    if (!SimplifyDebug(path, &out  SkDEBUGPARAMS(SkipAssert::kYes == skipAssert)
+            SkDEBUGPARAMS(testName))) {
+        if (ExpectSuccess::kYes == expectSuccess) {
+            SkDebugf("%s did not expect %s failure\n", __FUNCTION__, filename);
+            REPORTER_ASSERT(reporter, 0);
+        }
         return false;
+    } else {
+        if (ExpectSuccess::kNo == expectSuccess) {
+            SkDebugf("%s %s unexpected success\n", __FUNCTION__, filename);
+            REPORTER_ASSERT(reporter, 0);
+        }
     }
     SkBitmap bitmap;
     int errors = comparePaths(reporter, filename, path, out, bitmap);
-    if (!checkFail) {
+    if (ExpectMatch::kNo == expectMatch) {
         if (!errors) {
             SkDebugf("%s failing test %s now succeeds\n", __FUNCTION__, filename);
             REPORTER_ASSERT(reporter, 0);
             return false;
         }
     } else if (errors) {
         REPORTER_ASSERT(reporter, 0);
     }
     reporter->bumpTestCount();
     return errors == 0;
 }
 
 bool testSimplify(skiatest::Reporter* reporter, const SkPath& path, const char* filename) {
-    return inner_simplify(reporter, path, filename, true);
+    return inner_simplify(reporter, path, filename, ExpectSuccess::kYes, SkipAssert::kNo,
+            ExpectMatch::kYes);
+}
+
+bool testSimplifyFailSkipAssert(skiatest::Reporter* reporter, const SkPath& path, const char* filename) {
+    return inner_simplify(reporter, path, filename, ExpectSuccess::kNo, SkipAssert::kYes,
+            ExpectMatch::kNo);
 }
 
 bool testSimplifyCheck(skiatest::Reporter* reporter, const SkPath& path, const char* filename,
         bool checkFail) {
-    return inner_simplify(reporter, path, filename, checkFail);
+    return inner_simplify(reporter, path, filename, checkFail ?
+            ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
 }
 
 #if DEBUG_SHOW_TEST_NAME
 static void showName(const SkPath& a, const SkPath& b, const SkPathOp shapeOp) {
     SkDebugf("\n");
     showPathData(a);
     showOp(shapeOp);
     showPathData(b);
 }
 #endif
 
-bool OpDebug(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result
-             SkDEBUGPARAMS(bool skipAssert)
-             SkDEBUGPARAMS(const char* testName));
-
 static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
-        const SkPathOp shapeOp, const char* testName, bool expectSuccess, bool skipAssert) {
+        const SkPathOp shapeOp, const char* testName, ExpectSuccess expectSuccess,
+        SkipAssert skipAssert, ExpectMatch expectMatch) {
 #if 0 && DEBUG_SHOW_TEST_NAME
     showName(a, b, shapeOp);
 #endif
     SkPath out;
-    if (!OpDebug(a, b, shapeOp, &out  SkDEBUGPARAMS(skipAssert)
+    if (!OpDebug(a, b, shapeOp, &out  SkDEBUGPARAMS(SkipAssert::kYes == skipAssert)
             SkDEBUGPARAMS(testName))) {
-        if (expectSuccess) {
-            SkDebugf("%s did not expect failure\n", __FUNCTION__);
+        if (ExpectSuccess::kYes == expectSuccess) {
+            SkDebugf("%s %s did not expect failure\n", __FUNCTION__, testName);
             REPORTER_ASSERT(reporter, 0);
         }
         return false;
+    } else {
+        if (ExpectSuccess::kNo == expectSuccess) {
+                SkDebugf("%s %s unexpected success\n", __FUNCTION__, testName);
+                REPORTER_ASSERT(reporter, 0);
+        }
     }
     if (!reporter->verbose()) {
         return true;
     }
     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);
     SkRegion scaledRgnA, scaledRgnB, scaledRgnOut;
     SkPath scaledA, scaledB;
     scaledA.addPath(a, scale);
     scaledA.setFillType(a.getFillType());
     scaledB.addPath(b, scale);
     scaledB.setFillType(b.getFillType());
     scaledRgnA.setPath(scaledA, openClip);
     scaledRgnB.setPath(scaledB, openClip);
     scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp);
     scaledRgnOut.getBoundaryPath(&scaledPathOut);
     SkBitmap bitmap;
     SkPath scaledOut;
     scaledOut.addPath(out, scale);
     scaledOut.setFillType(out.getFillType());
     int result = comparePaths(reporter, testName, pathOut, scaledPathOut, out, scaledOut, bitmap,
-            a, b, shapeOp, scale, expectSuccess);
+            a, b, shapeOp, scale, ExpectMatch::kYes == expectMatch);
     reporter->bumpTestCount();
     return result == 0;
 }
 
 bool testPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName) {
-    return innerPathOp(reporter, a, b, shapeOp, testName, true, false);
+    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kYes, SkipAssert::kNo,
+            ExpectMatch::kYes);
 }
 
 bool testPathOpCheck(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName, bool checkFail) {
-    return innerPathOp(reporter, a, b, shapeOp, testName, checkFail, false);
+    return innerPathOp(reporter, a, b, shapeOp, testName, checkFail ?
+            ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
 }
 
 bool testPathOpFailCheck(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName) {
-    return innerPathOp(reporter, a, b, shapeOp, testName, false, false);
+    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kNo, SkipAssert::kNo,
+            ExpectMatch::kNo);
 }
 
-bool testPathSkipAssertOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
+bool testPathOpSkipAssert(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName) {
-    return innerPathOp(reporter, a, b, shapeOp, testName, true, true);
+    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kYes, SkipAssert::kYes,
+            ExpectMatch::kYes);
 }
 
-bool testPathFailSkipAssertOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
+bool testPathOpFailSkipAssert(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName) {
-    return innerPathOp(reporter, a, b, shapeOp, testName, false, true);
+    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kNo, SkipAssert::kYes,
+            ExpectMatch::kNo);
 }
 
-bool testPathFailOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
+bool testPathOpFail(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
                  const SkPathOp shapeOp, const char* testName) {
 #if DEBUG_SHOW_TEST_NAME
     showName(a, b, shapeOp);
 #endif
     SkPath orig;
     orig.lineTo(54, 43);
     SkPath out = orig;
     if (Op(a, b, shapeOp, &out) ) {
         SkDebugf("%s test is expected to fail\n", __FUNCTION__);
         REPORTER_ASSERT(reporter, 0);
@@ skipping 106 matching lines @@
         if (foundSkip && tests[index].fun != firstTest) {
             SkDebugf("    %s,\n", tests[index].str);
         }
         if (tests[index].fun == stopTest || index == last) {
             break;
         }
         index += reverse ? -1 : 1;
     } while (true);
 #endif
 }