make ignored-tests.txt specify full test name, not partial name

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 308 matching lines @@
             if (modeAsString.startsWith("-")) {
                 modeAsString.remove(0, 1);
             }
             modes.push_back(modeAsString);
         }
     }
 
     /**
      * Returns true if failures on this test should be ignored.
      */
-    bool ShouldIgnoreTest(const SkString &name) const {
-        for (int i = 0; i < fIgnorableTestSubstrings.count(); i++) {
-            if (name.contains(fIgnorableTestSubstrings[i].c_str())) {
+    bool ShouldIgnoreTest(const char *name) const {
+        for (int i = 0; i < fIgnorableTestNames.count(); i++) {
+            if (fIgnorableTestNames[i].equals(name)) {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * Calls RecordTestResults to record that we skipped a test.
      *
      * Depending on the backend, this may mean that we skipped a single rendermode, or all
@@ skipping 569 matching lines @@
      *
      * @param gm which test generated the actualBitmap
      * @param gRec
      * @param configName The config name to look for in the expectation file.
      * @param actualBitmapAndDigest ptr to bitmap generated by this run, or NULL
      *        if we don't have a usable bitmap representation
      */
     ErrorCombination compare_test_results_to_stored_expectations(
         GM* gm, const ConfigData& gRec, const char* configName,
         const BitmapAndDigest* actualBitmapAndDigest) {
-
-        SkString shortNamePlusConfig = make_shortname_plus_config(gm->shortName(), configName);
-
         ErrorCombination errors;
 
         if (NULL == actualBitmapAndDigest) {
             // Note that we intentionally skipped validating the results for
             // this test, because we don't know how to generate an SkBitmap
             // version of the output.
             errors.add(ErrorCombination(kIntentionallySkipped_ErrorType));
         } else if (!(gRec.fFlags & kWrite_ConfigFlag)) {
             // We don't record the results for this test or compare them
             // against any expectations, because the output image isn't
             // meaningful.
             // See https://code.google.com/p/skia/issues/detail?id=1410 ('some
             // GM result images not available for download from Google Storage')
             errors.add(ErrorCombination(kIntentionallySkipped_ErrorType));
         } else {
             ExpectationsSource *expectationsSource = this->fExpectationsSource.get();
-            SkString nameWithExtension(shortNamePlusConfig);
+            SkString nameWithExtension = make_shortname_plus_config(gm->shortName(), configName);
             nameWithExtension.append(".");
             nameWithExtension.append(kPNG_FileExtension);
 
             if (expectationsSource && (gRec.fFlags & kRead_ConfigFlag)) {
                 /*
                  * Get the expected results for this test, as one or more allowed
                  * hash digests. The current implementation of expectationsSource
                  * get this by computing the hash digest of a single PNG file on disk.
                  *
                  * TODO(epoger): This relies on the fact that
                  * force_all_opaque() was called on the bitmap before it
                  * was written to disk as a PNG in the first place. If
                  * not, the hash digest returned here may not match the
                  * hash digest of actualBitmap, which *has* been run through
                  * force_all_opaque().
                  * See comments above complete_bitmap() for more detail.
                  */
                 Expectations expectations = expectationsSource->get(nameWithExtension.c_str());
-                if (this->ShouldIgnoreTest(shortNamePlusConfig)) {
+                if (this->ShouldIgnoreTest(gm->shortName())) {
                     expectations.setIgnoreFailure(true);
                 }
                 errors.add(compare_to_expectations(expectations, *actualBitmapAndDigest,
                                                    gm->shortName(), configName, "", true));
             } else {
                 // If we are running without expectations, we still want to
                 // record the actual results.
                 add_actual_results_to_json_summary(nameWithExtension.c_str(),
                                                    actualBitmapAndDigest->fDigest,
                                                    ErrorCombination(kMissingExpectations_ErrorType),
@@ skipping 277 matching lines @@
         return errors;
     }
 
     //
     // member variables.
     // They are public for now, to allow easier setting by tool_main().
     //
 
     bool fUseFileHierarchy, fWriteChecksumBasedFilenames;
     ErrorCombination fIgnorableErrorTypes;
-    SkTArray<SkString> fIgnorableTestSubstrings;
+    SkTArray<SkString> fIgnorableTestNames;
 
     const char* fMismatchPath;
     const char* fMissingExpectationsPath;
 
     // collection of tests that have failed with each ErrorType
     SkTArray<SkString> fFailedTests[kLast_ErrorType+1];
     SkTArray<SkString> fTestsSkippedOnAllRenderModes;
     int fTestsRun;
     SkTDict<int> fRenderModesEncountered;
 
@@ skipping 799 matching lines @@
                 return false;
             } else {
                 outErrorTypes->add(type);
             }
         }
     }
     return true;
 }
 
 /**
- * Replace contents of ignoreTestSubstrings with a list of testname/config substrings, indicating
+ * Replace contents of ignoreTestNames with a list of test names, indicating
  * which tests' failures should be ignored.
  */
-static bool parse_flags_ignore_tests(SkTArray<SkString> &ignoreTestSubstrings) {
-    ignoreTestSubstrings.reset();
+static bool parse_flags_ignore_tests(SkTArray<SkString> &ignoreTestNames) {
+    ignoreTestNames.reset();
 
     // 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);
+                    ignoreTestNames.push_back(thisLine);
                 }
             }
         }
     }
 
     return true;
 }
 
 static bool parse_flags_modulo(int* moduloRemainder, int* moduloDivisor) {
     if (FLAGS_modulo.count() == 2) {
@@ skipping 119 matching lines @@
     SkTDArray<const PDFRasterizerData*> pdfRasterizers;
     SkTDArray<SkScalar> tileGridReplayScales;
 #if SK_SUPPORT_GPU
     GrContextFactory* grFactory = new GrContextFactory;
 #else
     GrContextFactory* grFactory = NULL;
 #endif
 
     if (!parse_flags_modulo(&moduloRemainder, &moduloDivisor) ||
         !parse_flags_ignore_error_types(&gmmain.fIgnorableErrorTypes) ||
-        !parse_flags_ignore_tests(gmmain.fIgnorableTestSubstrings) ||
+        !parse_flags_ignore_tests(gmmain.fIgnorableTestNames) ||
 #if SK_SUPPORT_GPU
         !parse_flags_gpu_cache(&gGpuCacheSizeBytes, &gGpuCacheSizeCount) ||
 #endif
         !parse_flags_tile_grid_replay_scales(&tileGridReplayScales) ||
         !parse_flags_resource_path() ||
         !parse_flags_jpeg_quality() ||
         !parse_flags_configs(&configs, grFactory) ||
         !parse_flags_pdf_rasterizers(configs, &pdfRasterizers) ||
         !parse_flags_gmmain_paths(&gmmain)) {
         return -1;
@@ skipping 167 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