GM: allow caller to specify which result types trigger an error

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 156 matching lines @@
     uint32_t flags;
 };
 
 static PipeFlagComboData gPipeWritingFlagCombos[] = {
     { "", 0 },
     { " cross-process", SkGPipeWriter::kCrossProcess_Flag },
     { " cross-process, shared address", SkGPipeWriter::kCrossProcess_Flag
         | SkGPipeWriter::kSharedAddressSpace_Flag }
 };
 
+const static ErrorCombination kDefaultIgnorableErrorTypes = ErrorCombination()
+    .plus(kMissingExpectations_ErrorType)
+    .plus(kIntentionallySkipped_ErrorType);
+
 class GMMain {
 public:
-    GMMain() : fUseFileHierarchy(false), fMismatchPath(NULL), fTestsRun(0),
-               fRenderModesEncountered(1) {
-        fIgnorableErrorCombination.add(kMissingExpectations_ErrorType);
-        fIgnorableErrorCombination.add(kIntentionallySkipped_ErrorType);
-    }
+    GMMain() : fUseFileHierarchy(false), fIgnorableErrorTypes(kDefaultIgnorableErrorTypes),
+               fMismatchPath(NULL), fTestsRun(0), fRenderModesEncountered(1) {}
 
     SkString make_name(const char shortName[], const char configName[]) {
         SkString name;
         if (0 == strlen(configName)) {
             name.append(shortName);
         } else if (fUseFileHierarchy) {
             name.appendf("%s%c%s", configName, SkPATH_SEPARATOR, shortName);
         } else {
             name.appendf("%s_%s", shortName, configName);
         }
@@ skipping 90 matching lines @@
     }
 
     /**
      * Return the number of significant (non-ignorable) errors we have
      * encountered so far.
      */
     int NumSignificantErrors() {
         int significantErrors = 0;
         for (int typeInt = 0; typeInt <= kLast_ErrorType; typeInt++) {
             ErrorType type = static_cast<ErrorType>(typeInt);
-            if (!fIgnorableErrorCombination.includes(type)) {
+            if (!fIgnorableErrorTypes.includes(type)) {
                 significantErrors += fFailedTests[type].count();
             }
         }
         return significantErrors;
     }
 
     /**
      * Display the summary of results with this ErrorType.
      *
      * @param type which ErrorType
      * @param verbose whether to be all verbose about it
      */
     void DisplayResultTypeSummary(ErrorType type, bool verbose) {
-        bool isIgnorableType = fIgnorableErrorCombination.includes(type);
+        bool isIgnorableType = fIgnorableErrorTypes.includes(type);
 
         SkString line;
         if (isIgnorableType) {
             line.append("[ ] ");
         } else {
             line.append("[*] ");
         }
 
         SkTArray<SkString> *failedTestsOfThisType = &fFailedTests[type];
         int count = failedTestsOfThisType->count();
@@ skipping 770 matching lines @@
         }
         return errors;
     }
 
     //
     // member variables.
     // They are public for now, to allow easier setting by tool_main().
     //
 
     bool fUseFileHierarchy;
-    ErrorCombination fIgnorableErrorCombination;
+    ErrorCombination fIgnorableErrorTypes;
 
     const char* fMismatchPath;
 
     // collection of tests that have failed with each ErrorType
     SkTArray<SkString> fFailedTests[kLast_ErrorType+1];
     int fTestsRun;
     SkTDict<int> fRenderModesEncountered;
 
     // Where to read expectations (expected image checksums, etc.) from.
     // If unset, we don't do comparisons.
@@ skipping 83 matching lines @@
 DEFINE_bool(deferred, true, "Exercise the deferred rendering test pass.");
 DEFINE_string(excludeConfig, "", "Space delimited list of configs to skip.");
 DEFINE_bool(forceBWtext, false, "Disable text anti-aliasing.");
 #if SK_SUPPORT_GPU
 DEFINE_string(gpuCacheSize, "", "<bytes> <count>: Limit the gpu cache to byte size or "
               "object count. " TOSTRING(DEFAULT_CACHE_VALUE) " for either value means "
               "use the default. 0 for either disables the cache.");
 #endif
 DEFINE_bool(hierarchy, false, "Whether to use multilevel directory structure "
             "when reading/writing files.");
+// TODO(epoger): Maybe should make SkCommandLineFlags handle default string
+// values differently, so that the first definition of ignoreErrorTypes worked?

[borenet, 2013/04/12 00:29:45]

Good question for scroggo@.  I'm not terribly familiar with SkCommandLineFlags.

[epoger, 2013/04/12 02:44:43]

Yeah, I wanted to commit this change and then see if we can improve
SkCommandLineFlags (or teach me how to use it properly!).

I tried using the ifdef-ed out approach, and whenever gm was run without
--ignoreErrorTypes specified (i.e., when it evaulated the default for this
option), I got this error:

GM: cannot find ErrorType with name 'Exercise the pdf rendering test pass.'

(That string of course coming from the definition of the pdf flag further
down!!!  Yikes!!!)

[scroggo, 2013/04/12 15:24:30]

Created https://code.google.com/p/skia/issues/detail?id=1237

+#if 0
+DEFINE_string(ignoreErrorTypes, kDefaultIgnorableErrorTypes.asString(" ").c_str(),
+              "Space-separated list of ErrorTypes that should be ignored. If any *other* error "
+              "types are encountered, the tool will exit with a nonzero return value.");
+#else
+DEFINE_string(ignoreErrorTypes, "", SkString(SkString(
+              "Space-separated list of ErrorTypes that should be ignored. If any *other* error "
+              "types are encountered, the tool will exit with a nonzero return value. "
+              "Defaults to: ") += kDefaultIgnorableErrorTypes.asString(" ")).c_str());
+#endif
 DEFINE_string(match, "",  "Only run tests whose name includes this substring/these substrings "
               "(more than one can be supplied, separated by spaces).");
 DEFINE_string(mismatchPath, "", "Write images for tests that failed due to "
               "pixel mismatches into this directory.");
 DEFINE_string(modulo, "", "[--modulo <remainder> <divisor>]: only run tests for which "
               "testIndex %% divisor == remainder.");
 DEFINE_bool(pdf, true, "Exercise the pdf rendering test pass.");
 DEFINE_bool(pipe, true, "Exercise the SkGPipe replay test pass.");
 DEFINE_string2(readPath, r, "", "Read reference images from this dir, and report "
                "any differences between those and the newly generated ones.");
@@ skipping 410 matching lines @@
 
     if (FLAGS_modulo.count() == 2) {
         moduloRemainder = atoi(FLAGS_modulo[0]);
         moduloDivisor = atoi(FLAGS_modulo[1]);
         if (moduloRemainder < 0 || moduloDivisor <= 0 || moduloRemainder >= moduloDivisor) {
             gm_fprintf(stderr, "invalid modulo values.");
             return -1;
         }
     }
 
+    if (FLAGS_ignoreErrorTypes.count() > 0) {
+        gmmain.fIgnorableErrorTypes = ErrorCombination();
+        for (int i = 0; i < FLAGS_ignoreErrorTypes.count(); i++) {
+            ErrorType type;
+            const char *name = FLAGS_ignoreErrorTypes[i];
+            if (!getErrorTypeByName(name, &type)) {
+                gm_fprintf(stderr, "cannot find ErrorType with name '%s'\n", name);
+                return -1;
+            } else {
+                gmmain.fIgnorableErrorTypes.add(type);
+            }
+        }
+    }
+
 #if SK_SUPPORT_GPU
     if (FLAGS_gpuCacheSize.count() > 0) {
         if (FLAGS_gpuCacheSize.count() != 2) {
             gm_fprintf(stderr, "--gpuCacheSize requires two arguments\n");
             return -1;
         }
         gGpuCacheSizeBytes = atoi(FLAGS_gpuCacheSize[0]);
         gGpuCacheSizeCount = atoi(FLAGS_gpuCacheSize[1]);
     } else {
         gGpuCacheSizeBytes = DEFAULT_CACHE_VALUE;
@@ skipping 237 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif