add flaky test option

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 40 matching lines @@
 };
 
 static const char* opSuffixes[] = {
     "d",
     "i",
     "u",
     "o",
     "r",
 };
 
+enum class ExpectSuccess {
+    kNo,
+    kYes,
+    kFlaky
+};
+
+enum class SkipAssert {
+    kNo,
+    kYes
+};
+
+enum class ExpectMatch {
+    kNo,
+    kYes,
+    kFlaky
+};
+
 #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;
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
@@ skipping 255 matching lines @@
     SkDebugf("    testPathOp(reporter, path, pathB, %s, filename);\n", opStrs[shapeOp]);
     SkDebugf("}\n");
     drawAsciiPaths(scaledOne, scaledTwo, true);
 }
 
 SK_DECLARE_STATIC_MUTEX(compareDebugOut3);
 
 static int comparePaths(skiatest::Reporter* reporter, const char* testName, const SkPath& one,
         const SkPath& scaledOne, const SkPath& two, const SkPath& scaledTwo, SkBitmap& bitmap,
         const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const SkMatrix& scale,
-        bool expectSuccess) {
+        ExpectMatch expectMatch) {
     int errors2x2;
     const int MAX_ERRORS = 8;
     (void) pathsDrawTheSame(bitmap, scaledOne, scaledTwo, errors2x2);
-    if (!expectSuccess) {
+    if (ExpectMatch::kNo == expectMatch) {
         if (errors2x2 < MAX_ERRORS) {
             REPORTER_ASSERT(reporter, 0);
         }
         return 0;
     }
     if (errors2x2 == 0) {
         return 0;
     }
-    if (errors2x2 >= MAX_ERRORS) {
+    if (ExpectMatch::kYes == expectMatch && errors2x2 >= MAX_ERRORS) {
         SkAutoMutexAcquire autoM(compareDebugOut3);
         showPathOpPath(testName, one, two, a, b, scaledOne, scaledTwo, shapeOp, scale);
         SkDebugf("\n/*");
         REPORTER_ASSERT(reporter, 0);
         SkDebugf(" */\n");
     }
     return errors2x2 >= MAX_ERRORS ? errors2x2 : 0;
 }
 
 // Default values for when reporter->verbose() is false.
@@ skipping 85 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,
         ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) {
 #if 0 && DEBUG_SHOW_TEST_NAME
     showPathData(path);
 #endif
     SkPath out;
     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 (ExpectMatch::kNo == expectMatch) {
         if (!errors) {
             SkDebugf("%s failing test %s now succeeds\n", __FUNCTION__, filename);
             REPORTER_ASSERT(reporter, 0);
             return false;
         }
-    } else if (errors) {
+    } else if (ExpectMatch::kYes == expectMatch && 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, ExpectSuccess::kYes, SkipAssert::kNo,
             ExpectMatch::kYes);
 }
@@ skipping 59 matching lines @@
     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, ExpectMatch::kYes == expectMatch);
+            a, b, shapeOp, scale, 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, ExpectSuccess::kYes, SkipAssert::kNo,
             ExpectMatch::kYes);
 }
 
@@ skipping 14 matching lines @@
     return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kYes, SkipAssert::kYes,
             ExpectMatch::kYes);
 }
 
 bool testPathOpFailSkipAssert(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
         const SkPathOp shapeOp, const char* testName) {
     return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kNo, SkipAssert::kYes,
             ExpectMatch::kNo);
 }
 
+bool testPathOpFlakySkipAssert(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b,
+        const SkPathOp shapeOp, const char* testName) {
+    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kFlaky, SkipAssert::kYes,
+            ExpectMatch::kFlaky);
+}
+
 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__);
@@ skipping 103 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
 }