DiffSummary Struct Reference

Public Member Functions
	DiffSummary ()
void	printContents (const FileArray &fileArray, const char *baseStatus, const char *comparisonStatus, bool listFilenames)
void	printStatus (bool listFilenames, bool failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount])
void	printContents (const FileArray &fileArray, const char *headerText, bool listFilenames)
void	print (bool listFilenames, bool failOnResultType[DiffRecord::kResultCount], bool failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount])
void	printfFailingBaseNames (const char separator[])
void	add (const DiffRecord &drp)

Public Attributes
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]

Detailed Description

Definition at line 64 of file skdiff_main.cpp.

Constructor & Destructor Documentation

DiffSummary()

DiffSummary::DiffSummary ( )

inline

Definition at line 65 of file skdiff_main.cpp.

        : fNumMatches(0)
        , fNumMismatches(0)
        , fMaxMismatchV(0)
        , fMaxMismatchPercent(0) { }

Member Function Documentation

add()

void DiffSummary::add ( const DiffRecord &  drp )

inline

Definition at line 172 of file skdiff_main.cpp.

                                     {
        uint32_t mismatchValue;
 
        if (drp.fBase.fFilename.equals(drp.fComparison.fFilename)) {
            fResultsOfType[drp.fResult].push_back(drp.fBase.fFilename);
        } else {
            SkString blame("(");
            blame.append(drp.fBase.fFilename);
            blame.append(", ");
            blame.append(drp.fComparison.fFilename);
            blame.append(")");
            fResultsOfType[drp.fResult].push_back(std::move(blame));
        }
        switch (drp.fResult) {
          case DiffRecord::kEqualBits_Result:
            fNumMatches++;
            break;
          case DiffRecord::kEqualPixels_Result:
            fNumMatches++;
            break;
          case DiffRecord::kDifferentSizes_Result:
            fNumMismatches++;
            break;
          case DiffRecord::kDifferentPixels_Result:
            fNumMismatches++;
            if (drp.fFractionDifference * 100 > fMaxMismatchPercent) {
                fMaxMismatchPercent = drp.fFractionDifference * 100;
            }
            mismatchValue = MAX3(drp.fMaxMismatchR, drp.fMaxMismatchG,
                                 drp.fMaxMismatchB);
            if (mismatchValue > fMaxMismatchV) {
                fMaxMismatchV = mismatchValue;
            }
            break;
          case DiffRecord::kCouldNotCompare_Result:
            fNumMismatches++;
            fStatusOfType[drp.fBase.fStatus][drp.fComparison.fStatus].push_back(
                    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;
        }
    }

print()

void DiffSummary::print ( bool  listFilenames, bool  failOnResultType[DiffRecord::kResultCount], bool  failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount]  )

inline

Definition at line 134 of file skdiff_main.cpp.

                                                                {
        printf("\ncompared %u file pairs:\n", fNumMatches + fNumMismatches);
        for (int resultInt = 0; resultInt < DiffRecord::kResultCount; ++resultInt) {
            DiffRecord::Result result = static_cast<DiffRecord::Result>(resultInt);
            if (failOnResultType[result]) {
                printf("[*] ");
            } else {
                printf("[_] ");
            }
            printContents(fResultsOfType[result], DiffRecord::getResultDescription(result),
                          listFilenames);
            if (DiffRecord::kCouldNotCompare_Result == result) {
                printStatus(listFilenames, failOnStatusType);
            }
        }
        printf("(results marked with [*] will cause nonzero return value)\n");
        printf("\nnumber of mismatching file pairs: %u\n", fNumMismatches);
        if (fNumMismatches > 0) {
            printf("Maximum pixel intensity mismatch %u\n", fMaxMismatchV);
            printf("Largest area mismatch was %.2f%% of pixels\n",fMaxMismatchPercent);
        }
    }

printContents() [1/2]

void DiffSummary::printContents ( const FileArray &  fileArray, const char *  baseStatus, const char *  comparisonStatus, bool  listFilenames  )

inline

Definition at line 81 of file skdiff_main.cpp.

                                           {
        int n = fileArray.size();
        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());
            }
        }
        printf("\n");
    }

printContents() [2/2]

void DiffSummary::printContents ( const FileArray &  fileArray, const char *  headerText, bool  listFilenames  )

inline

Definition at line 122 of file skdiff_main.cpp.

                                                                                               {
        int n = fileArray.size();
        printf("%d file pairs %s", n, headerText);
        if (listFilenames) {
            printf(": ");
            for (int i = 0; i < n; ++i) {
                printf("%s ", fileArray[i].c_str());
            }
        }
        printf("\n");
    }

printfFailingBaseNames()

void DiffSummary::printfFailingBaseNames ( const char  separator[] )

inline

Definition at line 159 of file skdiff_main.cpp.

                                                        {
        for (int resultInt = 0; resultInt < DiffRecord::kResultCount; ++resultInt) {
            const StringArray& array = fFailedBaseNames[resultInt];
            if (array.size()) {
                printf("%s [%d]%s", DiffRecord::ResultNames[resultInt], array.size(), separator);
                for (int j = 0; j < array.size(); ++j) {
                    printf("%s%s", array[j].c_str(), separator);
                }
                printf("\n");
            }
        }
    }

printStatus()

void DiffSummary::printStatus ( bool  listFilenames, bool  failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount]  )

inline

Definition at line 96 of file skdiff_main.cpp.

                                                                      {
        typedef DiffResource::Status Status;
 
        for (int base = 0; base < DiffResource::kStatusCount; ++base) {
            Status baseStatus = static_cast<Status>(base);
            for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
                Status comparisonStatus = static_cast<Status>(comparison);
                const FileArray& fileArray = fStatusOfType[base][comparison];
                if (fileArray.size() > 0) {
                    if (failOnStatusType[base][comparison]) {
                        printf("   [*] ");
                    } else {
                        printf("   [_] ");
                    }
                    printContents(fileArray,
                                  DiffResource::getStatusDescription(baseStatus),
                                  DiffResource::getStatusDescription(comparisonStatus),
                                  listFilenames);
                }
            }
        }
    }

Member Data Documentation

fFailedBaseNames

StringArray DiffSummary::fFailedBaseNames[DiffRecord::kResultCount]

Definition at line 79 of file skdiff_main.cpp.

fMaxMismatchPercent

float DiffSummary::fMaxMismatchPercent

Definition at line 74 of file skdiff_main.cpp.

fMaxMismatchV

uint32_t DiffSummary::fMaxMismatchV

Definition at line 73 of file skdiff_main.cpp.

fNumMatches

uint32_t DiffSummary::fNumMatches

Definition at line 71 of file skdiff_main.cpp.

fNumMismatches

uint32_t DiffSummary::fNumMismatches

Definition at line 72 of file skdiff_main.cpp.

fResultsOfType

FileArray DiffSummary::fResultsOfType[DiffRecord::kResultCount]

Definition at line 76 of file skdiff_main.cpp.

fStatusOfType

FileArray DiffSummary::fStatusOfType[DiffResource::kStatusCount][DiffResource::kStatusCount]

Definition at line 77 of file skdiff_main.cpp.

---

The documentation for this struct was generated from the following file:

• third_party/skia/tools/skdiff/skdiff_main.cpp