OLD | NEW |
| (Empty) |
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 * TODO(epoger): Combine this with tools/image_expectations.cpp, or eliminate on
e of the two. | |
8 */ | |
9 | |
10 #include "gm_expectations.h" | |
11 #include "SkBitmapHasher.h" | |
12 #include "SkData.h" | |
13 #include "SkImageDecoder.h" | |
14 | |
15 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message") | |
16 | |
17 // See gm_json.py for descriptions of each of these JSON keys. | |
18 // These constants must be kept in sync with the ones in that Python file! | |
19 const static char kJsonKey_ActualResults[] = "actual-results"; | |
20 const static char kJsonKey_ActualResults_Failed[] = "failed"; | |
21 const static char kJsonKey_ActualResults_FailureIgnored[]= "failure-ignored"; | |
22 const static char kJsonKey_ActualResults_NoComparison[] = "no-comparison"; | |
23 const static char kJsonKey_ActualResults_Succeeded[] = "succeeded"; | |
24 const static char kJsonKey_ExpectedResults[] = "expected-results"; | |
25 const static char kJsonKey_ExpectedResults_AllowedDigests[] = "allowed-digests"; | |
26 const static char kJsonKey_ExpectedResults_IgnoreFailure[] = "ignore-failure"; | |
27 | |
28 // Types of result hashes we support in the JSON file. | |
29 const static char kJsonKey_Hashtype_Bitmap_64bitMD5[] = "bitmap-64bitMD5"; | |
30 | |
31 | |
32 namespace skiagm { | |
33 | |
34 Json::Value CreateJsonTree(Json::Value expectedResults, | |
35 Json::Value actualResultsFailed, | |
36 Json::Value actualResultsFailureIgnored, | |
37 Json::Value actualResultsNoComparison, | |
38 Json::Value actualResultsSucceeded) { | |
39 Json::Value actualResults; | |
40 actualResults[kJsonKey_ActualResults_Failed] = actualResultsFailed; | |
41 actualResults[kJsonKey_ActualResults_FailureIgnored] = actualResultsFail
ureIgnored; | |
42 actualResults[kJsonKey_ActualResults_NoComparison] = actualResultsNoComp
arison; | |
43 actualResults[kJsonKey_ActualResults_Succeeded] = actualResultsSucceeded
; | |
44 Json::Value root; | |
45 root[kJsonKey_ActualResults] = actualResults; | |
46 root[kJsonKey_ExpectedResults] = expectedResults; | |
47 return root; | |
48 } | |
49 | |
50 // GmResultDigest class... | |
51 | |
52 GmResultDigest::GmResultDigest(const SkBitmap &bitmap) { | |
53 fIsValid = SkBitmapHasher::ComputeDigest(bitmap, &fHashDigest); | |
54 } | |
55 | |
56 GmResultDigest::GmResultDigest(const Json::Value &jsonTypeValuePair) { | |
57 fIsValid = false; | |
58 if (!jsonTypeValuePair.isArray()) { | |
59 SkDebugf("found non-array json value when parsing GmResultDigest: %s
\n", | |
60 jsonTypeValuePair.toStyledString().c_str()); | |
61 DEBUGFAIL_SEE_STDERR; | |
62 } else if (2 != jsonTypeValuePair.size()) { | |
63 SkDebugf("found json array with wrong size when parsing GmResultDige
st: %s\n", | |
64 jsonTypeValuePair.toStyledString().c_str()); | |
65 DEBUGFAIL_SEE_STDERR; | |
66 } else { | |
67 // TODO(epoger): The current implementation assumes that the | |
68 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 | |
69 Json::Value jsonHashValue = jsonTypeValuePair[1]; | |
70 if (!jsonHashValue.isIntegral()) { | |
71 SkDebugf("found non-integer jsonHashValue when parsing GmResultD
igest: %s\n", | |
72 jsonTypeValuePair.toStyledString().c_str()); | |
73 DEBUGFAIL_SEE_STDERR; | |
74 } else { | |
75 fHashDigest = jsonHashValue.asUInt64(); | |
76 fIsValid = true; | |
77 } | |
78 } | |
79 } | |
80 | |
81 bool GmResultDigest::isValid() const { | |
82 return fIsValid; | |
83 } | |
84 | |
85 bool GmResultDigest::equals(const GmResultDigest &other) const { | |
86 // TODO(epoger): The current implementation assumes that this | |
87 // and other are always of type kJsonKey_Hashtype_Bitmap_64bitMD5 | |
88 return (this->fIsValid && other.fIsValid && (this->fHashDigest == other.
fHashDigest)); | |
89 } | |
90 | |
91 Json::Value GmResultDigest::asJsonTypeValuePair() const { | |
92 // TODO(epoger): The current implementation assumes that the | |
93 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 | |
94 Json::Value jsonTypeValuePair; | |
95 if (fIsValid) { | |
96 jsonTypeValuePair.append(Json::Value(kJsonKey_Hashtype_Bitmap_64bitM
D5)); | |
97 jsonTypeValuePair.append(Json::UInt64(fHashDigest)); | |
98 } else { | |
99 jsonTypeValuePair.append(Json::Value("INVALID")); | |
100 } | |
101 return jsonTypeValuePair; | |
102 } | |
103 | |
104 SkString GmResultDigest::getHashType() const { | |
105 // TODO(epoger): The current implementation assumes that the | |
106 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 | |
107 return SkString(kJsonKey_Hashtype_Bitmap_64bitMD5); | |
108 } | |
109 | |
110 SkString GmResultDigest::getDigestValue() const { | |
111 // TODO(epoger): The current implementation assumes that the | |
112 // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5 | |
113 SkString retval; | |
114 retval.appendU64(fHashDigest); | |
115 return retval; | |
116 } | |
117 | |
118 | |
119 // Expectations class... | |
120 | |
121 Expectations::Expectations(bool ignoreFailure) { | |
122 fIgnoreFailure = ignoreFailure; | |
123 } | |
124 | |
125 Expectations::Expectations(const SkBitmap& bitmap, bool ignoreFailure) { | |
126 fBitmap = bitmap; | |
127 fIgnoreFailure = ignoreFailure; | |
128 fAllowedResultDigests.push_back(GmResultDigest(bitmap)); | |
129 } | |
130 | |
131 Expectations::Expectations(const BitmapAndDigest& bitmapAndDigest) { | |
132 fBitmap = bitmapAndDigest.fBitmap; | |
133 fIgnoreFailure = false; | |
134 fAllowedResultDigests.push_back(bitmapAndDigest.fDigest); | |
135 } | |
136 | |
137 Expectations::Expectations(Json::Value jsonElement) { | |
138 if (jsonElement.empty()) { | |
139 fIgnoreFailure = kDefaultIgnoreFailure; | |
140 } else { | |
141 Json::Value ignoreFailure = jsonElement[kJsonKey_ExpectedResults_Ign
oreFailure]; | |
142 if (ignoreFailure.isNull()) { | |
143 fIgnoreFailure = kDefaultIgnoreFailure; | |
144 } else if (!ignoreFailure.isBool()) { | |
145 SkDebugf("found non-boolean json value for key '%s' in element '
%s'\n", | |
146 kJsonKey_ExpectedResults_IgnoreFailure, | |
147 jsonElement.toStyledString().c_str()); | |
148 DEBUGFAIL_SEE_STDERR; | |
149 fIgnoreFailure = kDefaultIgnoreFailure; | |
150 } else { | |
151 fIgnoreFailure = ignoreFailure.asBool(); | |
152 } | |
153 | |
154 Json::Value allowedDigests = jsonElement[kJsonKey_ExpectedResults_Al
lowedDigests]; | |
155 if (allowedDigests.isNull()) { | |
156 // ok, we'll just assume there aren't any AllowedDigests to comp
are against | |
157 } else if (!allowedDigests.isArray()) { | |
158 SkDebugf("found non-array json value for key '%s' in element '%s
'\n", | |
159 kJsonKey_ExpectedResults_AllowedDigests, | |
160 jsonElement.toStyledString().c_str()); | |
161 DEBUGFAIL_SEE_STDERR; | |
162 } else { | |
163 for (Json::ArrayIndex i=0; i<allowedDigests.size(); i++) { | |
164 fAllowedResultDigests.push_back(GmResultDigest(allowedDigest
s[i])); | |
165 } | |
166 } | |
167 } | |
168 } | |
169 | |
170 bool Expectations::match(GmResultDigest actualGmResultDigest) const { | |
171 for (int i=0; i < this->fAllowedResultDigests.count(); i++) { | |
172 GmResultDigest allowedResultDigest = this->fAllowedResultDigests[i]; | |
173 if (allowedResultDigest.equals(actualGmResultDigest)) { | |
174 return true; | |
175 } | |
176 } | |
177 return false; | |
178 } | |
179 | |
180 Json::Value Expectations::asJsonValue() const { | |
181 Json::Value allowedDigestArray; | |
182 if (!this->fAllowedResultDigests.empty()) { | |
183 for (int i=0; i < this->fAllowedResultDigests.count(); i++) { | |
184 allowedDigestArray.append(this->fAllowedResultDigests[i].asJsonT
ypeValuePair()); | |
185 } | |
186 } | |
187 | |
188 Json::Value jsonExpectations; | |
189 jsonExpectations[kJsonKey_ExpectedResults_AllowedDigests] = allowedDiges
tArray; | |
190 jsonExpectations[kJsonKey_ExpectedResults_IgnoreFailure] = this->ignore
Failure(); | |
191 return jsonExpectations; | |
192 } | |
193 | |
194 // IndividualImageExpectationsSource class... | |
195 | |
196 Expectations IndividualImageExpectationsSource::get(const char *testName) co
nst { | |
197 SkString path = SkOSPath::Join(fRootDir.c_str(), testName); | |
198 SkBitmap referenceBitmap; | |
199 bool decodedReferenceBitmap = | |
200 SkImageDecoder::DecodeFile(path.c_str(), &referenceBitmap, kN32_SkCo
lorType, | |
201 SkImageDecoder::kDecodePixels_Mode, NULL)
; | |
202 if (decodedReferenceBitmap) { | |
203 return Expectations(referenceBitmap); | |
204 } else { | |
205 return Expectations(); | |
206 } | |
207 } | |
208 | |
209 | |
210 // JsonExpectationsSource class... | |
211 | |
212 JsonExpectationsSource::JsonExpectationsSource(const char *jsonPath) { | |
213 Parse(jsonPath, &fJsonRoot); | |
214 fJsonExpectedResults = fJsonRoot[kJsonKey_ExpectedResults]; | |
215 } | |
216 | |
217 Expectations JsonExpectationsSource::get(const char *testName) const { | |
218 return Expectations(fJsonExpectedResults[testName]); | |
219 } | |
220 | |
221 /*static*/ bool JsonExpectationsSource::Parse(const char *jsonPath, Json::Va
lue *jsonRoot) { | |
222 SkAutoDataUnref dataRef(SkData::NewFromFileName(jsonPath)); | |
223 if (NULL == dataRef.get()) { | |
224 SkDebugf("error reading JSON file %s\n", jsonPath); | |
225 DEBUGFAIL_SEE_STDERR; | |
226 return false; | |
227 } | |
228 | |
229 const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data()
); | |
230 size_t size = dataRef.get()->size(); | |
231 Json::Reader reader; | |
232 if (!reader.parse(bytes, bytes+size, *jsonRoot)) { | |
233 SkDebugf("error parsing JSON file %s\n", jsonPath); | |
234 DEBUGFAIL_SEE_STDERR; | |
235 return false; | |
236 } | |
237 return true; | |
238 } | |
239 } | |
OLD | NEW |