GM: add --ignoreFailuresFile as an alternative to --ignoreTests

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 18 matching lines @@
 #include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPDFRasterizer.h"
 #include "SkPicture.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkStream.h"
+#include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDict.h"
 #include "SkTileGridPicture.h"
 #include "SamplePipeControllers.h"
 
 #ifdef SK_DEBUG
 static const bool kDebugOnly = true;
 #else
 static const bool kDebugOnly = false;
 #endif
@@ skipping 1365 matching lines @@
 #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.");
 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.");
+DEFINE_string(ignoreFailuresFile, "", "Path to file containing a list of tests for which we "
+              "should ignore failures.\n"
+              "The file should list one test per line, except for comment lines starting with #");
 DEFINE_string(ignoreTests, "", "Space delimited list of tests for which we should ignore "
-              "failures.");
+              "failures.\n"
+              "DEPRECATED in favor of --ignoreFailuresFile; see bug 1730");
 DEFINE_string(match, "", "[~][^]substring[$] [...] of test name to run.\n"
               "Multiple matches may be separated by spaces.\n"
               "~ causes a matching test to always be skipped\n"
               "^ requires the start of the test to match\n"
               "$ requires the end of the test to match\n"
               "^ and $ requires an exact match\n"
               "If a test does not match any list entry,\n"
               "it is skipped unless some list entry starts with ~");
 DEFINE_string(missingExpectationsPath, "", "Write images for tests without expectations "
               "into this directory.");
@@ skipping 337 matching lines @@
                                                         FLAGS_simulatePipePlaybackFailure));
         if (FLAGS_tiledPipe) {
             errorsForAllModes.add(gmmain.test_tiled_pipe_playback(gm, compareConfig,
                                                                   comparisonBitmap));
         }
     }
     return errorsForAllModes;
 }
 
 /**
+ * Read individual lines from a file, pushing them into the given array.
+ *
+ * @param filename path to the file to read
+ * @param lines array of strings to add the lines to
+ * @returns true if able to read lines from the file
+ */
+static bool read_lines_from_file(const char* filename, SkTArray<SkString> &lines) {
+    SkAutoTUnref<SkStream> streamWrapper(SkStream::NewFromFile(filename));
+    SkStream *stream = streamWrapper.get();
+    if (!stream) {
+        gm_fprintf(stderr, "unable to read file '%s'\n", filename);
+        return false;
+    }
+
+    char c;
+    SkString line;
+    while (1 == stream->read(&c, 1)) {
+        // If we hit either CR or LF, we've completed a line.
+        //
+        // TODO: If the file uses both CR and LF, this will return an extra blank
+        // line for each line of the file.  Which is OK for current purposes...
+        //
+        // TODO: Does this properly handle unicode?  It doesn't matter for
+        // current purposes...
+        if ((c == 0x0d) || (c == 0x0a)) {
+            lines.push_back(line);
+            line.reset();
+        } else {
+            line.append(&c, 1);
+        }
+    }
+    lines.push_back(line);
+    return true;
+}
+
+/**
  * Return a list of all entries in an array of strings as a single string
  * of this form:
  * "item1", "item2", "item3"
  */
 SkString list_all(const SkTArray<SkString> &stringArray);
 SkString list_all(const SkTArray<SkString> &stringArray) {
     SkString total;
     for (int i = 0; i < stringArray.count(); i++) {
         if (i > 0) {
             total.append(", ");
@@ skipping 220 matching lines @@
     }
     return true;
 }
 
 /**
  * Replace contents of ignoreTestSubstrings with a list of testname/config substrings, indicating
  * which tests' failures should be ignored.
  */
 static bool parse_flags_ignore_tests(SkTArray<SkString> &ignoreTestSubstrings) {
     ignoreTestSubstrings.reset();
+
+    // Parse --ignoreTests
     for (int i = 0; i < FLAGS_ignoreTests.count(); i++) {

[scroggo, 2013/10/18 14:32:49]

If this is deprecated, should we add a message when it's used? The help string
is only shown if the user needs help (so they may never see it), and the help
string is rather large due to all the possible options.

[epoger, 2013/10/18 14:36:13]

My intent is to follow up this CL with more CLs that:
1. make buildbots use the new flag instead of the old one
2. wait for it to work through buildbots
3. remove the old flag

I'm open to other transition plans... I figured that nobody but the buildbots
are really using this flag currently anyway.

Any thoughts?

         ignoreTestSubstrings.push_back(SkString(FLAGS_ignoreTests[i]));
     }
+
+    // Parse --ignoreFailuresFile
+    for (int i = 0; i < FLAGS_ignoreFailuresFile.count(); i++) {
+        SkTArray<SkString> linesFromFile;
+        if (!read_lines_from_file(FLAGS_ignoreFailuresFile[i], linesFromFile)) {
+            return false;
+        } else {
+            for (int j = 0; j < linesFromFile.count(); j++) {
+                SkString thisLine = linesFromFile[j];
+                if (thisLine.isEmpty() || thisLine.startsWith('#')) {
+                    // skip this line
+                } else {
+                    ignoreTestSubstrings.push_back(thisLine);
+                }
+            }
+        }
+    }
+
     return true;
 }
 
 static bool parse_flags_modulo(int* moduloRemainder, int* moduloDivisor) {
     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.");
@@ skipping 286 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