OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2012 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 "SkChecksum.h" | 10 #include "SkChecksum.h" |
11 #include "SkCityHash.h" | |
12 | 11 |
13 // Word size that is large enough to hold results of any checksum type. | 12 // Word size that is large enough to hold results of any checksum type. |
14 typedef uint64_t checksum_result; | 13 typedef uint64_t checksum_result; |
15 | 14 |
16 namespace skiatest { | 15 namespace skiatest { |
17 class ChecksumTestClass : public Test { | 16 class ChecksumTestClass : public Test { |
18 public: | 17 public: |
19 static Test* Factory(void*) {return SkNEW(ChecksumTestClass); } | 18 static Test* Factory(void*) {return SkNEW(ChecksumTestClass); } |
20 protected: | 19 protected: |
21 virtual void onGetName(SkString* name) { name->set("Checksum"); } | 20 virtual void onGetName(SkString* name) { name->set("Checksum"); } |
22 virtual void onRun(Reporter* reporter) { | 21 virtual void onRun(Reporter* reporter) { |
23 this->fReporter = reporter; | 22 this->fReporter = reporter; |
24 RunTest(); | 23 RunTest(); |
25 } | 24 } |
26 private: | 25 private: |
27 enum Algorithm { | 26 enum Algorithm { |
28 kSkChecksum, | 27 kSkChecksum |
29 kSkCityHash32, | |
30 kSkCityHash64 | |
31 }; | 28 }; |
32 | 29 |
33 // Call Compute(data, size) on the appropriate checksum algorithm, | 30 // Call Compute(data, size) on the appropriate checksum algorithm, |
34 // depending on this->fWhichAlgorithm. | 31 // depending on this->fWhichAlgorithm. |
35 checksum_result ComputeChecksum(const char *data, size_t size) { | 32 checksum_result ComputeChecksum(const char *data, size_t size) { |
36 switch(fWhichAlgorithm) { | 33 switch(fWhichAlgorithm) { |
37 case kSkChecksum: | 34 case kSkChecksum: |
38 REPORTER_ASSERT_MESSAGE(fReporter, | 35 REPORTER_ASSERT_MESSAGE(fReporter, |
39 reinterpret_cast<uintptr_t>(data) % 4 ==
0, | 36 reinterpret_cast<uintptr_t>(data) % 4 ==
0, |
40 "test data pointer is not 32-bit aligned
"); | 37 "test data pointer is not 32-bit aligned
"); |
41 REPORTER_ASSERT_MESSAGE(fReporter, SkIsAlign4(size), | 38 REPORTER_ASSERT_MESSAGE(fReporter, SkIsAlign4(size), |
42 "test data size is not 32-bit aligned"); | 39 "test data size is not 32-bit aligned"); |
43 return SkChecksum::Compute(reinterpret_cast<const uint32_t *>(da
ta), size); | 40 return SkChecksum::Compute(reinterpret_cast<const uint32_t *>(da
ta), size); |
44 case kSkCityHash32: | |
45 return SkCityHash::Compute32(data, size); | |
46 case kSkCityHash64: | |
47 return SkCityHash::Compute64(data, size); | |
48 default: | 41 default: |
49 SkString message("fWhichAlgorithm has unknown value "); | 42 SkString message("fWhichAlgorithm has unknown value "); |
50 message.appendf("%d", fWhichAlgorithm); | 43 message.appendf("%d", fWhichAlgorithm); |
51 fReporter->reportFailed(message); | 44 fReporter->reportFailed(message); |
52 } | 45 } |
53 // we never get here | 46 // we never get here |
54 return 0; | 47 return 0; |
55 } | 48 } |
56 | 49 |
57 // Confirm that the checksum algorithm (specified by fWhichAlgorithm) | 50 // Confirm that the checksum algorithm (specified by fWhichAlgorithm) |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 *ptr++ = ((seed+i) & 0x7f); | 94 *ptr++ = ((seed+i) & 0x7f); |
102 } | 95 } |
103 checksum_result result = ComputeChecksum(start, len); | 96 checksum_result result = ComputeChecksum(start, len); |
104 return result; | 97 return result; |
105 } | 98 } |
106 | 99 |
107 void RunTest() { | 100 void RunTest() { |
108 // Test self-consistency of checksum algorithms. | 101 // Test self-consistency of checksum algorithms. |
109 fWhichAlgorithm = kSkChecksum; | 102 fWhichAlgorithm = kSkChecksum; |
110 TestChecksumSelfConsistency(128); | 103 TestChecksumSelfConsistency(128); |
111 fWhichAlgorithm = kSkCityHash32; | |
112 TestChecksumSelfConsistency(128); | |
113 fWhichAlgorithm = kSkCityHash64; | |
114 TestChecksumSelfConsistency(128); | |
115 | 104 |
116 // Test checksum results that should be consistent across | 105 // Test checksum results that should be consistent across |
117 // versions and platforms. | 106 // versions and platforms. |
118 fWhichAlgorithm = kSkChecksum; | 107 fWhichAlgorithm = kSkChecksum; |
119 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0); | 108 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0); |
120 fWhichAlgorithm = kSkCityHash32; | |
121 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0xdc56d17a); | |
122 REPORTER_ASSERT(fReporter, GetTestDataChecksum(4) == 0x616e1132); | |
123 REPORTER_ASSERT(fReporter, GetTestDataChecksum(8) == 0xeb0fd2d6); | |
124 REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x5321e430); | |
125 REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x924a10e4); | |
126 REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xd4de9dc9); | |
127 REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0xecf0325d); | |
128 fWhichAlgorithm = kSkCityHash64; | |
129 REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0x9ae16a3b2f9
0404fULL); | |
130 REPORTER_ASSERT(fReporter, GetTestDataChecksum(4) == 0x82bffd89895
8e540ULL); | |
131 REPORTER_ASSERT(fReporter, GetTestDataChecksum(8) == 0xad5a13e1e8e
93b98ULL); | |
132 REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x10b153630af
1f395ULL); | |
133 REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x7db71dc4adc
c6647ULL); | |
134 REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xeee763519b9
1b010ULL); | |
135 REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0x2fe19e0b223
9bc23ULL); | |
136 | 109 |
137 // TODO: note the weakness exposed by these collisions... | 110 // TODO: note the weakness exposed by these collisions... |
138 // We need to improve the SkChecksum algorithm. | 111 // We need to improve the SkChecksum algorithm. |
139 // We would prefer that these asserts FAIL! | 112 // We would prefer that these asserts FAIL! |
140 // Filed as https://code.google.com/p/skia/issues/detail?id=981 | 113 // Filed as https://code.google.com/p/skia/issues/detail?id=981 |
141 // ('SkChecksum algorithm allows for way too many collisions') | 114 // ('SkChecksum algorithm allows for way too many collisions') |
142 fWhichAlgorithm = kSkChecksum; | 115 fWhichAlgorithm = kSkChecksum; |
143 REPORTER_ASSERT(fReporter, | 116 REPORTER_ASSERT(fReporter, |
144 GetTestDataChecksum(128) == GetTestDataChecksum(256)); | 117 GetTestDataChecksum(128) == GetTestDataChecksum(256)); |
145 REPORTER_ASSERT(fReporter, | 118 REPORTER_ASSERT(fReporter, |
146 GetTestDataChecksum(132) == GetTestDataChecksum(260)); | 119 GetTestDataChecksum(132) == GetTestDataChecksum(260)); |
147 } | 120 } |
148 | 121 |
149 Reporter* fReporter; | 122 Reporter* fReporter; |
150 Algorithm fWhichAlgorithm; | 123 Algorithm fWhichAlgorithm; |
151 }; | 124 }; |
152 | 125 |
153 static TestRegistry gReg(ChecksumTestClass::Factory); | 126 static TestRegistry gReg(ChecksumTestClass::Factory); |
154 } | 127 } |
OLD | NEW |