add --listfailingbase option

tools/skdiff_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 "skdiff.h"
 #include "skdiff_html.h"
 #include "skdiff_utils.h"
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTemplates.h"
 #include "SkTSearch.h"
-#include "SkTypes.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 /**
  * skdiff
  *
  * Given three directory names, expects to find identically-named files in
  * each of the first two; the first are treated as a set of baseline,
  * the second a set of variant images, and a diff image is written into the
  * third directory for each pair.
  * Creates an index.html in the current third directory to compare each
  * pair that does not match exactly.
  * Recursively descends directories, unless run with --norecurse.
  *
  * Returns zero exit code if all images match across baseDir and comparisonDir.
  */
 
 typedef SkTDArray<SkString*> StringArray;
 typedef StringArray FileArray;
 
+static void add_unique_basename(StringArray* array, const SkString& filename) {
+    // trim off dirs
+    const char* src = filename.c_str();
+    const char* trimmed = strrchr(src, SkPATH_SEPARATOR);
+    if (trimmed) {
+        trimmed += 1;   // skip the separator
+    } else {
+        trimmed = src;
+    }
+    const char* end = strrchr(trimmed, '.');
+    if (!end) {
+        end = trimmed + strlen(trimmed);
+    }
+    SkString result(trimmed, end - trimmed);
+
+    // only add unique entries
+    for (int i = 0; i < array->count(); ++i) {
+        if (*array->getAt(i) == result) {
+            return;
+        }
+    }
+    *array->append() = new SkString(result);
+}
+
 struct DiffSummary {
     DiffSummary ()
         : fNumMatches(0)
         , fNumMismatches(0)
         , fMaxMismatchV(0)
         , fMaxMismatchPercent(0) { };
 
     ~DiffSummary() {
         for (int i = 0; i < DiffRecord::kResultCount; ++i) {
             fResultsOfType[i].deleteAll();
         }
         for (int base = 0; base < DiffResource::kStatusCount; ++base) {
             for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
                 fStatusOfType[base][comparison].deleteAll();
             }
         }
     }
 
     uint32_t fNumMatches;
     uint32_t fNumMismatches;
     uint32_t fMaxMismatchV;
     float fMaxMismatchPercent;
 
     FileArray fResultsOfType[DiffRecord::kResultCount];
     FileArray fStatusOfType[DiffResource::kStatusCount][DiffResource::kStatusCount];
 
+    StringArray fFailedBaseNames[DiffRecord::kResultCount];
+
     void printContents(const FileArray& fileArray,
                        const char* baseStatus, const char* comparisonStatus,
                        bool listFilenames) {
         int n = fileArray.count();
         printf("%d file pairs %s in baseDir and %s in comparisonDir",
                 n,            baseStatus,       comparisonStatus);
         if (listFilenames) {
             printf(": ");
             for (int i = 0; i < n; ++i) {
                 printf("%s ", fileArray[i]->c_str());
@@ skipping 58 matching lines @@
             }
         }
         printf("(results marked with [*] will cause nonzero return value)\n");
         printf("\nnumber of mismatching file pairs: %d\n", fNumMismatches);
         if (fNumMismatches > 0) {
             printf("Maximum pixel intensity mismatch %d\n", fMaxMismatchV);
             printf("Largest area mismatch was %.2f%% of pixels\n",fMaxMismatchPercent);
         }
     }
 
+    void printfFailingBaseNames(const char separator[]) {
+        for (int resultInt = 0; resultInt < DiffRecord::kResultCount; ++resultInt) {
+            const StringArray& array = fFailedBaseNames[resultInt];
+            if (array.count()) {
+                printf("%s [%d]%s", DiffRecord::ResultNames[resultInt], array.count(), separator);
+                for (int j = 0; j < array.count(); ++j) {
+                    printf("%s%s", array[j]->c_str(), separator);
+                }
+                printf("\n");
+            }
+        }
+    }
+
     void add (DiffRecord* drp) {
         uint32_t mismatchValue;
 
         if (drp->fBase.fFilename.equals(drp->fComparison.fFilename)) {
             fResultsOfType[drp->fResult].push(new SkString(drp->fBase.fFilename));
         } else {
             SkString* blame = new SkString("(");
             blame->append(drp->fBase.fFilename);
             blame->append(", ");
             blame->append(drp->fComparison.fFilename);
@@ skipping 26 matching lines @@
             fStatusOfType[drp->fBase.fStatus][drp->fComparison.fStatus].push(
                     new SkString(drp->fBase.fFilename));
             break;
           case DiffRecord::kUnknown_Result:
             SkDEBUGFAIL("adding uncategorized DiffRecord");
             break;
           default:
             SkDEBUGFAIL("adding DiffRecord with unhandled fResult value");
             break;
         }
+
+        switch (drp->fResult) {
+            case DiffRecord::kEqualBits_Result:
+            case DiffRecord::kEqualPixels_Result:
+                break;
+            default:
+                add_unique_basename(&fFailedBaseNames[drp->fResult], drp->fBase.fFilename);
+                break;
+        }
     }
 };
 
 /// Returns true if string contains any of these substrings.
 static bool string_contains_any_of(const SkString& string,
                                    const StringArray& substrings) {
     for (int i = 0; i < substrings.count(); i++) {
         if (string.contains(substrings[i]->c_str())) {
             return true;
         }
@@ skipping 373 matching lines @@
     SkString outputDir;
 
     StringArray matchSubstrings;
     StringArray nomatchSubstrings;
 
     bool generateDiffs = true;
     bool listFilenames = false;
     bool printDirNames = true;
     bool recurseIntoSubdirs = true;
     bool verbose = false;
+    bool listFailingBase = false;
 
     RecordArray differences;
     DiffSummary summary;
 
     bool failOnResultType[DiffRecord::kResultCount];
     for (int i = 0; i < DiffRecord::kResultCount; i++) {
         failOnResultType[i] = false;
     }
 
     bool failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount];
@@ skipping 104 matching lines @@
                     continue;
                 case 2:
                     outputDir.set(argv[i]);
                     continue;
                 default:
                     SkDebugf("extra unflagged argument <%s>\n", argv[i]);
                     usage(argv[0]);
                     return kGenericError;
             }
         }
+        if (!strcmp(argv[i], "--listFailingBase")) {
+            listFailingBase = true;
+            continue;
+        }
 
         SkDebugf("Unrecognized argument <%s>\n", argv[i]);
         usage(argv[0]);
         return kGenericError;
     }
 
     if (numUnflaggedArguments == 2) {
         outputDir = comparisonDir;
     } else if (numUnflaggedArguments != 3) {
         usage(argv[0]);
@@ skipping 33 matching lines @@
     if (matchSubstrings.isEmpty()) {
         matchSubstrings.push(new SkString(""));
     }
 
     create_diff_images(diffProc, colorThreshold, &differences,
                        baseDir, comparisonDir, outputDir,
                        matchSubstrings, nomatchSubstrings, recurseIntoSubdirs, generateDiffs,
                        verbose, &summary);
     summary.print(listFilenames, failOnResultType, failOnStatusType);
 
+    if (listFailingBase) {
+        summary.printfFailingBaseNames("\n");
+    }
+
     if (differences.count()) {
         qsort(differences.begin(), differences.count(),
               sizeof(DiffRecord*), sortProc);
     }
 
     if (generateDiffs) {
         print_diff_page(summary.fNumMatches, colorThreshold, differences,
                         baseDir, comparisonDir, outputDir);
     }
 
@@ skipping 23 matching lines @@
     // range [0...255] are wrapped (mod 256).  Do the conversion ourselves, to
     // make sure that we only return 0 when there were no failures.
     return (num_failing_results > 255) ? 255 : num_failing_results;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif