diff options
Diffstat (limited to 'third_party/abseil-cpp/absl/hash/hash_test.cc')
| -rw-r--r-- | third_party/abseil-cpp/absl/hash/hash_test.cc | 118 |
1 files changed, 22 insertions, 96 deletions
diff --git a/third_party/abseil-cpp/absl/hash/hash_test.cc b/third_party/abseil-cpp/absl/hash/hash_test.cc index b3ddebdd42..f02a537ae8 100644 --- a/third_party/abseil-cpp/absl/hash/hash_test.cc +++ b/third_party/abseil-cpp/absl/hash/hash_test.cc @@ -42,7 +42,6 @@ #include "absl/hash/internal/spy_hash_state.h" #include "absl/meta/type_traits.h" #include "absl/numeric/int128.h" -#include "absl/strings/cord_test_helpers.h" namespace { @@ -82,8 +81,8 @@ TYPED_TEST_P(HashValueIntTest, FastPath) { } REGISTER_TYPED_TEST_CASE_P(HashValueIntTest, BasicUsage, FastPath); -using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t, - uint32_t, uint64_t, size_t>; +using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t, uint32_t, + uint64_t, size_t>; INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueIntTest, IntTypes); enum LegacyEnum { kValue1, kValue2, kValue3 }; @@ -270,22 +269,6 @@ struct WrapInTuple { } }; -absl::Cord FlatCord(absl::string_view sv) { - absl::Cord c(sv); - c.Flatten(); - return c; -} - -absl::Cord FragmentedCord(absl::string_view sv) { - if (sv.size() < 2) { - return absl::Cord(sv); - } - size_t halfway = sv.size() / 2; - std::vector<absl::string_view> parts = {sv.substr(0, halfway), - sv.substr(halfway)}; - return absl::MakeFragmentedCord(parts); -} - TEST(HashValueTest, Strings) { EXPECT_TRUE((is_hashable<std::string>::value)); @@ -294,29 +277,25 @@ TEST(HashValueTest, Strings) { const std::string large = std::string(2048, 'x'); // multiple of chunk size const std::string huge = std::string(5000, 'a'); // not a multiple - EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( // - std::string(), absl::string_view(), absl::Cord(), // - std::string(""), absl::string_view(""), absl::Cord(""), // - std::string(small), absl::string_view(small), absl::Cord(small), // - std::string(dup), absl::string_view(dup), absl::Cord(dup), // - std::string(large), absl::string_view(large), absl::Cord(large), // - std::string(huge), absl::string_view(huge), FlatCord(huge), // - FragmentedCord(huge)))); + EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( + std::string(), absl::string_view(), + std::string(""), absl::string_view(""), + std::string(small), absl::string_view(small), + std::string(dup), absl::string_view(dup), + std::string(large), absl::string_view(large), + std::string(huge), absl::string_view(huge)))); // Also check that nested types maintain the same hash. const WrapInTuple t{}; - EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( // - t(std::string()), t(absl::string_view()), t(absl::Cord()), // - t(std::string("")), t(absl::string_view("")), t(absl::Cord("")), // - t(std::string(small)), t(absl::string_view(small)), // - t(absl::Cord(small)), // - t(std::string(dup)), t(absl::string_view(dup)), t(absl::Cord(dup)), // - t(std::string(large)), t(absl::string_view(large)), // - t(absl::Cord(large)), // - t(std::string(huge)), t(absl::string_view(huge)), // - t(FlatCord(huge)), t(FragmentedCord(huge))))); - - // Make sure that hashing a `const char*` does not use its string-value. + EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( + t(std::string()), t(absl::string_view()), + t(std::string("")), t(absl::string_view("")), + t(std::string(small)), t(absl::string_view(small)), + t(std::string(dup)), t(absl::string_view(dup)), + t(std::string(large)), t(absl::string_view(large)), + t(std::string(huge)), t(absl::string_view(huge))))); + + // Make sure that hashing a `const char*` does not use its std::string-value. EXPECT_NE(SpyHash(static_cast<const char*>("ABC")), SpyHash(absl::string_view("ABC"))); } @@ -407,7 +386,7 @@ using IntSequenceTypes = INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueSequenceTest, IntSequenceTypes); // Private type that only supports AbslHashValue to make sure our chosen hash -// implementation is recursive within absl::Hash. +// implentation is recursive within absl::Hash. // It uses std::abs() on the value to provide different bitwise representations // of the same logical value. struct Private { @@ -512,7 +491,7 @@ TEST(HashValueTest, CombinePiecewiseBuffer) { SCOPED_TRACE(big_buffer_size); std::string big_buffer; for (int i = 0; i < big_buffer_size; ++i) { - // Arbitrary string + // Arbitrary std::string big_buffer.push_back(32 + (i * (i / 3)) % 64); } auto big_buffer_hash = hash(PiecewiseHashTester(big_buffer)); @@ -581,24 +560,6 @@ TEST(HashValueTest, Maps) { MM{{1, "foo"}, {1, "foo"}, {43, "bar"}}, MM{{1, "foo"}, {43, "baz"}}))); } -TEST(HashValueTest, ReferenceWrapper) { - EXPECT_TRUE(is_hashable<std::reference_wrapper<Private>>::value); - - Private p1{1}, p10{10}; - EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( - p1, p10, std::ref(p1), std::ref(p10), std::cref(p1), std::cref(p10)))); - - EXPECT_TRUE(is_hashable<std::reference_wrapper<int>>::value); - int one = 1, ten = 10; - EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple( - one, ten, std::ref(one), std::ref(ten), std::cref(one), std::cref(ten)))); - - EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly( - std::make_tuple(std::tuple<std::reference_wrapper<int>>(std::ref(one)), - std::tuple<std::reference_wrapper<int>>(std::ref(ten)), - std::tuple<int>(one), std::tuple<int>(ten)))); -} - template <typename T, typename = void> struct IsHashCallable : std::false_type {}; @@ -819,8 +780,8 @@ TYPED_TEST_P(HashIntTest, BasicUsage) { } REGISTER_TYPED_TEST_CASE_P(HashIntTest, BasicUsage); -using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t, - uint32_t, uint64_t, size_t>; +using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t, uint32_t, + uint64_t, size_t>; INSTANTIATE_TYPED_TEST_CASE_P(My, HashIntTest, IntTypes); struct StructWithPadding { @@ -973,39 +934,4 @@ TEST(HashTest, DoesNotUseImplicitConversionsToBool) { absl::Hash<ValueWithBoolConversion>()(ValueWithBoolConversion{1})); } -TEST(HashOf, MatchesHashForSingleArgument) { - std::string s = "forty two"; - int i = 42; - double d = 42.0; - std::tuple<int, int> t{4, 2}; - - EXPECT_EQ(absl::HashOf(s), absl::Hash<std::string>{}(s)); - EXPECT_EQ(absl::HashOf(i), absl::Hash<int>{}(i)); - EXPECT_EQ(absl::HashOf(d), absl::Hash<double>{}(d)); - EXPECT_EQ(absl::HashOf(t), (absl::Hash<std::tuple<int, int>>{}(t))); -} - -TEST(HashOf, MatchesHashOfTupleForMultipleArguments) { - std::string hello = "hello"; - std::string world = "world"; - - EXPECT_EQ(absl::HashOf(), absl::HashOf(std::make_tuple())); - EXPECT_EQ(absl::HashOf(hello), absl::HashOf(std::make_tuple(hello))); - EXPECT_EQ(absl::HashOf(hello, world), - absl::HashOf(std::make_tuple(hello, world))); -} - -template <typename T> -std::true_type HashOfExplicitParameter(decltype(absl::HashOf<T>(0))) { - return {}; -} -template <typename T> -std::false_type HashOfExplicitParameter(size_t) { - return {}; -} - -TEST(HashOf, CantPassExplicitTemplateParameters) { - EXPECT_FALSE(HashOfExplicitParameter<int>(0)); -} - } // namespace |