OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2013 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 #include "Test.h" | 8 #include "Test.h" |
9 | 9 |
10 #include "SkBitmap.h" | 10 #include "SkBitmap.h" |
11 #include "SkBitmapChecksummer.h" | 11 #include "SkBitmapHasher.h" |
12 #include "SkChecksum.h" | |
13 #include "SkCityHash.h" | |
14 #include "SkColor.h" | 12 #include "SkColor.h" |
15 | 13 |
16 // Word size that is large enough to hold results of any checksum type. | 14 // Word size that is large enough to hold results of any checksum type. |
17 typedef uint64_t checksum_result; | 15 typedef uint64_t checksum_result; |
18 | 16 |
19 namespace skiatest { | 17 namespace skiatest { |
20 class ChecksumTestClass : public Test { | 18 class BitmapHasherTestClass : public Test { |
21 public: | 19 public: |
22 static Test* Factory(void*) {return SkNEW(ChecksumTestClass); } | 20 static Test* Factory(void*) {return SkNEW(BitmapHasherTestClass); } |
23 protected: | 21 protected: |
24 virtual void onGetName(SkString* name) { name->set("Checksum"); } | 22 virtual void onGetName(SkString* name) { name->set("BitmapHasher"); } |
25 virtual void onRun(Reporter* reporter) { | 23 virtual void onRun(Reporter* reporter) { |
26 this->fReporter = reporter; | 24 this->fReporter = reporter; |
27 RunTest(); | 25 RunTest(); |
28 } | 26 } |
29 private: | 27 private: |
30 enum Algorithm { | |
31 kSkChecksum, | |
32 kSkCityHash32, | |
33 kSkCityHash64 | |
34 }; | |
35 | |
36 // Call Compute(data, size) on the appropriate checksum algorithm, | |
37 // depending on this->fWhichAlgorithm. | |
38 checksum_result ComputeChecksum(const char *data, size_t size) { | |
39 switch(fWhichAlgorithm) { | |
40 case kSkChecksum: | |
41 REPORTER_ASSERT_MESSAGE(fReporter, | |
42 reinterpret_cast<uintptr_t>(data) % 4 ==
0, | |
43 "test data pointer is not 32-bit aligned
"); | |
44 REPORTER_ASSERT_MESSAGE(fReporter, SkIsAlign4(size), | |
45 "test data size is not 32-bit aligned"); | |
46 return SkChecksum::Compute(reinterpret_cast<const uint32_t *>(da
ta), size); | |
47 case kSkCityHash32: | |
48 return SkCityHash::Compute32(data, size); | |
49 case kSkCityHash64: | |
50 return SkCityHash::Compute64(data, size); | |
51 default: | |
52 SkString message("fWhichAlgorithm has unknown value "); | |
53 message.appendf("%d", fWhichAlgorithm); | |
54 fReporter->reportFailed(message); | |
55 } | |
56 // we never get here | |
57 return 0; | |
58 } | |
59 | |
60 // Confirm that the checksum algorithm (specified by fWhichAlgorithm) | |
61 // generates the same results if called twice over the same data. | |
62 void TestChecksumSelfConsistency(size_t buf_size) { | |
63 SkAutoMalloc storage(buf_size); | |
64 char* ptr = reinterpret_cast<char *>(storage.get()); | |
65 | |
66 REPORTER_ASSERT(fReporter, | |
67 GetTestDataChecksum(8, 0) == | |
68 GetTestDataChecksum(8, 0)); | |
69 REPORTER_ASSERT(fReporter, | |
70 GetTestDataChecksum(8, 0) != | |
71 GetTestDataChecksum(8, 1)); | |
72 | |
73 sk_bzero(ptr, buf_size); | |
74 checksum_result prev = 0; | |
75 | |
76 // assert that as we change values (from 0 to non-zero) in | |
77 // our buffer, we get a different value | |
78 for (size_t i = 0; i < buf_size; ++i) { | |
79 ptr[i] = (i & 0x7f) + 1; // need some non-zero value here | |
80 | |
81 // Try checksums of different-sized chunks, but always | |
82 // 32-bit aligned and big enough to contain all the | |
83 // nonzero bytes. (Remaining bytes will still be zero | |
84 // from the initial sk_bzero() call.) | |
85 size_t checksum_size = (((i/4)+1)*4); | |
86 REPORTER_ASSERT(fReporter, checksum_size <= buf_size); | |
87 | |
88 checksum_result curr = ComputeChecksum(ptr, checksum_size); | |
89 REPORTER_ASSERT(fReporter, prev != curr); | |
90 checksum_result again = ComputeChecksum(ptr, checksum_size); | |
91 REPORTER_ASSERT(fReporter, again == curr); | |
92 prev = curr; | |
93 } | |
94 } | |
95 | |
96 // Return the checksum of a buffer of bytes 'len' long. | |
97 // The pattern of values within the buffer will be consistent | |
98 // for every call, based on 'seed'. | |
99 checksum_result GetTestDataChecksum(size_t len, char seed=0) { | |
100 SkAutoMalloc storage(len); | |
101 char* start = reinterpret_cast<char *>(storage.get()); | |
102 char* ptr = start; | |
103 for (size_t i = 0; i < len; ++i) { | |
104 *ptr++ = ((seed+i) & 0x7f); | |
105 } | |
106 checksum_result result = ComputeChecksum(start, len); | |
107 return result; | |
108 } | |
109 | 28 |
110 // Fill in bitmap with test data. | 29 // Fill in bitmap with test data. |
111 void CreateTestBitmap(SkBitmap &bitmap, SkBitmap::Config config, int wid
th, int height, | 30 void CreateTestBitmap(SkBitmap &bitmap, SkBitmap::Config config, int wid
th, int height, |
112 SkColor color) { | 31 SkColor color) { |
113 bitmap.setConfig(config, width, height); | 32 bitmap.setConfig(config, width, height); |
114 REPORTER_ASSERT(fReporter, bitmap.allocPixels()); | 33 REPORTER_ASSERT(fReporter, bitmap.allocPixels()); |
115 bitmap.setIsOpaque(true); | 34 bitmap.setIsOpaque(true); |
116 bitmap.eraseColor(color); | 35 bitmap.eraseColor(color); |
117 } | 36 } |
118 | 37 |
119 void RunTest() { | 38 void RunTest() { |
120 // Test self-consistency of checksum algorithms. | 39 // Test SkBitmapHasher |
121 fWhichAlgorithm = kSkChecksum; | |
122 TestChecksumSelfConsistency(128); | |
123 fWhichAlgorithm = kSkCityHash32; | |
124 TestChecksumSelfConsistency(128); | |
125 fWhichAlgorithm = kSkCityHash64; | |
126 TestChecksumSelfConsistency(128); | |
127 | |
128 // Test checksum results that should be consistent across | |
129 // versions and platforms. | |
130 fWhichAlgorithm = kSkChecksum; | |
131 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0); | |
132 fWhichAlgorithm = kSkCityHash32; | |
133 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0xdc56d17a); | |
134 REPORTER_ASSERT(fReporter, GetTestDataChecksum(4) == 0x616e1132); | |
135 REPORTER_ASSERT(fReporter, GetTestDataChecksum(8) == 0xeb0fd2d6); | |
136 REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x5321e430); | |
137 REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x924a10e4); | |
138 REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xd4de9dc9); | |
139 REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0xecf0325d); | |
140 fWhichAlgorithm = kSkCityHash64; | |
141 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0x9ae16a3b2f9
0404fULL); | |
142 REPORTER_ASSERT(fReporter, GetTestDataChecksum(4) == 0x82bffd89895
8e540ULL); | |
143 REPORTER_ASSERT(fReporter, GetTestDataChecksum(8) == 0xad5a13e1e8e
93b98ULL); | |
144 REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x10b153630af
1f395ULL); | |
145 REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x7db71dc4adc
c6647ULL); | |
146 REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xeee763519b9
1b010ULL); | |
147 REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0x2fe19e0b223
9bc23ULL); | |
148 | |
149 // TODO: note the weakness exposed by these collisions... | |
150 // We need to improve the SkChecksum algorithm. | |
151 // We would prefer that these asserts FAIL! | |
152 // Filed as https://code.google.com/p/skia/issues/detail?id=981 | |
153 // ('SkChecksum algorithm allows for way too many collisions') | |
154 fWhichAlgorithm = kSkChecksum; | |
155 REPORTER_ASSERT(fReporter, | |
156 GetTestDataChecksum(128) == GetTestDataChecksum(256)); | |
157 REPORTER_ASSERT(fReporter, | |
158 GetTestDataChecksum(132) == GetTestDataChecksum(260)); | |
159 | |
160 // Test SkBitmapChecksummer | |
161 SkBitmap bitmap; | 40 SkBitmap bitmap; |
| 41 SkHashDigest digest; |
162 // initial test case | 42 // initial test case |
163 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 333, 555, SK_C
olorBLUE); | 43 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 333, 555, SK_C
olorBLUE); |
164 REPORTER_ASSERT(fReporter, | 44 REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &di
gest)); |
165 SkBitmapChecksummer::Compute64(bitmap) == 0x18f9df68
b1b02f38ULL); | 45 REPORTER_ASSERT(fReporter, digest == 0x18f9df68b1b02f38ULL); |
166 // same pixel data but different dimensions should yield a different
checksum | 46 // same pixel data but different dimensions should yield a different
checksum |
167 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_C
olorBLUE); | 47 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_C
olorBLUE); |
168 REPORTER_ASSERT(fReporter, | 48 REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &di
gest)); |
169 SkBitmapChecksummer::Compute64(bitmap) == 0x6b029818
3f786c8eULL); | 49 REPORTER_ASSERT(fReporter, digest == 0x6b0298183f786c8eULL); |
170 // same dimensions but different color should yield a different chec
ksum | 50 // same dimensions but different color should yield a different chec
ksum |
171 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_C
olorGREEN); | 51 CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_C
olorGREEN); |
172 REPORTER_ASSERT(fReporter, | 52 REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &di
gest)); |
173 SkBitmapChecksummer::Compute64(bitmap) == 0xc6b4b3f6
fadaaf37ULL); | 53 REPORTER_ASSERT(fReporter, digest == 0xc6b4b3f6fadaaf37ULL); |
174 // same pixel colors in a different config should yield the same che
cksum | 54 // same pixel colors in a different config should yield the same che
cksum |
175 CreateTestBitmap(bitmap, SkBitmap::kARGB_4444_Config, 555, 333, SK_C
olorGREEN); | 55 CreateTestBitmap(bitmap, SkBitmap::kARGB_4444_Config, 555, 333, SK_C
olorGREEN); |
176 REPORTER_ASSERT(fReporter, | 56 REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &di
gest)); |
177 SkBitmapChecksummer::Compute64(bitmap) == 0xc6b4b3f6
fadaaf37ULL); | 57 REPORTER_ASSERT(fReporter, digest == 0xc6b4b3f6fadaaf37ULL); |
178 } | 58 } |
179 | 59 |
180 Reporter* fReporter; | 60 Reporter* fReporter; |
181 Algorithm fWhichAlgorithm; | |
182 }; | 61 }; |
183 | 62 |
184 static TestRegistry gReg(ChecksumTestClass::Factory); | 63 static TestRegistry gReg(BitmapHasherTestClass::Factory); |
185 } | 64 } |
OLD | NEW |