Do not fail skimage on missing expectations.

tools/skimage_main.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.
  */
 
 #include "gm_expectations.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 79 matching lines @@
 
 // Store the names of the filenames to report later which ones failed, succeeded, and were
 // invalid.
 static SkTArray<SkString, false> gInvalidStreams;
 static SkTArray<SkString, false> gMissingCodecs;
 static SkTArray<SkString, false> gDecodeFailures;
 static SkTArray<SkString, false> gEncodeFailures;
 static SkTArray<SkString, false> gSuccessfulDecodes;
 static SkTArray<SkString, false> gSuccessfulSubsetDecodes;
 static SkTArray<SkString, false> gFailedSubsetDecodes;
+// Files/subsets that do not have expectations. Not reported as a failure of the test so
+// the bots will not turn red with each new image test.
+static SkTArray<SkString, false> gMissingExpectations;
+static SkTArray<SkString, false> gMissingSubsetExpectations;
 
 // Expections read from a file specified by readExpectationsPath. The expectations must have been
 // previously written using createExpectationsPath.
 SkAutoTUnref<skiagm::JsonExpectationsSource> gJsonExpectations;
 
 static bool write_bitmap(const char outName[], const SkBitmap& bm) {
     return SkImageEncoder::EncodeFile(outName, bm, SkImageEncoder::kPNG_Type, 100);
 }
 
 /**
@@ skipping 62 matching lines @@
         return false;
     }
     skiagm::Expectations jsExpectations = gJsonExpectations->get(filename);
     return jsExpectations.ignoreFailure();
 }
 
 /**
  *  Compare against an expectation for this filename, if there is one.
  *  @param bitmap SkBitmap to compare to the expected value.
  *  @param filename String used to find the expected value.
+ *  @param failureArray Array to add a failure message to on failure.
+ *  @param missingArray Array to add missing expectation to on failure.
  *  @return bool True in any of these cases:
  *                  - the bitmap matches the expectation.
  *               False in any of these cases:
  *                  - there is no expectations file.
  *                  - there is an expectations file, but no expectation for this bitmap.
  *                  - there is an expectation for this bitmap, but it did not match.
  *                  - expectation could not be computed from the bitmap.
  */
 static bool compare_to_expectations_if_necessary(const SkBitmap& bitmap, const char* filename,
-                                                 SkTArray<SkString, false>* failureArray) {
+                                                 SkTArray<SkString, false>* failureArray,
+                                                 SkTArray<SkString, false>* missingArray) {
     skiagm::GmResultDigest resultDigest(bitmap);
     if (!resultDigest.isValid()) {
         if (failureArray != NULL) {
             failureArray->push_back().printf("decoded %s, but could not create a GmResultDigest.",
                                              filename);
         }
         return false;
     }
 
     if (NULL == gJsonExpectations.get()) {
         return false;
     }
 
     skiagm::Expectations jsExpectation = gJsonExpectations->get(filename);
     if (jsExpectation.empty()) {
-        if (failureArray != NULL) {
-            failureArray->push_back().printf("decoded %s, but could not find expectation.",
+        if (missingArray != NULL) {
+            missingArray->push_back().printf("decoded %s, but could not find expectation.",
                                              filename);
         }
         return false;
     }
 
     if (jsExpectation.match(resultDigest)) {
         return true;
     }
 
     if (failureArray != NULL) {
@@ skipping 117 matching lines @@
             gDecodeFailures.push_back() = failure;
         } else {
             // Now check that the bounds match:
             if (dim.width() != bitmap.width() || dim.height() != bitmap.height()) {
                 SkString failure = SkStringPrintf("bounds do not match for %s", srcPath);
                 gDecodeFailures.push_back() = failure;
             }
         }
     }
 
-    if (compare_to_expectations_if_necessary(bitmap, filename, &gDecodeFailures)) {
+    if (compare_to_expectations_if_necessary(bitmap, filename,
+                                             &gDecodeFailures,
+                                             &gMissingExpectations)) {
         gSuccessfulDecodes.push_back().printf("%s [%d %d]", srcPath, bitmap.width(),
                                               bitmap.height());
     } else if (!FLAGS_mismatchPath.isEmpty()) {
         SkString outPath;
         make_outname(&outPath, FLAGS_mismatchPath[0], srcPath, ".png");
         if (write_bitmap(outPath.c_str(), bitmap)) {
             gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
         } else {
             gEncodeFailures.push_back().set(outPath);
         }
@@ skipping 24 matching lines @@
             for (int i = 0; i < 5; i++) {
                 SkBitmap bitmapFromDecodeSubset;
                 // FIXME: Come up with a more representative set of rectangles.
                 SkIRect rect = generate_random_rect(&rand, width, height);
                 SkString subsetDim = SkStringPrintf("[%d,%d,%d,%d]", rect.fLeft, rect.fTop,
                                                     rect.fRight, rect.fBottom);
                 if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, SkBitmap::kNo_Config)) {
                     SkString subsetName = SkStringPrintf("%s_%s", filename, subsetDim.c_str());
                     if (compare_to_expectations_if_necessary(bitmapFromDecodeSubset,
                                                              subsetName.c_str(),
-                                                             &gFailedSubsetDecodes)) {
+                                                             &gFailedSubsetDecodes,
+                                                             &gMissingSubsetExpectations)) {
                         gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
                                                               subsetDim.c_str(), srcPath);
                     } else if (!FLAGS_mismatchPath.isEmpty()) {
                         write_subset(FLAGS_mismatchPath[0], filename, subsetDim.c_str(),
                                      &bitmapFromDecodeSubset, rect, bitmap);
                     }
 
                     write_expectations(bitmapFromDecodeSubset, subsetName.c_str());
                     if (writePath != NULL) {
                         write_subset(writePath->c_str(), filename, subsetDim.c_str(),
@@ skipping 180 matching lines @@
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
     // Add some space, since codecs may print warnings without newline.
     SkDebugf("\n\n");
 
     bool failed = print_strings("Invalid files", gInvalidStreams);
     failed |= print_strings("Missing codec", gMissingCodecs);
     failed |= print_strings("Failed to decode", gDecodeFailures);
     failed |= print_strings("Failed to encode", gEncodeFailures);
     print_strings("Decoded", gSuccessfulDecodes);
+    print_strings("Missing expectations", gMissingExpectations);
 
     if (FLAGS_testSubsetDecoding) {
         failed |= print_strings("Failed subset decodes", gFailedSubsetDecodes);
         print_strings("Decoded subsets", gSuccessfulSubsetDecodes);
+        print_strings("Missing subset expectations", gMissingSubsetExpectations);
     }
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif