?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[docs] Add LICENSE.txt to the root of the mono-repo
[llvm-project.git] / llvm / unittests / ADT / HashingTest.cpp
blobbb19a569999f2dc3cae4eaff07d4da73c13ff6fd
1 //===- llvm/unittest/ADT/HashingTest.cpp ----------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Hashing.h unit tests.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/ADT/Hashing.h"
14 #include "llvm/Support/DataTypes.h"
15 #include "llvm/Support/HashBuilder.h"
16 #include "gtest/gtest.h"
17 #include <deque>
18 #include <list>
19 #include <map>
20 #include <vector>
21
22 namespace llvm {
23
24 // Helper for test code to print hash codes.
25 void PrintTo(const hash_code &code, std::ostream *os) {
26 *os << static_cast<size_t>(code);
27 }
28
29 // Fake an object that is recognized as hashable data to test super large
30 // objects.
31 struct LargeTestInteger { uint64_t arr[8]; };
32
33 struct NonPOD {
34 uint64_t x, y;
35 NonPOD(uint64_t x, uint64_t y) : x(x), y(y) {}
36 friend hash_code hash_value(const NonPOD &obj) {
37 return hash_combine(obj.x, obj.y);
38 }
39 };
40
41 namespace hashing {
42 namespace detail {
43 template <> struct is_hashable_data<LargeTestInteger> : std::true_type {};
44 } // namespace detail
45 } // namespace hashing
46
47 } // namespace llvm
48
49 using namespace llvm;
50
51 namespace {
52
53 enum TestEnumeration {
54 TE_Foo = 42,
55 TE_Bar = 43
56 };
57
58 TEST(HashingTest, HashValueBasicTest) {
59 int x = 42, y = 43, c = 'x';
60 void *p = nullptr;
61 uint64_t i = 71;
62 const unsigned ci = 71;
63 volatile int vi = 71;
64 const volatile int cvi = 71;
65 uintptr_t addr = reinterpret_cast<uintptr_t>(&y);
66 EXPECT_EQ(hash_value(42), hash_value(x));
67 EXPECT_EQ(hash_value(42), hash_value(TE_Foo));
68 EXPECT_NE(hash_value(42), hash_value(y));
69 EXPECT_NE(hash_value(42), hash_value(TE_Bar));
70 EXPECT_NE(hash_value(42), hash_value(p));
71 EXPECT_EQ(hash_value(71), hash_value(i));
72 EXPECT_EQ(hash_value(71), hash_value(ci));
73 EXPECT_EQ(hash_value(71), hash_value(vi));
74 EXPECT_EQ(hash_value(71), hash_value(cvi));
75 EXPECT_EQ(hash_value(c), hash_value('x'));
76 EXPECT_EQ(hash_value('4'), hash_value('0' + 4));
77 EXPECT_EQ(hash_value(addr), hash_value(&y));
78 }
79
80 TEST(HashingTest, HashValueStdPair) {
81 EXPECT_EQ(hash_combine(42, 43), hash_value(std::make_pair(42, 43)));
82 EXPECT_NE(hash_combine(43, 42), hash_value(std::make_pair(42, 43)));
83 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42ull, 43ull)));
84 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42, 43ull)));
85 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42ull, 43)));
86
87 // Note that pairs are implicitly flattened to a direct sequence of data and
88 // hashed efficiently as a consequence.
89 EXPECT_EQ(hash_combine(42, 43, 44),
90 hash_value(std::make_pair(42, std::make_pair(43, 44))));
91 EXPECT_EQ(hash_value(std::make_pair(42, std::make_pair(43, 44))),
92 hash_value(std::make_pair(std::make_pair(42, 43), 44)));
93
94 // Ensure that pairs which have padding bytes *inside* them don't get treated
95 // this way.
96 EXPECT_EQ(hash_combine('0', hash_combine(1ull, '2')),
97 hash_value(std::make_pair('0', std::make_pair(1ull, '2'))));
98
99 // Ensure that non-POD pairs don't explode the traits used.
100 NonPOD obj1(1, 2), obj2(3, 4), obj3(5, 6);
101 EXPECT_EQ(hash_combine(obj1, hash_combine(obj2, obj3)),
102 hash_value(std::make_pair(obj1, std::make_pair(obj2, obj3))));
103 }
104
105 TEST(HashingTest, HashValueStdTuple) {
106 EXPECT_EQ(hash_combine(), hash_value(std::make_tuple()));
107 EXPECT_EQ(hash_combine(42), hash_value(std::make_tuple(42)));
108 EXPECT_EQ(hash_combine(42, 'c'), hash_value(std::make_tuple(42, 'c')));
109
110 EXPECT_NE(hash_combine(43, 42), hash_value(std::make_tuple(42, 43)));
111 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42ull, 43ull)));
112 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42, 43ull)));
113 EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42ull, 43)));
114 }
115
116 TEST(HashingTest, HashValueStdString) {
117 std::string s = "Hello World!";
118 EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size()), hash_value(s));
119 EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size() - 1),
120 hash_value(s.substr(0, s.size() - 1)));
121 EXPECT_EQ(hash_combine_range(s.c_str() + 1, s.c_str() + s.size() - 1),
122 hash_value(s.substr(1, s.size() - 2)));
123
124 std::wstring ws = L"Hello Wide World!";
125 EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size()),
126 hash_value(ws));
127 EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size() - 1),
128 hash_value(ws.substr(0, ws.size() - 1)));
129 EXPECT_EQ(hash_combine_range(ws.c_str() + 1, ws.c_str() + ws.size() - 1),
130 hash_value(ws.substr(1, ws.size() - 2)));
131 }
132
133 template <typename T, size_t N> T *begin(T (&arr)[N]) { return arr; }
134 template <typename T, size_t N> T *end(T (&arr)[N]) { return arr + N; }
135
136 // Provide a dummy, hashable type designed for easy verification: its hash is
137 // the same as its value.
138 struct HashableDummy { size_t value; };
139 hash_code hash_value(HashableDummy dummy) { return dummy.value; }
140
141 TEST(HashingTest, HashCombineRangeBasicTest) {
142 // Leave this uninitialized in the hope that valgrind will catch bad reads.
143 int dummy;
144 hash_code dummy_hash = hash_combine_range(&dummy, &dummy);
145 EXPECT_NE(hash_code(0), dummy_hash);
146
147 const int arr1[] = { 1, 2, 3 };
148 hash_code arr1_hash = hash_combine_range(begin(arr1), end(arr1));
149 EXPECT_NE(dummy_hash, arr1_hash);
150 EXPECT_EQ(arr1_hash, hash_combine_range(begin(arr1), end(arr1)));
151
152 const std::vector<int> vec(begin(arr1), end(arr1));
153 EXPECT_EQ(arr1_hash, hash_combine_range(vec.begin(), vec.end()));
154
155 const std::list<int> list(begin(arr1), end(arr1));
156 EXPECT_EQ(arr1_hash, hash_combine_range(list.begin(), list.end()));
157
158 const std::deque<int> deque(begin(arr1), end(arr1));
159 EXPECT_EQ(arr1_hash, hash_combine_range(deque.begin(), deque.end()));
160
161 const int arr2[] = { 3, 2, 1 };
162 hash_code arr2_hash = hash_combine_range(begin(arr2), end(arr2));
163 EXPECT_NE(dummy_hash, arr2_hash);
164 EXPECT_NE(arr1_hash, arr2_hash);
165
166 const int arr3[] = { 1, 1, 2, 3 };
167 hash_code arr3_hash = hash_combine_range(begin(arr3), end(arr3));
168 EXPECT_NE(dummy_hash, arr3_hash);
169 EXPECT_NE(arr1_hash, arr3_hash);
170
171 const int arr4[] = { 1, 2, 3, 3 };
172 hash_code arr4_hash = hash_combine_range(begin(arr4), end(arr4));
173 EXPECT_NE(dummy_hash, arr4_hash);
174 EXPECT_NE(arr1_hash, arr4_hash);
175
176 const size_t arr5[] = { 1, 2, 3 };
177 const HashableDummy d_arr5[] = { {1}, {2}, {3} };
178 hash_code arr5_hash = hash_combine_range(begin(arr5), end(arr5));
179 hash_code d_arr5_hash = hash_combine_range(begin(d_arr5), end(d_arr5));
180 EXPECT_EQ(arr5_hash, d_arr5_hash);
181 }
182
183 TEST(HashingTest, HashCombineRangeLengthDiff) {
184 // Test that as only the length varies, we compute different hash codes for
185 // sequences.
186 std::map<size_t, size_t> code_to_size;
187 std::vector<char> all_one_c(256, '\xff');
188 for (unsigned Idx = 1, Size = all_one_c.size(); Idx < Size; ++Idx) {
189 hash_code code = hash_combine_range(&all_one_c[0], &all_one_c[0] + Idx);
190 std::map<size_t, size_t>::iterator
191 I = code_to_size.insert(std::make_pair(code, Idx)).first;
192 EXPECT_EQ(Idx, I->second);
193 }
194 code_to_size.clear();
195 std::vector<char> all_zero_c(256, '\0');
196 for (unsigned Idx = 1, Size = all_zero_c.size(); Idx < Size; ++Idx) {
197 hash_code code = hash_combine_range(&all_zero_c[0], &all_zero_c[0] + Idx);
198 std::map<size_t, size_t>::iterator
199 I = code_to_size.insert(std::make_pair(code, Idx)).first;
200 EXPECT_EQ(Idx, I->second);
201 }
202 code_to_size.clear();
203 std::vector<unsigned> all_one_int(512, -1);
204 for (unsigned Idx = 1, Size = all_one_int.size(); Idx < Size; ++Idx) {
205 hash_code code = hash_combine_range(&all_one_int[0], &all_one_int[0] + Idx);
206 std::map<size_t, size_t>::iterator
207 I = code_to_size.insert(std::make_pair(code, Idx)).first;
208 EXPECT_EQ(Idx, I->second);
209 }
210 code_to_size.clear();
211 std::vector<unsigned> all_zero_int(512, 0);
212 for (unsigned Idx = 1, Size = all_zero_int.size(); Idx < Size; ++Idx) {
213 hash_code code = hash_combine_range(&all_zero_int[0], &all_zero_int[0] + Idx);
214 std::map<size_t, size_t>::iterator
215 I = code_to_size.insert(std::make_pair(code, Idx)).first;
216 EXPECT_EQ(Idx, I->second);
217 }
218 }
219
220 TEST(HashingTest, HashCombineRangeGoldenTest) {
221 struct { const char *s; uint64_t hash; } golden_data[] = {
222 #if SIZE_MAX == UINT64_MAX || SIZE_MAX == UINT32_MAX
223 { "a", 0xaeb6f9d5517c61f8ULL },
224 { "ab", 0x7ab1edb96be496b4ULL },
225 { "abc", 0xe38e60bf19c71a3fULL },
226 { "abcde", 0xd24461a66de97f6eULL },
227 { "abcdefgh", 0x4ef872ec411dec9dULL },
228 { "abcdefghijklm", 0xe8a865539f4eadfeULL },
229 { "abcdefghijklmnopqrstu", 0x261cdf85faaf4e79ULL },
230 { "abcdefghijklmnopqrstuvwxyzabcdef", 0x43ba70e4198e3b2aULL },
231 { "abcdefghijklmnopqrstuvwxyzabcdef"
232 "abcdefghijklmnopqrstuvwxyzghijkl"
233 "abcdefghijklmnopqrstuvwxyzmnopqr"
234 "abcdefghijklmnopqrstuvwxyzstuvwx"
235 "abcdefghijklmnopqrstuvwxyzyzabcd", 0xdcd57fb2afdf72beULL },
236 { "a", 0xaeb6f9d5517c61f8ULL },
237 { "aa", 0xf2b3b69a9736a1ebULL },
238 { "aaa", 0xf752eb6f07b1cafeULL },
239 { "aaaaa", 0x812bd21e1236954cULL },
240 { "aaaaaaaa", 0xff07a2cff08ac587ULL },
241 { "aaaaaaaaaaaaa", 0x84ac949d54d704ecULL },
242 { "aaaaaaaaaaaaaaaaaaaaa", 0xcb2c8fb6be8f5648ULL },
243 { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0xcc40ab7f164091b6ULL },
244 { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
245 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
246 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
247 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
248 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0xc58e174c1e78ffe9ULL },
249 { "z", 0x1ba160d7e8f8785cULL },
250 { "zz", 0x2c5c03172f1285d7ULL },
251 { "zzz", 0x9d2c4f4b507a2ac3ULL },
252 { "zzzzz", 0x0f03b9031735693aULL },
253 { "zzzzzzzz", 0xe674147c8582c08eULL },
254 { "zzzzzzzzzzzzz", 0x3162d9fa6938db83ULL },
255 { "zzzzzzzzzzzzzzzzzzzzz", 0x37b9a549e013620cULL },
256 { "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", 0x8921470aff885016ULL },
257 { "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
258 "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
259 "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
260 "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
261 "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", 0xf60fdcd9beb08441ULL },
262 { "a", 0xaeb6f9d5517c61f8ULL },
263 { "ab", 0x7ab1edb96be496b4ULL },
264 { "aba", 0x3edb049950884d0aULL },
265 { "ababa", 0x8f2de9e73a97714bULL },
266 { "abababab", 0xee14a29ddf0ce54cULL },
267 { "ababababababa", 0x38b3ddaada2d52b4ULL },
268 { "ababababababababababa", 0xd3665364219f2b85ULL },
269 { "abababababababababababababababab", 0xa75cd6afbf1bc972ULL },
270 { "abababababababababababababababab"
271 "abababababababababababababababab"
272 "abababababababababababababababab"
273 "abababababababababababababababab"
274 "abababababababababababababababab", 0x840192d129f7a22bULL }
275 #else
276 #error This test only supports 64-bit and 32-bit systems.
277 #endif
278 };
279 for (unsigned i = 0; i < sizeof(golden_data)/sizeof(*golden_data); ++i) {
280 StringRef str = golden_data[i].s;
281 hash_code hash = hash_combine_range(str.begin(), str.end());
282 #if 0 // Enable this to generate paste-able text for the above structure.
283 std::string member_str = "\"" + str.str() + "\",";
284 fprintf(stderr, " { %-35s 0x%016llxULL },\n",
285 member_str.c_str(), static_cast<uint64_t>(hash));
286 #endif
287 EXPECT_EQ(static_cast<size_t>(golden_data[i].hash),
288 static_cast<size_t>(hash));
289 }
290 }
291
292 TEST(HashingTest, HashCombineBasicTest) {
293 // Hashing a sequence of homogenous types matches range hashing.
294 const int i1 = 42, i2 = 43, i3 = 123, i4 = 999, i5 = 0, i6 = 79;
295 const int arr1[] = { i1, i2, i3, i4, i5, i6 };
296 EXPECT_EQ(hash_combine_range(arr1, arr1 + 1), hash_combine(i1));
297 EXPECT_EQ(hash_combine_range(arr1, arr1 + 2), hash_combine(i1, i2));
298 EXPECT_EQ(hash_combine_range(arr1, arr1 + 3), hash_combine(i1, i2, i3));
299 EXPECT_EQ(hash_combine_range(arr1, arr1 + 4), hash_combine(i1, i2, i3, i4));
300 EXPECT_EQ(hash_combine_range(arr1, arr1 + 5),
301 hash_combine(i1, i2, i3, i4, i5));
302 EXPECT_EQ(hash_combine_range(arr1, arr1 + 6),
303 hash_combine(i1, i2, i3, i4, i5, i6));
304
305 // Hashing a sequence of heterogeneous types which *happen* to all produce the
306 // same data for hashing produces the same as a range-based hash of the
307 // fundamental values.
308 const size_t s1 = 1024, s2 = 8888, s3 = 9000000;
309 const HashableDummy d1 = { 1024 }, d2 = { 8888 }, d3 = { 9000000 };
310 const size_t arr2[] = { s1, s2, s3 };
311 EXPECT_EQ(hash_combine_range(begin(arr2), end(arr2)),
312 hash_combine(s1, s2, s3));
313 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(s1, s2, d3));
314 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(s1, d2, s3));
315 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, s2, s3));
316 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, d2, s3));
317 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, d2, d3));
318
319 // Permuting values causes hashes to change.
320 EXPECT_NE(hash_combine(i1, i1, i1), hash_combine(i1, i1, i2));
321 EXPECT_NE(hash_combine(i1, i1, i1), hash_combine(i1, i2, i1));
322 EXPECT_NE(hash_combine(i1, i1, i1), hash_combine(i2, i1, i1));
323 EXPECT_NE(hash_combine(i1, i1, i1), hash_combine(i2, i2, i1));
324 EXPECT_NE(hash_combine(i1, i1, i1), hash_combine(i2, i2, i2));
325 EXPECT_NE(hash_combine(i2, i1, i1), hash_combine(i1, i1, i2));
326 EXPECT_NE(hash_combine(i1, i1, i2), hash_combine(i1, i2, i1));
327 EXPECT_NE(hash_combine(i1, i2, i1), hash_combine(i2, i1, i1));
328
329 // Changing type w/o changing value causes hashes to change.
330 EXPECT_NE(hash_combine(i1, i2, i3), hash_combine((char)i1, i2, i3));
331 EXPECT_NE(hash_combine(i1, i2, i3), hash_combine(i1, (char)i2, i3));
332 EXPECT_NE(hash_combine(i1, i2, i3), hash_combine(i1, i2, (char)i3));
333
334 // This is array of uint64, but it should have the exact same byte pattern as
335 // an array of LargeTestIntegers.
336 const uint64_t bigarr[] = {
337 0xaaaaaaaaababababULL, 0xacacacacbcbcbcbcULL, 0xccddeeffeeddccbbULL,
338 0xdeadbeafdeadbeefULL, 0xfefefefededededeULL, 0xafafafafededededULL,
339 0xffffeeeeddddccccULL, 0xaaaacbcbffffababULL,
340 0xaaaaaaaaababababULL, 0xacacacacbcbcbcbcULL, 0xccddeeffeeddccbbULL,
341 0xdeadbeafdeadbeefULL, 0xfefefefededededeULL, 0xafafafafededededULL,
342 0xffffeeeeddddccccULL, 0xaaaacbcbffffababULL,
343 0xaaaaaaaaababababULL, 0xacacacacbcbcbcbcULL, 0xccddeeffeeddccbbULL,
344 0xdeadbeafdeadbeefULL, 0xfefefefededededeULL, 0xafafafafededededULL,
345 0xffffeeeeddddccccULL, 0xaaaacbcbffffababULL
346 };
347 // Hash a preposterously large integer, both aligned with the buffer and
348 // misaligned.
349 const LargeTestInteger li = { {
350 0xaaaaaaaaababababULL, 0xacacacacbcbcbcbcULL, 0xccddeeffeeddccbbULL,
351 0xdeadbeafdeadbeefULL, 0xfefefefededededeULL, 0xafafafafededededULL,
352 0xffffeeeeddddccccULL, 0xaaaacbcbffffababULL
353 } };
354 // Rotate the storage from 'li'.
355 const LargeTestInteger l2 = { {
356 0xacacacacbcbcbcbcULL, 0xccddeeffeeddccbbULL, 0xdeadbeafdeadbeefULL,
357 0xfefefefededededeULL, 0xafafafafededededULL, 0xffffeeeeddddccccULL,
358 0xaaaacbcbffffababULL, 0xaaaaaaaaababababULL
359 } };
360 const LargeTestInteger l3 = { {
361 0xccddeeffeeddccbbULL, 0xdeadbeafdeadbeefULL, 0xfefefefededededeULL,
362 0xafafafafededededULL, 0xffffeeeeddddccccULL, 0xaaaacbcbffffababULL,
363 0xaaaaaaaaababababULL, 0xacacacacbcbcbcbcULL
364 } };
365 EXPECT_EQ(hash_combine_range(begin(bigarr), end(bigarr)),
366 hash_combine(li, li, li));
367 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 9),
368 hash_combine(bigarr[0], l2));
369 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 10),
370 hash_combine(bigarr[0], bigarr[1], l3));
371 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 17),
372 hash_combine(li, bigarr[0], l2));
373 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 18),
374 hash_combine(li, bigarr[0], bigarr[1], l3));
375 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 18),
376 hash_combine(bigarr[0], l2, bigarr[9], l3));
377 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 20),
378 hash_combine(bigarr[0], l2, bigarr[9], l3, bigarr[18], bigarr[19]));
379 }
380
381 TEST(HashingTest, HashCombineArgs18) {
382 // This tests that we can pass in up to 18 args.
383 #define CHECK_SAME(...) \
384 EXPECT_EQ(hash_combine(__VA_ARGS__), hash_combine(__VA_ARGS__))
385 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18);
386 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17);
387 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
388 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
389 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
390 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
391 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
392 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
393 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
394 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9);
395 CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8);
396 CHECK_SAME(1, 2, 3, 4, 5, 6, 7);
397 CHECK_SAME(1, 2, 3, 4, 5, 6);
398 CHECK_SAME(1, 2, 3, 4, 5);
399 CHECK_SAME(1, 2, 3, 4);
400 CHECK_SAME(1, 2, 3);
401 CHECK_SAME(1, 2);
402 CHECK_SAME(1);
403 #undef CHECK_SAME
404 }
405
406 struct StructWithHashBuilderSupport {
407 char C;
408 int I;
409 template <typename HasherT, llvm::support::endianness Endianness>
410 friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
411 const StructWithHashBuilderSupport &Value) {
412 HBuilder.add(Value.C, Value.I);
413 }
414 };
415
416 TEST(HashingTest, HashWithHashBuilder) {
417 StructWithHashBuilderSupport S{'c', 1};
418 EXPECT_NE(static_cast<size_t>(llvm::hash_value(S)), static_cast<size_t>(0));
419 }
420
421 struct StructWithHashBuilderAndHashValueSupport {
422 char C;
423 int I;
424 template <typename HasherT, llvm::support::endianness Endianness>
425 friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
426 const StructWithHashBuilderAndHashValueSupport &Value) {}
427 friend hash_code
428 hash_value(const StructWithHashBuilderAndHashValueSupport &Value) {
429 return 0xbeef;
430 }
431 };
432
433 TEST(HashingTest, HashBuilderAndHashValue) {
434 StructWithHashBuilderAndHashValueSupport S{'c', 1};
435 EXPECT_EQ(static_cast<size_t>(hash_value(S)), static_cast<size_t>(0xbeef));
436 }
437
438 } // namespace
LLVM monorepo