X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=unittests%2FADT%2FHashingTest.cpp;h=34eb5a52eb8a0fa11f3748480cff088509581b15;hb=4e29d0712ce1b3ed1f9ad2dae3af87589540d6f8;hp=0d24e0d6e3985846fa01719f9430ea1280964aa5;hpb=2547e7faba2b0511b88cfd2a187c072612105600;p=oota-llvm.git diff --git a/unittests/ADT/HashingTest.cpp b/unittests/ADT/HashingTest.cpp index 0d24e0d6e39..34eb5a52eb8 100644 --- a/unittests/ADT/HashingTest.cpp +++ b/unittests/ADT/HashingTest.cpp @@ -30,9 +30,18 @@ void PrintTo(const hash_code &code, std::ostream *os) { // objects. struct LargeTestInteger { uint64_t arr[8]; }; +struct NonPOD { + uint64_t x, y; + NonPOD(uint64_t x, uint64_t y) : x(x), y(y) {} + ~NonPOD() {} + friend hash_code hash_value(const NonPOD &obj) { + return hash_combine(obj.x, obj.y); + } +}; + namespace hashing { namespace detail { -template <> struct is_hashable_data : true_type {}; +template <> struct is_hashable_data : std::true_type {}; } // namespace detail } // namespace hashing @@ -42,57 +51,73 @@ using namespace llvm; namespace { -struct NonPOD { - uint64_t x, y; - NonPOD(uint64_t x, uint64_t y) : x(x), y(y) {} - ~NonPOD() {} - friend hash_code hash_value(const NonPOD &obj) { - return hash_combine(obj.x, obj.y); - } +enum TestEnumeration { + TE_Foo = 42, + TE_Bar = 43 }; - TEST(HashingTest, HashValueBasicTest) { int x = 42, y = 43, c = 'x'; - void *p = 0; + void *p = nullptr; uint64_t i = 71; const unsigned ci = 71; volatile int vi = 71; const volatile int cvi = 71; uintptr_t addr = reinterpret_cast(&y); - EXPECT_EQ(llvm::hash_value(42), llvm::hash_value(x)); - EXPECT_NE(llvm::hash_value(42), llvm::hash_value(y)); - EXPECT_NE(llvm::hash_value(42), llvm::hash_value(p)); - EXPECT_EQ(llvm::hash_value(71), llvm::hash_value(i)); - EXPECT_EQ(llvm::hash_value(71), llvm::hash_value(ci)); - EXPECT_EQ(llvm::hash_value(71), llvm::hash_value(vi)); - EXPECT_EQ(llvm::hash_value(71), llvm::hash_value(cvi)); - EXPECT_EQ(llvm::hash_value(c), llvm::hash_value('x')); - EXPECT_EQ(llvm::hash_value('4'), llvm::hash_value('0' + 4)); - EXPECT_EQ(llvm::hash_value(addr), llvm::hash_value(&y)); - - EXPECT_EQ(llvm::hash_combine(42, 43), llvm::hash_value(std::make_pair(42, 43))); - EXPECT_NE(llvm::hash_combine(43, 42), llvm::hash_value(std::make_pair(42, 43))); - EXPECT_NE(llvm::hash_combine(42, 43), llvm::hash_value(std::make_pair(42ull, 43ull))); - EXPECT_NE(llvm::hash_combine(42, 43), llvm::hash_value(std::make_pair(42, 43ull))); - EXPECT_NE(llvm::hash_combine(42, 43), llvm::hash_value(std::make_pair(42ull, 43))); + EXPECT_EQ(hash_value(42), hash_value(x)); + EXPECT_EQ(hash_value(42), hash_value(TE_Foo)); + EXPECT_NE(hash_value(42), hash_value(y)); + EXPECT_NE(hash_value(42), hash_value(TE_Bar)); + EXPECT_NE(hash_value(42), hash_value(p)); + EXPECT_EQ(hash_value(71), hash_value(i)); + EXPECT_EQ(hash_value(71), hash_value(ci)); + EXPECT_EQ(hash_value(71), hash_value(vi)); + EXPECT_EQ(hash_value(71), hash_value(cvi)); + EXPECT_EQ(hash_value(c), hash_value('x')); + EXPECT_EQ(hash_value('4'), hash_value('0' + 4)); + EXPECT_EQ(hash_value(addr), hash_value(&y)); +} + +TEST(HashingTest, HashValueStdPair) { + EXPECT_EQ(hash_combine(42, 43), hash_value(std::make_pair(42, 43))); + EXPECT_NE(hash_combine(43, 42), hash_value(std::make_pair(42, 43))); + EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42ull, 43ull))); + EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42, 43ull))); + EXPECT_NE(hash_combine(42, 43), hash_value(std::make_pair(42ull, 43))); // Note that pairs are implicitly flattened to a direct sequence of data and // hashed efficiently as a consequence. - EXPECT_EQ(llvm::hash_combine(42, 43, 44), - llvm::hash_value(std::make_pair(42, std::make_pair(43, 44)))); - EXPECT_EQ(llvm::hash_value(std::make_pair(42, std::make_pair(43, 44))), - llvm::hash_value(std::make_pair(std::make_pair(42, 43), 44))); + EXPECT_EQ(hash_combine(42, 43, 44), + hash_value(std::make_pair(42, std::make_pair(43, 44)))); + EXPECT_EQ(hash_value(std::make_pair(42, std::make_pair(43, 44))), + hash_value(std::make_pair(std::make_pair(42, 43), 44))); // Ensure that pairs which have padding bytes *inside* them don't get treated // this way. - EXPECT_EQ(llvm::hash_combine('0', hash_combine(1ull, '2')), - llvm::hash_value(std::make_pair('0', std::make_pair(1ull, '2')))); + EXPECT_EQ(hash_combine('0', hash_combine(1ull, '2')), + hash_value(std::make_pair('0', std::make_pair(1ull, '2')))); // Ensure that non-POD pairs don't explode the traits used. NonPOD obj1(1, 2), obj2(3, 4), obj3(5, 6); - EXPECT_EQ(llvm::hash_combine(obj1, hash_combine(obj2, obj3)), - llvm::hash_value(std::make_pair(obj1, std::make_pair(obj2, obj3)))); + EXPECT_EQ(hash_combine(obj1, hash_combine(obj2, obj3)), + hash_value(std::make_pair(obj1, std::make_pair(obj2, obj3)))); +} + +TEST(HashingTest, HashValueStdString) { + std::string s = "Hello World!"; + EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size()), hash_value(s)); + EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size() - 1), + hash_value(s.substr(0, s.size() - 1))); + EXPECT_EQ(hash_combine_range(s.c_str() + 1, s.c_str() + s.size() - 1), + hash_value(s.substr(1, s.size() - 2))); + + std::wstring ws = L"Hello Wide World!"; + EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size()), + hash_value(ws)); + EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size() - 1), + hash_value(ws.substr(0, ws.size() - 1))); + EXPECT_EQ(hash_combine_range(ws.c_str() + 1, ws.c_str() + ws.size() - 1), + hash_value(ws.substr(1, ws.size() - 2))); } template T *begin(T (&arr)[N]) { return arr; } @@ -320,7 +345,7 @@ TEST(HashingTest, HashCombineBasicTest) { EXPECT_EQ(hash_combine_range(arr1, arr1 + 6), hash_combine(i1, i2, i3, i4, i5, i6)); - // Hashing a sequence of heterogenous types which *happen* to all produce the + // Hashing a sequence of heterogeneous types which *happen* to all produce the // same data for hashing produces the same as a range-based hash of the // fundamental values. const size_t s1 = 1024, s2 = 8888, s3 = 9000000; @@ -396,4 +421,29 @@ TEST(HashingTest, HashCombineBasicTest) { hash_combine(bigarr[0], l2, bigarr[9], l3, bigarr[18], bigarr[19])); } +TEST(HashingTest, HashCombineArgs18) { + // This tests that we can pass in up to 18 args. +#define CHECK_SAME(...) \ + EXPECT_EQ(hash_combine(__VA_ARGS__), hash_combine(__VA_ARGS__)) + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8, 9); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7, 8); + CHECK_SAME(1, 2, 3, 4, 5, 6, 7); + CHECK_SAME(1, 2, 3, 4, 5, 6); + CHECK_SAME(1, 2, 3, 4, 5); + CHECK_SAME(1, 2, 3, 4); + CHECK_SAME(1, 2, 3); + CHECK_SAME(1, 2); + CHECK_SAME(1); +#undef CHECK_SAME +} + }