1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "gm_expectations.h" 9 #include "SkBitmapHasher.h" 10 #include "SkImageDecoder.h" 11 12 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message") 13 14 // See gm_json.py for descriptions of each of these JSON keys. 15 // These constants must be kept in sync with the ones in that Python file! 16 const static char kJsonKey_ActualResults[] = "actual-results"; 17 const static char kJsonKey_ActualResults_Failed[] = "failed"; 18 const static char kJsonKey_ActualResults_FailureIgnored[]= "failure-ignored"; 19 const static char kJsonKey_ActualResults_NoComparison[] = "no-comparison"; 20 const static char kJsonKey_ActualResults_Succeeded[] = "succeeded"; 21 const static char kJsonKey_ExpectedResults[] = "expected-results"; 22 const static char kJsonKey_ExpectedResults_AllowedDigests[] = "allowed-digests"; 23 const static char kJsonKey_ExpectedResults_IgnoreFailure[] = "ignore-failure"; 24 25 // Types of result hashes we support in the JSON file. 26 const static char kJsonKey_Hashtype_Bitmap_64bitMD5[] = "bitmap-64bitMD5"; 27 28 29 namespace skiagm { 30 SK_DEFINE_INST_COUNT(ExpectationsSource) 31 32 void gm_fprintf(FILE *stream, const char format[], ...) { 33 va_list args; 34 va_start(args, format); 35 fprintf(stream, "GM: "); 36 vfprintf(stream, format, args); 37 va_end(args); 38 } 39 40 Json::Value CreateJsonTree(Json::Value expectedResults, 41 Json::Value actualResultsFailed, 42 Json::Value actualResultsFailureIgnored, 43 Json::Value actualResultsNoComparison, 44 Json::Value actualResultsSucceeded) { 45 Json::Value actualResults; 46 actualResults[kJsonKey_ActualResults_Failed] = actualResultsFailed; 47 actualResults[kJsonKey_ActualResults_FailureIgnored] = actualResultsFailureIgnored; 48 actualResults[kJsonKey_ActualResults_NoComparison] = actualResultsNoComparison; 49 actualResults[kJsonKey_ActualResults_Succeeded] = actualResultsSucceeded; 50 Json::Value root; 51 root[kJsonKey_ActualResults] = actualResults; 52 root[kJsonKey_ExpectedResults] = expectedResults; 53 return root; 54 } 55 56 57 // GmResultDigest class... 58 59 GmResultDigest::GmResultDigest(const SkBitmap &bitmap) { 60 fIsValid = SkBitmapHasher::ComputeDigest(bitmap, &fHashDigest); 61 } 62 63 GmResultDigest::GmResultDigest(const Json::Value &jsonTypeValuePair) { 64 fIsValid = false; 65 if (!jsonTypeValuePair.isArray()) { 66 gm_fprintf(stderr, "found non-array json value when parsing GmResultDigest: %s\n", 67 jsonTypeValuePair.toStyledString().c_str()); 68 DEBUGFAIL_SEE_STDERR; 69 } else if (2 != jsonTypeValuePair.size()) { 70 gm_fprintf(stderr, "found json array with wrong size when parsing GmResultDigest: %s\n", 71 jsonTypeValuePair.toStyledString().c_str()); 72 DEBUGFAIL_SEE_STDERR; 73 } else { 74 // TODO(epoger): The current implementation assumes that the 75 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 76 Json::Value jsonHashValue = jsonTypeValuePair[1]; 77 if (!jsonHashValue.isIntegral()) { 78 gm_fprintf(stderr, 79 "found non-integer jsonHashValue when parsing GmResultDigest: %s\n", 80 jsonTypeValuePair.toStyledString().c_str()); 81 DEBUGFAIL_SEE_STDERR; 82 } else { 83 fHashDigest = jsonHashValue.asUInt64(); 84 fIsValid = true; 85 } 86 } 87 } 88 89 bool GmResultDigest::isValid() const { 90 return fIsValid; 91 } 92 93 bool GmResultDigest::equals(const GmResultDigest &other) const { 94 // TODO(epoger): The current implementation assumes that this 95 // and other are always of type kJsonKey_Hashtype_Bitmap_64bitMD5 96 return (this->fIsValid && other.fIsValid && (this->fHashDigest == other.fHashDigest)); 97 } 98 99 Json::Value GmResultDigest::asJsonTypeValuePair() const { 100 // TODO(epoger): The current implementation assumes that the 101 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 102 Json::Value jsonTypeValuePair; 103 if (fIsValid) { 104 jsonTypeValuePair.append(Json::Value(kJsonKey_Hashtype_Bitmap_64bitMD5)); 105 jsonTypeValuePair.append(Json::UInt64(fHashDigest)); 106 } else { 107 jsonTypeValuePair.append(Json::Value("INVALID")); 108 } 109 return jsonTypeValuePair; 110 } 111 112 SkString GmResultDigest::getHashType() const { 113 // TODO(epoger): The current implementation assumes that the 114 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 115 return SkString(kJsonKey_Hashtype_Bitmap_64bitMD5); 116 } 117 118 SkString GmResultDigest::getDigestValue() const { 119 // TODO(epoger): The current implementation assumes that the 120 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 121 SkString retval; 122 retval.appendU64(fHashDigest); 123 return retval; 124 } 125 126 127 // Expectations class... 128 129 Expectations::Expectations(bool ignoreFailure) { 130 fIgnoreFailure = ignoreFailure; 131 } 132 133 Expectations::Expectations(const SkBitmap& bitmap, bool ignoreFailure) { 134 fBitmap = bitmap; 135 fIgnoreFailure = ignoreFailure; 136 fAllowedResultDigests.push_back(GmResultDigest(bitmap)); 137 } 138 139 Expectations::Expectations(Json::Value jsonElement) { 140 if (jsonElement.empty()) { 141 fIgnoreFailure = kDefaultIgnoreFailure; 142 } else { 143 Json::Value ignoreFailure = jsonElement[kJsonKey_ExpectedResults_IgnoreFailure]; 144 if (ignoreFailure.isNull()) { 145 fIgnoreFailure = kDefaultIgnoreFailure; 146 } else if (!ignoreFailure.isBool()) { 147 gm_fprintf(stderr, "found non-boolean json value" 148 " for key '%s' in element '%s'\n", 149 kJsonKey_ExpectedResults_IgnoreFailure, 150 jsonElement.toStyledString().c_str()); 151 DEBUGFAIL_SEE_STDERR; 152 fIgnoreFailure = kDefaultIgnoreFailure; 153 } else { 154 fIgnoreFailure = ignoreFailure.asBool(); 155 } 156 157 Json::Value allowedDigests = jsonElement[kJsonKey_ExpectedResults_AllowedDigests]; 158 if (allowedDigests.isNull()) { 159 // ok, we'll just assume there aren't any AllowedDigests to compare against 160 } else if (!allowedDigests.isArray()) { 161 gm_fprintf(stderr, "found non-array json value" 162 " for key '%s' in element '%s'\n", 163 kJsonKey_ExpectedResults_AllowedDigests, 164 jsonElement.toStyledString().c_str()); 165 DEBUGFAIL_SEE_STDERR; 166 } else { 167 for (Json::ArrayIndex i=0; i<allowedDigests.size(); i++) { 168 fAllowedResultDigests.push_back(GmResultDigest(allowedDigests[i])); 169 } 170 } 171 } 172 } 173 174 bool Expectations::match(GmResultDigest actualGmResultDigest) const { 175 for (int i=0; i < this->fAllowedResultDigests.count(); i++) { 176 GmResultDigest allowedResultDigest = this->fAllowedResultDigests[i]; 177 if (allowedResultDigest.equals(actualGmResultDigest)) { 178 return true; 179 } 180 } 181 return false; 182 } 183 184 Json::Value Expectations::asJsonValue() const { 185 Json::Value allowedDigestArray; 186 if (!this->fAllowedResultDigests.empty()) { 187 for (int i=0; i < this->fAllowedResultDigests.count(); i++) { 188 allowedDigestArray.append(this->fAllowedResultDigests[i].asJsonTypeValuePair()); 189 } 190 } 191 192 Json::Value jsonExpectations; 193 jsonExpectations[kJsonKey_ExpectedResults_AllowedDigests] = allowedDigestArray; 194 jsonExpectations[kJsonKey_ExpectedResults_IgnoreFailure] = this->ignoreFailure(); 195 return jsonExpectations; 196 } 197 198 199 // IndividualImageExpectationsSource class... 200 201 Expectations IndividualImageExpectationsSource::get(const char *testName) { 202 SkString path = SkOSPath::SkPathJoin(fRootDir.c_str(), testName); 203 SkBitmap referenceBitmap; 204 bool decodedReferenceBitmap = 205 SkImageDecoder::DecodeFile(path.c_str(), &referenceBitmap, 206 SkBitmap::kARGB_8888_Config, 207 SkImageDecoder::kDecodePixels_Mode, 208 NULL); 209 if (decodedReferenceBitmap) { 210 return Expectations(referenceBitmap); 211 } else { 212 return Expectations(); 213 } 214 } 215 216 217 // JsonExpectationsSource class... 218 219 JsonExpectationsSource::JsonExpectationsSource(const char *jsonPath) { 220 Parse(jsonPath, &fJsonRoot); 221 fJsonExpectedResults = fJsonRoot[kJsonKey_ExpectedResults]; 222 } 223 224 Expectations JsonExpectationsSource::get(const char *testName) { 225 return Expectations(fJsonExpectedResults[testName]); 226 } 227 228 /*static*/ SkData* JsonExpectationsSource::ReadIntoSkData(SkStream &stream, size_t maxBytes) { 229 if (0 == maxBytes) { 230 return SkData::NewEmpty(); 231 } 232 char* bufStart = reinterpret_cast<char *>(sk_malloc_throw(maxBytes)); 233 char* bufPtr = bufStart; 234 size_t bytesRemaining = maxBytes; 235 while (bytesRemaining > 0) { 236 size_t bytesReadThisTime = stream.read(bufPtr, bytesRemaining); 237 if (0 == bytesReadThisTime) { 238 break; 239 } 240 bytesRemaining -= bytesReadThisTime; 241 bufPtr += bytesReadThisTime; 242 } 243 return SkData::NewFromMalloc(bufStart, maxBytes - bytesRemaining); 244 } 245 246 /*static*/ bool JsonExpectationsSource::Parse(const char *jsonPath, Json::Value *jsonRoot) { 247 SkFILEStream inFile(jsonPath); 248 if (!inFile.isValid()) { 249 gm_fprintf(stderr, "unable to read JSON file %s\n", jsonPath); 250 DEBUGFAIL_SEE_STDERR; 251 return false; 252 } 253 254 SkAutoDataUnref dataRef(ReadFileIntoSkData(inFile)); 255 if (NULL == dataRef.get()) { 256 gm_fprintf(stderr, "error reading JSON file %s\n", jsonPath); 257 DEBUGFAIL_SEE_STDERR; 258 return false; 259 } 260 261 const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data()); 262 size_t size = dataRef.get()->size(); 263 Json::Reader reader; 264 if (!reader.parse(bytes, bytes+size, *jsonRoot)) { 265 gm_fprintf(stderr, "error parsing JSON file %s\n", jsonPath); 266 DEBUGFAIL_SEE_STDERR; 267 return false; 268 } 269 return true; 270 } 271 272 } 273