Write/compare against expectations in skimage tool.

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 "SkBitmapHasher.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTemplates.h"
 
+DEFINE_string(createExpectationsPath, "", "Path to write JSON expectations.");
 DEFINE_string2(readPath, r, "", "Folder(s) and files to decode images. Required.");
+DEFINE_string(readExpectationsPath, "", "Path to read JSON expectations from.");
 DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 DEFINE_bool(reencode, true, "Reencode the images to test encoding.");
 DEFINE_bool(testSubsetDecoding, true, "Test decoding subsets of images.");
 
 struct Format {
     SkImageEncoder::Type    fType;
     SkImageDecoder::Format  fFormat;
     const char*             fSuffix;
 };
 
@@ skipping 58 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;
 
+// 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[], SkBitmap* bm) {
     SkBitmap bitmap8888;
     if (SkBitmap::kARGB_8888_Config != bm->config()) {
         if (!bm->copyTo(&bitmap8888, SkBitmap::kARGB_8888_Config)) {
             return false;
         }
         bm = &bitmap8888;
     }
     // FIXME: This forces all pixels to be opaque, like the many implementations
     // of force_all_opaque. These should be unified if they cannot be eliminated.
@@ skipping 40 matching lines @@
             rect.fTop--;
         } else {
             rect.fBottom++;
             // Again, this must be in range.
             SkASSERT(rect.fBottom < maxY);
         }
     }
     return rect;
 }
 
+// Stored expectations to be written to a file createExpectationsPath is specified.

[epoger, 2013/05/08 17:24:48]

"written to a file createExpectationsPath" -> "written to a file *if*
createExpectationsPath" ?

[scroggo, 2013/05/08 18:46:33]

Done.

+static Json::Value gExpectationsToWrite;
+
+/**
+ *  If expectations are to be recorded, record the expected checksum of bitmap into global
+ *  expectations array.
+ */
+static void write_expectations(const SkBitmap& bitmap, const char* filename) {
+    if (!FLAGS_createExpectationsPath.isEmpty()) {
+        // Creates an Expectations object, and add it to the list to write.
+        skiagm::Expectations expectation(bitmap);
+        Json::Value value = expectation.asJsonValue();
+        gExpectationsToWrite[filename] = value;
+    }
+}
+
+/**
+ *  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.
+ *  @return bool True if the bitmap matched the expectation, or if there was no expectation. False
+ *      if there was an expecation that the bitmap did not match, or if an expectation could not be
+ *      computed from an expectation.
+ */
+static bool compare_to_expectations_if_necessary(const SkBitmap& bitmap, const char* filename,
+                                                 SkTArray<SkString, false>* failureArray) {

[epoger, 2013/05/08 17:24:48]

could you pass failureArray by reference instead, and then not have to worry
about it maybe being NULL?

[scroggo, 2013/05/08 18:46:33]

That makes sense to me, but according to our coding style guidelines, we pass
mutable parameters as pointers.

+    if (NULL == gJsonExpectations.get()) {
+        return true;
+    }
+    skiagm::Expectations jsExpectation = gJsonExpectations->get(filename);
+    if (jsExpectation.empty()) {
+        return true;
+    }
+    SkHashDigest checksum;
+    if (SkBitmapHasher::ComputeDigest(bitmap, &checksum)) {

[epoger, 2013/05/08 17:24:48]

I think it would be a bit easier to follow if you exit early when possible, like
you already do above...

if (!SkBitmapHasher::ComputeDigest(bitmap, &checksum)) {
  failureArray->push_back().printf("decoded %s, but could not create a
checksum.", filename);
  return false;
}

if (jsExpectation.match(checksum)) {
  return true;
}

failureArray->push_back().printf("decoded %s, but the result does not match "
  "expectations.", filename);
return false;

[scroggo, 2013/05/08 18:46:33]

Yes, that is much clearer! Done!

+        if (jsExpectation.match(checksum)) {
+            return true;
+        } else {
+            failureArray->push_back().printf("decoded %s, but the result does not match "
+                                             "expectations.",
+                                             filename);
+            return false;
+        }
+    } else {
+        failureArray->push_back().printf("decoded %s, but could not create a checksum.", filename);
+        return false;
+    }
+}
+
 static void decodeFileAndWrite(const char srcPath[], const SkString* writePath) {
     SkBitmap bitmap;
     SkFILEStream stream(srcPath);
     if (!stream.isValid()) {
         gInvalidStreams.push_back().set(srcPath);
         return;
     }
 
     SkImageDecoder* codec = SkImageDecoder::Factory(&stream);
     if (NULL == codec) {
         gMissingCodecs.push_back().set(srcPath);
         return;
     }
 
     SkAutoTDelete<SkImageDecoder> ad(codec);
 
     stream.rewind();
     if (!codec->decode(&stream, &bitmap, SkBitmap::kARGB_8888_Config,
                        SkImageDecoder::kDecodePixels_Mode)) {
         gDecodeFailures.push_back().set(srcPath);
         return;
     }
 
-    gSuccessfulDecodes.push_back().printf("%s [%d %d]", srcPath, bitmap.width(), bitmap.height());
+    // Create a string representing just the filename itself, for use in json expectations.
+    const char* filename = strrchr(srcPath, SkPATH_SEPARATOR);

[epoger, 2013/05/08 17:24:48]

Maybe split this out into its own SkBasename() method, which we could eventually
move into SkOSFile.h ?

[scroggo, 2013/05/08 18:46:33]

Moved into its own method. Sure enough, other files do something similar.
SkOSFile.h may be a good final place for it.

+    if (NULL == filename || ++filename == '\0') {
+        filename = srcPath;
+    }
+
+    if (compare_to_expectations_if_necessary(bitmap, filename, &gDecodeFailures)) {
+        gSuccessfulDecodes.push_back().printf("%s [%d %d]", srcPath, bitmap.width(),
+                                              bitmap.height());
+    }
+
+    write_expectations(bitmap, filename);
 
     if (FLAGS_testSubsetDecoding) {
         SkDEBUGCODE(bool couldRewind =) stream.rewind();
         SkASSERT(couldRewind);
         int width, height;
         // Build the tile index for decoding subsets. If the image is 1x1, skip subset
         // decoding since there are no smaller subsets.
         if (codec->buildTileIndex(&stream, &width, &height) && width > 1 && height > 1) {
             SkASSERT(bitmap.width() == width && bitmap.height() == height);
             // Call decodeSubset multiple times:
             SkRandom rand(0);
             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)) {
-                    gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
-                                                          subsetDim.c_str(), srcPath);
+                    SkString subsetName = SkStringPrintf("%s_%s", filename, subsetDim.c_str());
+                    if (compare_to_expectations_if_necessary(bitmapFromDecodeSubset,
+                                                             subsetName.c_str(),
+                                                             &gFailedSubsetDecodes)) {
+                        gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
+                                                              subsetDim.c_str(), srcPath);
+                    }
+
+                    write_expectations(bitmapFromDecodeSubset, subsetName.c_str());
+
                     if (writePath != NULL) {
                         // Write the region to a file whose name includes the dimensions.
                         SkString suffix = SkStringPrintf("_%s.png", subsetDim.c_str());
                         SkString outPath;
                         make_outname(&outPath, writePath->c_str(), srcPath, suffix.c_str());
                         SkDEBUGCODE(bool success =)
                         write_bitmap(outPath.c_str(), &bitmapFromDecodeSubset);
                         SkASSERT(success);
                         gSuccessfulSubsetDecodes.push_back().printf("\twrote %s", outPath.c_str());
                         // Also use extractSubset from the original for visual comparison.
@@ skipping 114 matching lines @@
     SkCommandLineFlags::Parse(argc, argv);
 
     if (FLAGS_readPath.count() < 1) {
         SkDebugf("Folder(s) or image(s) to decode are required.\n");
         return -1;
     }
 
 
     SkAutoGraphics ag;
 
+    if (!FLAGS_readExpectationsPath.isEmpty()) {
+        gJsonExpectations.reset(SkNEW_ARGS(skiagm::JsonExpectationsSource,
+                                           (FLAGS_readExpectationsPath[0])));
+    }
+
     SkString outDir;
     SkString* outDirPtr;
 
     if (FLAGS_writePath.count() == 1) {
         outDir.set(FLAGS_writePath[0]);
-        if (outDir.c_str()[outDir.size() - 1] != '/') {
-            outDir.append("/");
+        if (outDir.c_str()[outDir.size() - 1] != SkPATH_SEPARATOR) {

[scroggo, 2013/05/08 18:46:33]

Also moved into its own function.

+            outDir.append(&SkPATH_SEPARATOR);
         }
         outDirPtr = &outDir;
     } else {
         outDirPtr = NULL;
     }
 
     for (int i = 0; i < FLAGS_readPath.count(); i++) {
         if (strlen(FLAGS_readPath[i]) < 1) {
             break;
         }
         SkOSFile::Iter iter(FLAGS_readPath[i]);
         SkString filename;
         if (iter.next(&filename)) {
             SkString directory(FLAGS_readPath[i]);
-            if (directory[directory.size() - 1] != '/') {
-                directory.append("/");
+            if (directory[directory.size() - 1] != SkPATH_SEPARATOR) {
+                directory.append(&SkPATH_SEPARATOR);
             }
             do {
                 SkString fullname(directory);
                 fullname.append(filename);
                 decodeFileAndWrite(fullname.c_str(), outDirPtr);
             } while (iter.next(&filename));
         } else {
             decodeFileAndWrite(FLAGS_readPath[i], outDirPtr);
         }
     }
 
+    if (!FLAGS_createExpectationsPath.isEmpty()) {
+        // Use an empty value for everything besides expectations, since the reader only cares
+        // about the expectations.
+        Json::Value nullValue;
+        Json::Value root = skiagm::CreateJsonTree(gExpectationsToWrite, nullValue, nullValue,
+                                                  nullValue, nullValue);
+        std::string jsonStdString = root.toStyledString();
+        SkString path = SkStringPrintf("%s%cresults.json", FLAGS_createExpectationsPath[0],
+                                       SkPATH_SEPARATOR);
+        SkFILEWStream stream(path.c_str());
+        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);
 
     if (FLAGS_testSubsetDecoding) {
         failed |= print_strings("Failed subset decodes", gFailedSubsetDecodes);
         print_strings("Decoded subsets", gSuccessfulSubsetDecodes);
     }
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif