diff --git a/tests/googletest/include/absl/container/internal/unordered_map_constructor_test.h b/tests/googletest/include/absl/container/internal/unordered_map_constructor_test.h
deleted file mode 100644
index 7e84dc25..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_map_constructor_test.h
+++ /dev/null
@@ -1,494 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
-
-#include <algorithm>
-#include <unordered_map>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ConstructorTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ConstructorTest);
-
-TYPED_TEST_P(ConstructorTest, NoArgs) {
-  TypeParam m;
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCount) {
-  TypeParam m(123);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHash) {
-  using H = typename TypeParam::hasher;
-  H hasher;
-  TypeParam m(123, hasher);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  H hasher;
-  E equal;
-  TypeParam m(123, hasher, equal);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename T>
-struct is_std_unordered_map : std::false_type {};
-
-template <typename... T>
-struct is_std_unordered_map<std::unordered_map<T...>> : std::true_type {};
-
-#if defined(UNORDERED_MAP_CXX14) || defined(UNORDERED_MAP_CXX17)
-using has_cxx14_std_apis = std::true_type;
-#else
-using has_cxx14_std_apis = std::false_type;
-#endif
-
-template <typename T>
-using expect_cxx14_apis =
-    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
-                      has_cxx14_std_apis>;
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
-  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::true_type) {
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  TypeParam m(123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
-  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
-using has_alloc_std_constructors = std::true_type;
-#else
-using has_alloc_std_constructors = std::false_type;
-#endif
-
-template <typename T>
-using expect_alloc_constructors =
-    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
-                      has_alloc_std_constructors>;
-
-template <typename TypeParam>
-void AllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void AllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, Alloc) {
-  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
-  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
-  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam n(m);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam n(m, A(11));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
-  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on copy constructors.
-
-TYPED_TEST_P(ConstructorTest, MoveConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam t(m);
-  TypeParam n(std::move(t));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam t(m);
-  TypeParam n(std::move(t), A(1));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
-  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on move constructors.
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(values, 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  A alloc(0);
-  TypeParam m(values, 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
-  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values, 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
-  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, Assignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam n;
-  n = m;
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
-// (it depends on traits).
-
-TYPED_TEST_P(ConstructorTest, MoveAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam t(m);
-  TypeParam n;
-  n = std::move(t);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam n({gen()});
-  n = m;
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam t(m);
-  TypeParam n({gen()});
-  n = std::move(t);
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values);
-  m = *&m;  // Avoid -Wself-assign
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-// We cannot test self move as standard states that it leaves standard
-// containers in unspecified state (and in practice in causes memory-leak
-// according to heap-checker!).
-
-REGISTER_TYPED_TEST_SUITE_P(
-    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
-    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
-    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
-    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
-    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
-    InitializerListBucketAlloc, InitializerListBucketHashAlloc, Assignment,
-    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
-    MoveAssignmentOverwritesExisting,
-    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_map_lookup_test.h b/tests/googletest/include/absl/container/internal/unordered_map_lookup_test.h
deleted file mode 100644
index 3713cd9a..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_map_lookup_test.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class LookupTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(LookupTest);
-
-TYPED_TEST_P(LookupTest, At) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  for (const auto& p : values) {
-    const auto& val = m.at(p.first);
-    EXPECT_EQ(p.second, val) << ::testing::PrintToString(p.first);
-  }
-}
-
-TYPED_TEST_P(LookupTest, OperatorBracket) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values) {
-    auto& val = m[p.first];
-    EXPECT_EQ(V(), val) << ::testing::PrintToString(p.first);
-    val = p.second;
-  }
-  for (const auto& p : values)
-    EXPECT_EQ(p.second, m[p.first]) << ::testing::PrintToString(p.first);
-}
-
-TYPED_TEST_P(LookupTest, Count) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values)
-    EXPECT_EQ(0, m.count(p.first)) << ::testing::PrintToString(p.first);
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values)
-    EXPECT_EQ(1, m.count(p.first)) << ::testing::PrintToString(p.first);
-}
-
-TYPED_TEST_P(LookupTest, Find) {
-  using std::get;
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values)
-    EXPECT_TRUE(m.end() == m.find(p.first))
-        << ::testing::PrintToString(p.first);
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values) {
-    auto it = m.find(p.first);
-    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(p.first);
-    EXPECT_EQ(p.second, get<1>(*it)) << ::testing::PrintToString(p.first);
-  }
-}
-
-TYPED_TEST_P(LookupTest, EqualRange) {
-  using std::get;
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values) {
-    auto r = m.equal_range(p.first);
-    ASSERT_EQ(0, std::distance(r.first, r.second));
-  }
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values) {
-    auto r = m.equal_range(p.first);
-    ASSERT_EQ(1, std::distance(r.first, r.second));
-    EXPECT_EQ(p.second, get<1>(*r.first)) << ::testing::PrintToString(p.first);
-  }
-}
-
-REGISTER_TYPED_TEST_SUITE_P(LookupTest, At, OperatorBracket, Count, Find,
-                            EqualRange);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_map_members_test.h b/tests/googletest/include/absl/container/internal/unordered_map_members_test.h
deleted file mode 100644
index 7d48cdb8..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_map_members_test.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
-
-#include <type_traits>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class MembersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(MembersTest);
-
-template <typename T>
-void UseType() {}
-
-TYPED_TEST_P(MembersTest, Typedefs) {
-  EXPECT_TRUE((std::is_same<std::pair<const typename TypeParam::key_type,
-                                      typename TypeParam::mapped_type>,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((absl::conjunction<
-               absl::negation<std::is_signed<typename TypeParam::size_type>>,
-               std::is_integral<typename TypeParam::size_type>>()));
-  EXPECT_TRUE((absl::conjunction<
-               std::is_signed<typename TypeParam::difference_type>,
-               std::is_integral<typename TypeParam::difference_type>>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::hasher&>()(
-                   std::declval<const typename TypeParam::key_type&>())),
-               size_t>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::key_equal&>()(
-                   std::declval<const typename TypeParam::key_type&>(),
-                   std::declval<const typename TypeParam::key_type&>())),
-               bool>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
-                            typename TypeParam::reference>()));
-  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
-                            typename TypeParam::const_reference>()));
-  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
-                                typename TypeParam::allocator_type>::pointer,
-                            typename TypeParam::pointer>()));
-  EXPECT_TRUE(
-      (std::is_same<typename std::allocator_traits<
-                        typename TypeParam::allocator_type>::const_pointer,
-                    typename TypeParam::const_pointer>()));
-}
-
-TYPED_TEST_P(MembersTest, SimpleFunctions) {
-  EXPECT_GT(TypeParam().max_size(), 0);
-}
-
-TYPED_TEST_P(MembersTest, BeginEnd) {
-  TypeParam t = {typename TypeParam::value_type{}};
-  EXPECT_EQ(t.begin(), t.cbegin());
-  EXPECT_EQ(t.end(), t.cend());
-  EXPECT_NE(t.begin(), t.end());
-  EXPECT_NE(t.cbegin(), t.cend());
-}
-
-REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_map_modifiers_test.h b/tests/googletest/include/absl/container/internal/unordered_map_modifiers_test.h
deleted file mode 100644
index 4d9ab30f..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_map_modifiers_test.h
+++ /dev/null
@@ -1,352 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
-
-#include <memory>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ModifiersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ModifiersTest);
-
-TYPED_TEST_P(ModifiersTest, Clear) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  m.clear();
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(m.empty());
-}
-
-TYPED_TEST_P(ModifiersTest, Insert) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.insert(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.insert(val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto it = m.insert(m.end(), val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.insert(it, val2);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  m.insert(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  m.insert(val2);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
-#if !defined(__GLIBCXX__)
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> base_values;
-  std::generate_n(std::back_inserter(base_values), 10,
-                  hash_internal::Generator<T>());
-  std::vector<T> values;
-  while (values.size() != 100) {
-    std::copy_n(base_values.begin(), 10, std::back_inserter(values));
-  }
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(values.begin(), values.end());
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-#endif
-}
-
-TYPED_TEST_P(ModifiersTest, InsertOrAssign) {
-#ifdef UNORDERED_MAP_CXX17
-  using std::get;
-  using K = typename TypeParam::key_type;
-  using V = typename TypeParam::mapped_type;
-  K k = hash_internal::Generator<K>()();
-  V val = hash_internal::Generator<V>()();
-  TypeParam m;
-  auto p = m.insert_or_assign(k, val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(k, get<0>(*p.first));
-  EXPECT_EQ(val, get<1>(*p.first));
-  V val2 = hash_internal::Generator<V>()();
-  p = m.insert_or_assign(k, val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(k, get<0>(*p.first));
-  EXPECT_EQ(val2, get<1>(*p.first));
-#endif
-}
-
-TYPED_TEST_P(ModifiersTest, InsertOrAssignHint) {
-#ifdef UNORDERED_MAP_CXX17
-  using std::get;
-  using K = typename TypeParam::key_type;
-  using V = typename TypeParam::mapped_type;
-  K k = hash_internal::Generator<K>()();
-  V val = hash_internal::Generator<V>()();
-  TypeParam m;
-  auto it = m.insert_or_assign(m.end(), k, val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(k, get<0>(*it));
-  EXPECT_EQ(val, get<1>(*it));
-  V val2 = hash_internal::Generator<V>()();
-  it = m.insert_or_assign(it, k, val2);
-  EXPECT_EQ(k, get<0>(*it));
-  EXPECT_EQ(val2, get<1>(*it));
-#endif
-}
-
-TYPED_TEST_P(ModifiersTest, Emplace) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.emplace(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.emplace(val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, EmplaceHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.emplace_hint(m.end(), val);
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.emplace_hint(it, val2);
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, TryEmplace) {
-#ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.try_emplace(val.first, val.second);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.try_emplace(val2.first, val2.second);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-#endif
-}
-
-TYPED_TEST_P(ModifiersTest, TryEmplaceHint) {
-#ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.try_emplace(m.end(), val.first, val.second);
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.try_emplace(it, val2.first, val2.second);
-  EXPECT_EQ(val, *it);
-#endif
-}
-
-template <class V>
-using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
-
-// In openmap we chose not to return the iterator from erase because that's
-// more expensive. As such we adapt erase to return an iterator here.
-struct EraseFirst {
-  template <class Map>
-  auto operator()(Map* m, int) const
-      -> IfNotVoid<decltype(m->erase(m->begin()))> {
-    return m->erase(m->begin());
-  }
-  template <class Map>
-  typename Map::iterator operator()(Map* m, ...) const {
-    auto it = m->begin();
-    m->erase(it++);
-    return it;
-  }
-};
-
-TYPED_TEST_P(ModifiersTest, Erase) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using std::get;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  auto& first = *m.begin();
-  std::vector<T> values2;
-  for (const auto& val : values)
-    if (get<0>(val) != get<0>(first)) values2.push_back(val);
-  auto it = EraseFirst()(&m, 0);
-  ASSERT_TRUE(it != m.end());
-  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values2.begin(),
-                                                             values2.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, EraseRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  auto it = m.erase(m.begin(), m.end());
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(it == m.end());
-}
-
-TYPED_TEST_P(ModifiersTest, EraseKey) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_EQ(1, m.erase(values[0].first));
-  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
-                                                             values.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, Swap) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> v1;
-  std::vector<T> v2;
-  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
-  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
-  TypeParam m1(v1.begin(), v1.end());
-  TypeParam m2(v2.begin(), v2.end());
-  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v1));
-  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v2));
-  m1.swap(m2);
-  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v2));
-  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v1));
-}
-
-// TODO(alkis): Write tests for extract.
-// TODO(alkis): Write tests for merge.
-
-REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
-                            InsertRange, InsertWithinCapacity,
-                            InsertRangeWithinCapacity, InsertOrAssign,
-                            InsertOrAssignHint, Emplace, EmplaceHint,
-                            TryEmplace, TryEmplaceHint, Erase, EraseRange,
-                            EraseKey, Swap);
-
-template <typename Type>
-struct is_unique_ptr : std::false_type {};
-
-template <typename Type>
-struct is_unique_ptr<std::unique_ptr<Type>> : std::true_type {};
-
-template <class UnordMap>
-class UniquePtrModifiersTest : public ::testing::Test {
- protected:
-  UniquePtrModifiersTest() {
-    static_assert(is_unique_ptr<typename UnordMap::mapped_type>::value,
-                  "UniquePtrModifiersTyest may only be called with a "
-                  "std::unique_ptr value type.");
-  }
-};
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest);
-
-TYPED_TEST_SUITE_P(UniquePtrModifiersTest);
-
-// Test that we do not move from rvalue arguments if an insertion does not
-// happen.
-TYPED_TEST_P(UniquePtrModifiersTest, TryEmplace) {
-#ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.try_emplace(val.first, std::move(val.second));
-  EXPECT_TRUE(p.second);
-  // A moved from std::unique_ptr is guaranteed to be nullptr.
-  EXPECT_EQ(val.second, nullptr);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.try_emplace(val2.first, std::move(val2.second));
-  EXPECT_FALSE(p.second);
-  EXPECT_NE(val2.second, nullptr);
-#endif
-}
-
-REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_set_constructor_test.h b/tests/googletest/include/absl/container/internal/unordered_set_constructor_test.h
deleted file mode 100644
index af1116e6..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_set_constructor_test.h
+++ /dev/null
@@ -1,496 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
-
-#include <algorithm>
-#include <unordered_set>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ConstructorTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ConstructorTest);
-
-TYPED_TEST_P(ConstructorTest, NoArgs) {
-  TypeParam m;
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCount) {
-  TypeParam m(123);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHash) {
-  using H = typename TypeParam::hasher;
-  H hasher;
-  TypeParam m(123, hasher);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  H hasher;
-  E equal;
-  TypeParam m(123, hasher, equal);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-
-  const auto& cm = m;
-  EXPECT_EQ(cm.hash_function(), hasher);
-  EXPECT_EQ(cm.key_eq(), equal);
-  EXPECT_EQ(cm.get_allocator(), alloc);
-  EXPECT_TRUE(cm.empty());
-  EXPECT_THAT(keys(cm), ::testing::UnorderedElementsAre());
-  EXPECT_GE(cm.bucket_count(), 123);
-}
-
-template <typename T>
-struct is_std_unordered_set : std::false_type {};
-
-template <typename... T>
-struct is_std_unordered_set<std::unordered_set<T...>> : std::true_type {};
-
-#if defined(UNORDERED_SET_CXX14) || defined(UNORDERED_SET_CXX17)
-using has_cxx14_std_apis = std::true_type;
-#else
-using has_cxx14_std_apis = std::false_type;
-#endif
-
-template <typename T>
-using expect_cxx14_apis =
-    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
-                      has_cxx14_std_apis>;
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
-  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::true_type) {
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  TypeParam m(123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
-  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
-using has_alloc_std_constructors = std::true_type;
-#else
-using has_alloc_std_constructors = std::false_type;
-#endif
-
-template <typename T>
-using expect_alloc_constructors =
-    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
-                      has_alloc_std_constructors>;
-
-template <typename TypeParam>
-void AllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void AllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, Alloc) {
-  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
-  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
-  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam n(m);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-  EXPECT_NE(TypeParam(0, hasher, equal, alloc), n);
-}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam n(m, A(11));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
-  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on copy constructors.
-
-TYPED_TEST_P(ConstructorTest, MoveConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam t(m);
-  TypeParam n(std::move(t));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam t(m);
-  TypeParam n(std::move(t), A(1));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
-  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on move constructors.
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(values, 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  A alloc(0);
-  TypeParam m(values, 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
-  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values, 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
-  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam n;
-  n = m;
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
-// (it depends on traits).
-
-TYPED_TEST_P(ConstructorTest, MoveAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam t(m);
-  TypeParam n;
-  n = std::move(t);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam n({gen()});
-  n = m;
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam t(m);
-  TypeParam n({gen()});
-  n = std::move(t);
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values);
-  m = *&m;  // Avoid -Wself-assign.
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-REGISTER_TYPED_TEST_SUITE_P(
-    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
-    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
-    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
-    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
-    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
-    InitializerListBucketAlloc, InitializerListBucketHashAlloc, CopyAssignment,
-    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
-    MoveAssignmentOverwritesExisting,
-    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_set_lookup_test.h b/tests/googletest/include/absl/container/internal/unordered_set_lookup_test.h
deleted file mode 100644
index b35f766e..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_set_lookup_test.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordSet>
-class LookupTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(LookupTest);
-
-TYPED_TEST_P(LookupTest, Count) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values)
-    EXPECT_EQ(0, m.count(v)) << ::testing::PrintToString(v);
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values)
-    EXPECT_EQ(1, m.count(v)) << ::testing::PrintToString(v);
-}
-
-TYPED_TEST_P(LookupTest, Find) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values)
-    EXPECT_TRUE(m.end() == m.find(v)) << ::testing::PrintToString(v);
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values) {
-    typename TypeParam::iterator it = m.find(v);
-    static_assert(std::is_same<const typename TypeParam::value_type&,
-                               decltype(*it)>::value,
-                  "");
-    static_assert(std::is_same<const typename TypeParam::value_type*,
-                               decltype(it.operator->())>::value,
-                  "");
-    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(v);
-    EXPECT_EQ(v, *it) << ::testing::PrintToString(v);
-  }
-}
-
-TYPED_TEST_P(LookupTest, EqualRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values) {
-    auto r = m.equal_range(v);
-    ASSERT_EQ(0, std::distance(r.first, r.second));
-  }
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values) {
-    auto r = m.equal_range(v);
-    ASSERT_EQ(1, std::distance(r.first, r.second));
-    EXPECT_EQ(v, *r.first);
-  }
-}
-
-REGISTER_TYPED_TEST_SUITE_P(LookupTest, Count, Find, EqualRange);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_set_members_test.h b/tests/googletest/include/absl/container/internal/unordered_set_members_test.h
deleted file mode 100644
index 4c5e104a..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_set_members_test.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
-
-#include <type_traits>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordSet>
-class MembersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(MembersTest);
-
-template <typename T>
-void UseType() {}
-
-TYPED_TEST_P(MembersTest, Typedefs) {
-  EXPECT_TRUE((std::is_same<typename TypeParam::key_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((absl::conjunction<
-               absl::negation<std::is_signed<typename TypeParam::size_type>>,
-               std::is_integral<typename TypeParam::size_type>>()));
-  EXPECT_TRUE((absl::conjunction<
-               std::is_signed<typename TypeParam::difference_type>,
-               std::is_integral<typename TypeParam::difference_type>>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::hasher&>()(
-                   std::declval<const typename TypeParam::key_type&>())),
-               size_t>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::key_equal&>()(
-                   std::declval<const typename TypeParam::key_type&>(),
-                   std::declval<const typename TypeParam::key_type&>())),
-               bool>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
-                            typename TypeParam::reference>()));
-  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
-                            typename TypeParam::const_reference>()));
-  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
-                                typename TypeParam::allocator_type>::pointer,
-                            typename TypeParam::pointer>()));
-  EXPECT_TRUE(
-      (std::is_same<typename std::allocator_traits<
-                        typename TypeParam::allocator_type>::const_pointer,
-                    typename TypeParam::const_pointer>()));
-}
-
-TYPED_TEST_P(MembersTest, SimpleFunctions) {
-  EXPECT_GT(TypeParam().max_size(), 0);
-}
-
-TYPED_TEST_P(MembersTest, BeginEnd) {
-  TypeParam t = {typename TypeParam::value_type{}};
-  EXPECT_EQ(t.begin(), t.cbegin());
-  EXPECT_EQ(t.end(), t.cend());
-  EXPECT_NE(t.begin(), t.end());
-  EXPECT_NE(t.cbegin(), t.cend());
-}
-
-REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
diff --git a/tests/googletest/include/absl/container/internal/unordered_set_modifiers_test.h b/tests/googletest/include/absl/container/internal/unordered_set_modifiers_test.h
deleted file mode 100644
index d8864bb2..00000000
--- a/tests/googletest/include/absl/container/internal/unordered_set_modifiers_test.h
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/internal/hash_generator_testing.h"
-#include "absl/container/internal/hash_policy_testing.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordSet>
-class ModifiersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ModifiersTest);
-
-TYPED_TEST_P(ModifiersTest, Clear) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  m.clear();
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(m.empty());
-}
-
-TYPED_TEST_P(ModifiersTest, Insert) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.insert(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  p = m.insert(val);
-  EXPECT_FALSE(p.second);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto it = m.insert(m.end(), val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-  it = m.insert(it, val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  m.insert(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
-#if !defined(__GLIBCXX__)
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> base_values;
-  std::generate_n(std::back_inserter(base_values), 10,
-                  hash_internal::Generator<T>());
-  std::vector<T> values;
-  while (values.size() != 100) {
-    values.insert(values.end(), base_values.begin(), base_values.end());
-  }
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(values.begin(), values.end());
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-#endif
-}
-
-TYPED_TEST_P(ModifiersTest, Emplace) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.emplace(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  p = m.emplace(val);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, EmplaceHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.emplace_hint(m.end(), val);
-  EXPECT_EQ(val, *it);
-  it = m.emplace_hint(it, val);
-  EXPECT_EQ(val, *it);
-}
-
-template <class V>
-using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
-
-// In openmap we chose not to return the iterator from erase because that's
-// more expensive. As such we adapt erase to return an iterator here.
-struct EraseFirst {
-  template <class Map>
-  auto operator()(Map* m, int) const
-      -> IfNotVoid<decltype(m->erase(m->begin()))> {
-    return m->erase(m->begin());
-  }
-  template <class Map>
-  typename Map::iterator operator()(Map* m, ...) const {
-    auto it = m->begin();
-    m->erase(it++);
-    return it;
-  }
-};
-
-TYPED_TEST_P(ModifiersTest, Erase) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  std::vector<T> values2;
-  for (const auto& val : values)
-    if (val != *m.begin()) values2.push_back(val);
-  auto it = EraseFirst()(&m, 0);
-  ASSERT_TRUE(it != m.end());
-  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values2.begin(),
-                                                            values2.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, EraseRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  auto it = m.erase(m.begin(), m.end());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(it == m.end());
-}
-
-TYPED_TEST_P(ModifiersTest, EraseKey) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_EQ(1, m.erase(values[0]));
-  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
-                                                            values.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, Swap) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> v1;
-  std::vector<T> v2;
-  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
-  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
-  TypeParam m1(v1.begin(), v1.end());
-  TypeParam m2(v2.begin(), v2.end());
-  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v1));
-  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v2));
-  m1.swap(m2);
-  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v2));
-  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v1));
-}
-
-// TODO(alkis): Write tests for extract.
-// TODO(alkis): Write tests for merge.
-
-REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
-                            InsertRange, InsertWithinCapacity,
-                            InsertRangeWithinCapacity, Emplace, EmplaceHint,
-                            Erase, EraseRange, EraseKey, Swap);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
diff --git a/tests/googletest/include/absl/hash/hash_testing.h b/tests/googletest/include/absl/hash/hash_testing.h
deleted file mode 100644
index 1e1c5741..00000000
--- a/tests/googletest/include/absl/hash/hash_testing.h
+++ /dev/null
@@ -1,378 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_HASH_HASH_TESTING_H_
-#define ABSL_HASH_HASH_TESTING_H_
-
-#include <initializer_list>
-#include <tuple>
-#include <type_traits>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/hash/internal/spy_hash_state.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/str_cat.h"
-#include "absl/types/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Run the absl::Hash algorithm over all the elements passed in and verify that
-// their hash expansion is congruent with their `==` operator.
-//
-// It is used in conjunction with EXPECT_TRUE. Failures will output information
-// on what requirement failed and on which objects.
-//
-// Users should pass a collection of types as either an initializer list or a
-// container of cases.
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       {v1, v2, ..., vN}));
-//
-//   std::vector<MyType> cases;
-//   // Fill cases...
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(cases));
-//
-// Users can pass a variety of types for testing heterogeneous lookup with
-// `std::make_tuple`:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN)));
-//
-//
-// Ideally, the values passed should provide enough coverage of the `==`
-// operator and the AbslHashValue implementations.
-// For dynamically sized types, the empty state should usually be included in
-// the values.
-//
-// The function accepts an optional comparator function, in case that `==` is
-// not enough for the values provided.
-//
-// Usage:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN), MyCustomEq{}));
-//
-// It checks the following requirements:
-//   1. The expansion for a value is deterministic.
-//   2. For any two objects `a` and `b` in the sequence, if `a == b` evaluates
-//      to true, then their hash expansion must be equal.
-//   3. If `a == b` evaluates to false their hash expansion must be unequal.
-//   4. If `a == b` evaluates to false neither hash expansion can be a
-//      suffix of the other.
-//   5. AbslHashValue overloads should not be called by the user. They are only
-//      meant to be called by the framework. Users should call H::combine() and
-//      H::combine_contiguous().
-//   6. No moved-from instance of the hash state is used in the implementation
-//      of AbslHashValue.
-//
-// The values do not have to have the same type. This can be useful for
-// equivalent types that support heterogeneous lookup.
-//
-// A possible reason for breaking (2) is combining state in the hash expansion
-// that was not used in `==`.
-// For example:
-//
-// struct Bad2 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad2 x) {
-//     // Uses a and b.
-//     return H::combine(std::move(state), x.a, x.b);
-//   }
-//   friend bool operator==(Bad2 x, Bad2 y) {
-//     // Only uses a.
-//     return x.a == y.a;
-//   }
-// };
-//
-// As for (3), breaking this usually means that there is state being passed to
-// the `==` operator that is not used in the hash expansion.
-// For example:
-//
-// struct Bad3 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad3 x) {
-//     // Only uses a.
-//     return H::combine(std::move(state), x.a);
-//   }
-//   friend bool operator==(Bad3 x, Bad3 y) {
-//     // Uses a and b.
-//     return x.a == y.a && x.b == y.b;
-//   }
-// };
-//
-// Finally, a common way to break 4 is by combining dynamic ranges without
-// combining the size of the range.
-// For example:
-//
-// struct Bad4 {
-//   int *p, size;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad4 x) {
-//     return H::combine_contiguous(std::move(state), x.p, x.p + x.size);
-//   }
-//   friend bool operator==(Bad4 x, Bad4 y) {
-//    // Compare two ranges for equality. C++14 code can instead use std::equal.
-//     return absl::equal(x.p, x.p + x.size, y.p, y.p + y.size);
-//   }
-// };
-//
-// An easy solution to this is to combine the size after combining the range,
-// like so:
-// template <typename H>
-// friend H AbslHashValue(H state, Bad4 x) {
-//   return H::combine(
-//       H::combine_contiguous(std::move(state), x.p, x.p + x.size), x.size);
-// }
-//
-template <int&... ExplicitBarrier, typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values);
-
-template <int&... ExplicitBarrier, typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals);
-
-namespace hash_internal {
-
-struct PrintVisitor {
-  size_t index;
-  template <typename T>
-  std::string operator()(const T* value) const {
-    return absl::StrCat("#", index, "(", testing::PrintToString(*value), ")");
-  }
-};
-
-template <typename Eq>
-struct EqVisitor {
-  Eq eq;
-  template <typename T, typename U>
-  bool operator()(const T* t, const U* u) const {
-    return eq(*t, *u);
-  }
-};
-
-struct ExpandVisitor {
-  template <typename T>
-  SpyHashState operator()(const T* value) const {
-    return SpyHashState::combine(SpyHashState(), *value);
-  }
-};
-
-template <typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  using V = typename Container::value_type;
-
-  struct Info {
-    const V& value;
-    size_t index;
-    std::string ToString() const {
-      return absl::visit(PrintVisitor{index}, value);
-    }
-    SpyHashState expand() const { return absl::visit(ExpandVisitor{}, value); }
-  };
-
-  using EqClass = std::vector<Info>;
-  std::vector<EqClass> classes;
-
-  // Gather the values in equivalence classes.
-  size_t i = 0;
-  for (const auto& value : values) {
-    EqClass* c = nullptr;
-    for (auto& eqclass : classes) {
-      if (absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) {
-        c = &eqclass;
-        break;
-      }
-    }
-    if (c == nullptr) {
-      classes.emplace_back();
-      c = &classes.back();
-    }
-    c->push_back({value, i});
-    ++i;
-
-    // Verify potential errors captured by SpyHashState.
-    if (auto error = c->back().expand().error()) {
-      return testing::AssertionFailure() << *error;
-    }
-  }
-
-  if (classes.size() < 2) {
-    return testing::AssertionFailure()
-           << "At least two equivalence classes are expected.";
-  }
-
-  // We assume that equality is correctly implemented.
-  // Now we verify that AbslHashValue is also correctly implemented.
-
-  for (const auto& c : classes) {
-    // All elements of the equivalence class must have the same hash
-    // expansion.
-    const SpyHashState expected = c[0].expand();
-    for (const Info& v : c) {
-      if (v.expand() != v.expand()) {
-        return testing::AssertionFailure()
-               << "Hash expansion for " << v.ToString()
-               << " is non-deterministic.";
-      }
-      if (v.expand() != expected) {
-        return testing::AssertionFailure()
-               << "Values " << c[0].ToString() << " and " << v.ToString()
-               << " evaluate as equal but have an unequal hash expansion.";
-      }
-    }
-
-    // Elements from other classes must have different hash expansion.
-    for (const auto& c2 : classes) {
-      if (&c == &c2) continue;
-      const SpyHashState c2_hash = c2[0].expand();
-      switch (SpyHashState::Compare(expected, c2_hash)) {
-        case SpyHashState::CompareResult::kEqual:
-          return testing::AssertionFailure()
-                 << "Values " << c[0].ToString() << " and " << c2[0].ToString()
-                 << " evaluate as unequal but have an equal hash expansion.";
-        case SpyHashState::CompareResult::kBSuffixA:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c2[0].ToString()
-                 << " is a suffix of the hash expansion of " << c[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kASuffixB:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c[0].ToString()
-                 << " is a suffix of the hash expansion of " << c2[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kUnequal:
-          break;
-      }
-    }
-  }
-  return testing::AssertionSuccess();
-}
-
-template <typename... T>
-struct TypeSet {
-  template <typename U, bool = disjunction<std::is_same<T, U>...>::value>
-  struct Insert {
-    using type = TypeSet<U, T...>;
-  };
-  template <typename U>
-  struct Insert<U, true> {
-    using type = TypeSet;
-  };
-
-  template <template <typename...> class C>
-  using apply = C<T...>;
-};
-
-template <typename... T>
-struct MakeTypeSet : TypeSet<> {};
-template <typename T, typename... Ts>
-struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type {};
-
-template <typename... T>
-using VariantForTypes = typename MakeTypeSet<
-    const typename std::decay<T>::type*...>::template apply<absl::variant>;
-
-template <typename Container>
-struct ContainerAsVector {
-  using V = absl::variant<const typename Container::value_type*>;
-  using Out = std::vector<V>;
-
-  static Out Do(const Container& values) {
-    Out out;
-    for (const auto& v : values) out.push_back(&v);
-    return out;
-  }
-};
-
-template <typename... T>
-struct ContainerAsVector<std::tuple<T...>> {
-  using V = VariantForTypes<T...>;
-  using Out = std::vector<V>;
-
-  template <size_t... I>
-  static Out DoImpl(const std::tuple<T...>& tuple, absl::index_sequence<I...>) {
-    return Out{&std::get<I>(tuple)...};
-  }
-
-  static Out Do(const std::tuple<T...>& values) {
-    return DoImpl(values, absl::index_sequence_for<T...>());
-  }
-};
-
-template <>
-struct ContainerAsVector<std::tuple<>> {
-  static std::vector<VariantForTypes<int>> Do(std::tuple<>) { return {}; }
-};
-
-struct DefaultEquals {
-  template <typename T, typename U>
-  bool operator()(const T& t, const U& u) const {
-    return t == u;
-  }
-};
-
-}  // namespace hash_internal
-
-template <int&..., typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values), equals);
-}
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      equals);
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_HASH_TESTING_H_
diff --git a/tests/googletest/include/absl/log/check_test_impl.inc b/tests/googletest/include/absl/log/check_test_impl.inc
deleted file mode 100644
index d5c0aee4..00000000
--- a/tests/googletest/include/absl/log/check_test_impl.inc
+++ /dev/null
@@ -1,528 +0,0 @@
-//
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_LOG_CHECK_TEST_IMPL_H_
-#define ABSL_LOG_CHECK_TEST_IMPL_H_
-
-// Verify that both sets of macros behave identically by parameterizing the
-// entire test file.
-#ifndef ABSL_TEST_CHECK
-#error ABSL_TEST_CHECK must be defined for these tests to work.
-#endif
-
-#include <ostream>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/log/internal/test_helpers.h"
-#include "absl/status/status.h"
-
-// NOLINTBEGIN(misc-definitions-in-headers)
-
-namespace absl_log_internal {
-
-using ::testing::AllOf;
-using ::testing::HasSubstr;
-using ::testing::Not;
-
-auto* test_env ABSL_ATTRIBUTE_UNUSED = ::testing::AddGlobalTestEnvironment(
-    new absl::log_internal::LogTestEnvironment);
-
-#if GTEST_HAS_DEATH_TEST
-
-TEST(CHECKDeathTest, TestBasicValues) {
-  ABSL_TEST_CHECK(true);
-
-  EXPECT_DEATH(ABSL_TEST_CHECK(false), "Check failed: false");
-
-  int i = 2;
-  ABSL_TEST_CHECK(i != 3);  // NOLINT
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-TEST(CHECKTest, TestLogicExpressions) {
-  int i = 5;
-  ABSL_TEST_CHECK(i > 0 && i < 10);
-  ABSL_TEST_CHECK(i < 0 || i > 3);
-}
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-ABSL_CONST_INIT const auto global_var_check = [](int i) {
-  ABSL_TEST_CHECK(i > 0);  // NOLINT
-  return i + 1;
-}(3);
-
-ABSL_CONST_INIT const auto global_var = [](int i) {
-  ABSL_TEST_CHECK_GE(i, 0);  // NOLINT
-  return i + 1;
-}(global_var_check);
-#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG
-
-TEST(CHECKTest, TestPlacementsInCompoundStatements) {
-  // check placement inside if/else clauses
-  if (true) ABSL_TEST_CHECK(true);
-
-  if (false)
-    ;  // NOLINT
-  else
-    ABSL_TEST_CHECK(true);
-
-  switch (0)
-  case 0:
-    ABSL_TEST_CHECK(true);  // NOLINT
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-  constexpr auto var = [](int i) {
-    ABSL_TEST_CHECK(i > 0);  // NOLINT
-    return i + 1;
-  }(global_var);
-  (void)var;
-#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG
-}
-
-TEST(CHECKTest, TestBoolConvertible) {
-  struct Tester {
-  } tester;
-  ABSL_TEST_CHECK([&]() { return &tester; }());
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-TEST(CHECKDeathTest, TestChecksWithSideEffects) {
-  int var = 0;
-  ABSL_TEST_CHECK([&var]() {
-    ++var;
-    return true;
-  }());
-  EXPECT_EQ(var, 1);
-
-  EXPECT_DEATH(ABSL_TEST_CHECK([&var]() {
-                 ++var;
-                 return false;
-               }()) << var,
-               "Check failed: .* 2");
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-template <int a, int b>
-constexpr int sum() {
-  return a + b;
-}
-#define MACRO_ONE 1
-#define TEMPLATE_SUM(a, b) sum<a, b>()
-#define CONCAT(a, b) a b
-#define IDENTITY(x) x
-
-TEST(CHECKTest, TestPassingMacroExpansion) {
-  ABSL_TEST_CHECK(IDENTITY(true));
-  ABSL_TEST_CHECK_EQ(TEMPLATE_SUM(MACRO_ONE, 2), 3);
-  ABSL_TEST_CHECK_STREQ(CONCAT("x", "y"), "xy");
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-TEST(CHECKTest, TestMacroExpansionInMessage) {
-  auto MessageGen = []() { ABSL_TEST_CHECK(IDENTITY(false)); };
-  EXPECT_DEATH(MessageGen(), HasSubstr("IDENTITY(false)"));
-}
-
-TEST(CHECKTest, TestNestedMacroExpansionInMessage) {
-  EXPECT_DEATH(ABSL_TEST_CHECK(IDENTITY(false)), HasSubstr("IDENTITY(false)"));
-}
-
-TEST(CHECKTest, TestMacroExpansionCompare) {
-  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(IDENTITY(false), IDENTITY(true)),
-               HasSubstr("IDENTITY(false) == IDENTITY(true)"));
-  EXPECT_DEATH(ABSL_TEST_CHECK_GT(IDENTITY(1), IDENTITY(2)),
-               HasSubstr("IDENTITY(1) > IDENTITY(2)"));
-}
-
-TEST(CHECKTest, TestMacroExpansionStrCompare) {
-  EXPECT_DEATH(ABSL_TEST_CHECK_STREQ(IDENTITY("x"), IDENTITY("y")),
-               HasSubstr("IDENTITY(\"x\") == IDENTITY(\"y\")"));
-  EXPECT_DEATH(ABSL_TEST_CHECK_STRCASENE(IDENTITY("a"), IDENTITY("A")),
-               HasSubstr("IDENTITY(\"a\") != IDENTITY(\"A\")"));
-}
-
-TEST(CHECKTest, TestMacroExpansionStatus) {
-  EXPECT_DEATH(
-      ABSL_TEST_CHECK_OK(IDENTITY(absl::FailedPreconditionError("message"))),
-      HasSubstr("IDENTITY(absl::FailedPreconditionError(\"message\"))"));
-}
-
-TEST(CHECKTest, TestMacroExpansionComma) {
-  EXPECT_DEATH(ABSL_TEST_CHECK(TEMPLATE_SUM(MACRO_ONE, 2) == 4),
-               HasSubstr("TEMPLATE_SUM(MACRO_ONE, 2) == 4"));
-}
-
-TEST(CHECKTest, TestMacroExpansionCommaCompare) {
-  EXPECT_DEATH(
-      ABSL_TEST_CHECK_EQ(TEMPLATE_SUM(2, MACRO_ONE), TEMPLATE_SUM(3, 2)),
-      HasSubstr("TEMPLATE_SUM(2, MACRO_ONE) == TEMPLATE_SUM(3, 2)"));
-  EXPECT_DEATH(
-      ABSL_TEST_CHECK_GT(TEMPLATE_SUM(2, MACRO_ONE), TEMPLATE_SUM(3, 2)),
-      HasSubstr("TEMPLATE_SUM(2, MACRO_ONE) > TEMPLATE_SUM(3, 2)"));
-}
-
-TEST(CHECKTest, TestMacroExpansionCommaStrCompare) {
-  EXPECT_DEATH(ABSL_TEST_CHECK_STREQ(CONCAT("x", "y"), "z"),
-               HasSubstr("CONCAT(\"x\", \"y\") == \"z\""));
-  EXPECT_DEATH(ABSL_TEST_CHECK_STRNE(CONCAT("x", "y"), "xy"),
-               HasSubstr("CONCAT(\"x\", \"y\") != \"xy\""));
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-#undef TEMPLATE_SUM
-#undef CONCAT
-#undef MACRO
-#undef ONE
-
-#if GTEST_HAS_DEATH_TEST
-
-TEST(CHECKDeachTest, TestOrderOfInvocationsBetweenCheckAndMessage) {
-  int counter = 0;
-
-  auto GetStr = [&counter]() -> std::string {
-    return counter++ == 0 ? "" : "non-empty";
-  };
-
-  EXPECT_DEATH(ABSL_TEST_CHECK(!GetStr().empty()) << GetStr(),
-               HasSubstr("non-empty"));
-}
-
-TEST(CHECKTest, TestSecondaryFailure) {
-  auto FailingRoutine = []() {
-    ABSL_TEST_CHECK(false) << "Secondary";
-    return false;
-  };
-  EXPECT_DEATH(ABSL_TEST_CHECK(FailingRoutine()) << "Primary",
-               AllOf(HasSubstr("Secondary"), Not(HasSubstr("Primary"))));
-}
-
-TEST(CHECKTest, TestSecondaryFailureInMessage) {
-  auto MessageGen = []() {
-    ABSL_TEST_CHECK(false) << "Secondary";
-    return "Primary";
-  };
-  EXPECT_DEATH(ABSL_TEST_CHECK(false) << MessageGen(),
-               AllOf(HasSubstr("Secondary"), Not(HasSubstr("Primary"))));
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-TEST(CHECKTest, TestBinaryChecksWithPrimitives) {
-  ABSL_TEST_CHECK_EQ(1, 1);
-  ABSL_TEST_CHECK_NE(1, 2);
-  ABSL_TEST_CHECK_GE(1, 1);
-  ABSL_TEST_CHECK_GE(2, 1);
-  ABSL_TEST_CHECK_LE(1, 1);
-  ABSL_TEST_CHECK_LE(1, 2);
-  ABSL_TEST_CHECK_GT(2, 1);
-  ABSL_TEST_CHECK_LT(1, 2);
-}
-
-// For testing using CHECK*() on anonymous enums.
-enum { CASE_A, CASE_B };
-
-TEST(CHECKTest, TestBinaryChecksWithEnumValues) {
-  // Tests using CHECK*() on anonymous enums.
-  ABSL_TEST_CHECK_EQ(CASE_A, CASE_A);
-  ABSL_TEST_CHECK_NE(CASE_A, CASE_B);
-  ABSL_TEST_CHECK_GE(CASE_A, CASE_A);
-  ABSL_TEST_CHECK_GE(CASE_B, CASE_A);
-  ABSL_TEST_CHECK_LE(CASE_A, CASE_A);
-  ABSL_TEST_CHECK_LE(CASE_A, CASE_B);
-  ABSL_TEST_CHECK_GT(CASE_B, CASE_A);
-  ABSL_TEST_CHECK_LT(CASE_A, CASE_B);
-}
-
-TEST(CHECKTest, TestBinaryChecksWithNullptr) {
-  const void* p_null = nullptr;
-  const void* p_not_null = &p_null;
-  ABSL_TEST_CHECK_EQ(p_null, nullptr);
-  ABSL_TEST_CHECK_EQ(nullptr, p_null);
-  ABSL_TEST_CHECK_NE(p_not_null, nullptr);
-  ABSL_TEST_CHECK_NE(nullptr, p_not_null);
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-// Test logging of various char-typed values by failing CHECK*().
-TEST(CHECKDeathTest, TestComparingCharsValues) {
-  {
-    char a = ';';
-    char b = 'b';
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. 'b'\\)");
-    b = 1;
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. char value 1\\)");
-  }
-  {
-    signed char a = ';';
-    signed char b = 'b';
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. 'b'\\)");
-    b = -128;
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. signed char value -128\\)");
-  }
-  {
-    unsigned char a = ';';
-    unsigned char b = 'b';
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. 'b'\\)");
-    b = 128;
-    EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-                 "Check failed: a == b \\(';' vs. unsigned char value 128\\)");
-  }
-}
-
-TEST(CHECKDeathTest, TestNullValuesAreReportedCleanly) {
-  const char* a = nullptr;
-  const char* b = nullptr;
-  EXPECT_DEATH(ABSL_TEST_CHECK_NE(a, b),
-               "Check failed: a != b \\(\\(null\\) vs. \\(null\\)\\)");
-
-  a = "xx";
-  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-               "Check failed: a == b \\(xx vs. \\(null\\)\\)");
-  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(b, a),
-               "Check failed: b == a \\(\\(null\\) vs. xx\\)");
-
-  std::nullptr_t n{};
-  EXPECT_DEATH(ABSL_TEST_CHECK_NE(n, nullptr),
-               "Check failed: n != nullptr \\(\\(null\\) vs. \\(null\\)\\)");
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-TEST(CHECKTest, TestSTREQ) {
-  ABSL_TEST_CHECK_STREQ("this", "this");
-  ABSL_TEST_CHECK_STREQ(nullptr, nullptr);
-  ABSL_TEST_CHECK_STRCASEEQ("this", "tHiS");
-  ABSL_TEST_CHECK_STRCASEEQ(nullptr, nullptr);
-  ABSL_TEST_CHECK_STRNE("this", "tHiS");
-  ABSL_TEST_CHECK_STRNE("this", nullptr);
-  ABSL_TEST_CHECK_STRCASENE("this", "that");
-  ABSL_TEST_CHECK_STRCASENE(nullptr, "that");
-  ABSL_TEST_CHECK_STREQ((std::string("a") + "b").c_str(), "ab");
-  ABSL_TEST_CHECK_STREQ(std::string("test").c_str(),
-                        (std::string("te") + std::string("st")).c_str());
-}
-
-TEST(CHECKTest, TestComparisonPlacementsInCompoundStatements) {
-  // check placement inside if/else clauses
-  if (true) ABSL_TEST_CHECK_EQ(1, 1);
-  if (true) ABSL_TEST_CHECK_STREQ("c", "c");
-
-  if (false)
-    ;  // NOLINT
-  else
-    ABSL_TEST_CHECK_LE(0, 1);
-
-  if (false)
-    ;  // NOLINT
-  else
-    ABSL_TEST_CHECK_STRNE("a", "b");
-
-  switch (0)
-  case 0:
-    ABSL_TEST_CHECK_NE(1, 0);
-
-  switch (0)
-  case 0:
-    ABSL_TEST_CHECK_STRCASEEQ("A", "a");
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-  constexpr auto var = [](int i) {
-    ABSL_TEST_CHECK_GT(i, 0);
-    return i + 1;
-  }(global_var);
-  (void)var;
-
-  // CHECK_STR... checks are not supported in constexpr routines.
-  // constexpr auto var2 = [](int i) {
-  //  ABSL_TEST_CHECK_STRNE("c", "d");
-  //  return i + 1;
-  // }(global_var);
-
-#if defined(__GNUC__)
-  int var3 = (({ ABSL_TEST_CHECK_LE(1, 2); }), global_var < 10) ? 1 : 0;
-  (void)var3;
-
-  int var4 = (({ ABSL_TEST_CHECK_STREQ("a", "a"); }), global_var < 10) ? 1 : 0;
-  (void)var4;
-#endif  // __GNUC__
-#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG
-}
-
-TEST(CHECKTest, TestDCHECK) {
-#ifdef NDEBUG
-  ABSL_TEST_DCHECK(1 == 2) << " DCHECK's shouldn't be compiled in normal mode";
-#endif
-  ABSL_TEST_DCHECK(1 == 1);  // NOLINT(readability/check)
-  ABSL_TEST_DCHECK_EQ(1, 1);
-  ABSL_TEST_DCHECK_NE(1, 2);
-  ABSL_TEST_DCHECK_GE(1, 1);
-  ABSL_TEST_DCHECK_GE(2, 1);
-  ABSL_TEST_DCHECK_LE(1, 1);
-  ABSL_TEST_DCHECK_LE(1, 2);
-  ABSL_TEST_DCHECK_GT(2, 1);
-  ABSL_TEST_DCHECK_LT(1, 2);
-
-  // Test DCHECK on std::nullptr_t
-  const void* p_null = nullptr;
-  const void* p_not_null = &p_null;
-  ABSL_TEST_DCHECK_EQ(p_null, nullptr);
-  ABSL_TEST_DCHECK_EQ(nullptr, p_null);
-  ABSL_TEST_DCHECK_NE(p_not_null, nullptr);
-  ABSL_TEST_DCHECK_NE(nullptr, p_not_null);
-}
-
-TEST(CHECKTest, TestQCHECK) {
-  // The tests that QCHECK does the same as CHECK
-  ABSL_TEST_QCHECK(1 == 1);  // NOLINT(readability/check)
-  ABSL_TEST_QCHECK_EQ(1, 1);
-  ABSL_TEST_QCHECK_NE(1, 2);
-  ABSL_TEST_QCHECK_GE(1, 1);
-  ABSL_TEST_QCHECK_GE(2, 1);
-  ABSL_TEST_QCHECK_LE(1, 1);
-  ABSL_TEST_QCHECK_LE(1, 2);
-  ABSL_TEST_QCHECK_GT(2, 1);
-  ABSL_TEST_QCHECK_LT(1, 2);
-
-  // Tests using QCHECK*() on anonymous enums.
-  ABSL_TEST_QCHECK_EQ(CASE_A, CASE_A);
-  ABSL_TEST_QCHECK_NE(CASE_A, CASE_B);
-  ABSL_TEST_QCHECK_GE(CASE_A, CASE_A);
-  ABSL_TEST_QCHECK_GE(CASE_B, CASE_A);
-  ABSL_TEST_QCHECK_LE(CASE_A, CASE_A);
-  ABSL_TEST_QCHECK_LE(CASE_A, CASE_B);
-  ABSL_TEST_QCHECK_GT(CASE_B, CASE_A);
-  ABSL_TEST_QCHECK_LT(CASE_A, CASE_B);
-}
-
-TEST(CHECKTest, TestQCHECKPlacementsInCompoundStatements) {
-  // check placement inside if/else clauses
-  if (true) ABSL_TEST_QCHECK(true);
-
-  if (false)
-    ;  // NOLINT
-  else
-    ABSL_TEST_QCHECK(true);
-
-  if (false)
-    ;  // NOLINT
-  else
-    ABSL_TEST_QCHECK(true);
-
-  switch (0)
-  case 0:
-    ABSL_TEST_QCHECK(true);
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-  constexpr auto var = [](int i) {
-    ABSL_TEST_QCHECK(i > 0);  // NOLINT
-    return i + 1;
-  }(global_var);
-  (void)var;
-
-#if defined(__GNUC__)
-  int var2 = (({ ABSL_TEST_CHECK_LE(1, 2); }), global_var < 10) ? 1 : 0;
-  (void)var2;
-#endif  // __GNUC__
-#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG
-}
-
-class ComparableType {
- public:
-  explicit ComparableType(int v) : v_(v) {}
-
-  void MethodWithCheck(int i) {
-    ABSL_TEST_CHECK_EQ(*this, i);
-    ABSL_TEST_CHECK_EQ(i, *this);
-  }
-
-  int Get() const { return v_; }
-
- private:
-  friend bool operator==(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ == rhs.v_;
-  }
-  friend bool operator!=(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ != rhs.v_;
-  }
-  friend bool operator<(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ < rhs.v_;
-  }
-  friend bool operator<=(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ <= rhs.v_;
-  }
-  friend bool operator>(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ > rhs.v_;
-  }
-  friend bool operator>=(const ComparableType& lhs, const ComparableType& rhs) {
-    return lhs.v_ >= rhs.v_;
-  }
-  friend bool operator==(const ComparableType& lhs, int rhs) {
-    return lhs.v_ == rhs;
-  }
-  friend bool operator==(int lhs, const ComparableType& rhs) {
-    return lhs == rhs.v_;
-  }
-
-  friend std::ostream& operator<<(std::ostream& out, const ComparableType& v) {
-    return out << "ComparableType{" << v.Get() << "}";
-  }
-
-  int v_;
-};
-
-TEST(CHECKTest, TestUserDefinedCompOp) {
-  ABSL_TEST_CHECK_EQ(ComparableType{0}, ComparableType{0});
-  ABSL_TEST_CHECK_NE(ComparableType{1}, ComparableType{2});
-  ABSL_TEST_CHECK_LT(ComparableType{1}, ComparableType{2});
-  ABSL_TEST_CHECK_LE(ComparableType{1}, ComparableType{2});
-  ABSL_TEST_CHECK_GT(ComparableType{2}, ComparableType{1});
-  ABSL_TEST_CHECK_GE(ComparableType{2}, ComparableType{2});
-}
-
-TEST(CHECKTest, TestCheckInMethod) {
-  ComparableType v{1};
-  v.MethodWithCheck(1);
-}
-
-TEST(CHECKDeathTest, TestUserDefinedStreaming) {
-  ComparableType v1{1};
-  ComparableType v2{2};
-
-  EXPECT_DEATH(
-      ABSL_TEST_CHECK_EQ(v1, v2),
-      HasSubstr(
-          "Check failed: v1 == v2 (ComparableType{1} vs. ComparableType{2})"));
-}
-
-}  // namespace absl_log_internal
-
-// NOLINTEND(misc-definitions-in-headers)
-
-#endif  // ABSL_LOG_CHECK_TEST_IMPL_H_
diff --git a/tests/googletest/include/absl/log/internal/test_matchers.cc b/tests/googletest/include/absl/log/internal/test_matchers.cc
deleted file mode 100644
index 8c6515c4..00000000
--- a/tests/googletest/include/absl/log/internal/test_matchers.cc
+++ /dev/null
@@ -1,217 +0,0 @@
-//
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/log/internal/test_matchers.h"
-
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/log/internal/test_helpers.h"
-#include "absl/strings/string_view.h"
-#include "absl/time/clock.h"
-#include "absl/time/time.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-namespace {
-using ::testing::_;
-using ::testing::AllOf;
-using ::testing::Ge;
-using ::testing::HasSubstr;
-using ::testing::MakeMatcher;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-using ::testing::Not;
-using ::testing::Property;
-using ::testing::ResultOf;
-using ::testing::Truly;
-
-class AsStringImpl final
-    : public MatcherInterface<absl::string_view> {
- public:
-  explicit AsStringImpl(
-      const Matcher<const std::string&>& str_matcher)
-      : str_matcher_(str_matcher) {}
-  bool MatchAndExplain(
-      absl::string_view actual,
-      MatchResultListener* listener) const override {
-    return str_matcher_.MatchAndExplain(std::string(actual), listener);
-  }
-  void DescribeTo(std::ostream* os) const override {
-    return str_matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream* os) const override {
-    return str_matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  const Matcher<const std::string&> str_matcher_;
-};
-
-class MatchesOstreamImpl final
-    : public MatcherInterface<absl::string_view> {
- public:
-  explicit MatchesOstreamImpl(std::string expected)
-      : expected_(std::move(expected)) {}
-  bool MatchAndExplain(absl::string_view actual,
-                       MatchResultListener*) const override {
-    return actual == expected_;
-  }
-  void DescribeTo(std::ostream* os) const override {
-    *os << "matches the contents of the ostringstream, which are \""
-        << expected_ << "\"";
-  }
-
-  void DescribeNegationTo(std::ostream* os) const override {
-    *os << "does not match the contents of the ostringstream, which are \""
-        << expected_ << "\"";
-  }
-
- private:
-  const std::string expected_;
-};
-}  // namespace
-
-Matcher<absl::string_view> AsString(
-    const Matcher<const std::string&>& str_matcher) {
-  return MakeMatcher(new AsStringImpl(str_matcher));
-}
-
-Matcher<const absl::LogEntry&> SourceFilename(
-    const Matcher<absl::string_view>& source_filename) {
-  return Property("source_filename", &absl::LogEntry::source_filename,
-                  source_filename);
-}
-
-Matcher<const absl::LogEntry&> SourceBasename(
-    const Matcher<absl::string_view>& source_basename) {
-  return Property("source_basename", &absl::LogEntry::source_basename,
-                  source_basename);
-}
-
-Matcher<const absl::LogEntry&> SourceLine(
-    const Matcher<int>& source_line) {
-  return Property("source_line", &absl::LogEntry::source_line, source_line);
-}
-
-Matcher<const absl::LogEntry&> Prefix(
-    const Matcher<bool>& prefix) {
-  return Property("prefix", &absl::LogEntry::prefix, prefix);
-}
-
-Matcher<const absl::LogEntry&> LogSeverity(
-    const Matcher<absl::LogSeverity>& log_severity) {
-  return Property("log_severity", &absl::LogEntry::log_severity, log_severity);
-}
-
-Matcher<const absl::LogEntry&> Timestamp(
-    const Matcher<absl::Time>& timestamp) {
-  return Property("timestamp", &absl::LogEntry::timestamp, timestamp);
-}
-
-Matcher<const absl::LogEntry&> TimestampInMatchWindow() {
-  return Property("timestamp", &absl::LogEntry::timestamp,
-                  AllOf(Ge(absl::Now()), Truly([](absl::Time arg) {
-                          return arg <= absl::Now();
-                        })));
-}
-
-Matcher<const absl::LogEntry&> ThreadID(
-    const Matcher<absl::LogEntry::tid_t>& tid) {
-  return Property("tid", &absl::LogEntry::tid, tid);
-}
-
-Matcher<const absl::LogEntry&> TextMessageWithPrefixAndNewline(
-    const Matcher<absl::string_view>&
-        text_message_with_prefix_and_newline) {
-  return Property("text_message_with_prefix_and_newline",
-                  &absl::LogEntry::text_message_with_prefix_and_newline,
-                  text_message_with_prefix_and_newline);
-}
-
-Matcher<const absl::LogEntry&> TextMessageWithPrefix(
-    const Matcher<absl::string_view>& text_message_with_prefix) {
-  return Property("text_message_with_prefix",
-                  &absl::LogEntry::text_message_with_prefix,
-                  text_message_with_prefix);
-}
-
-Matcher<const absl::LogEntry&> TextMessage(
-    const Matcher<absl::string_view>& text_message) {
-  return Property("text_message", &absl::LogEntry::text_message, text_message);
-}
-
-Matcher<const absl::LogEntry&> TextPrefix(
-    const Matcher<absl::string_view>& text_prefix) {
-  return ResultOf(
-      [](const absl::LogEntry& entry) {
-        absl::string_view msg = entry.text_message_with_prefix();
-        msg.remove_suffix(entry.text_message().size());
-        return msg;
-      },
-      text_prefix);
-}
-Matcher<const absl::LogEntry&> RawEncodedMessage(
-    const Matcher<absl::string_view>& raw_encoded_message) {
-  return Property("encoded_message", &absl::LogEntry::encoded_message,
-                  raw_encoded_message);
-}
-
-Matcher<const absl::LogEntry&> Verbosity(
-    const Matcher<int>& verbosity) {
-  return Property("verbosity", &absl::LogEntry::verbosity, verbosity);
-}
-
-Matcher<const absl::LogEntry&> Stacktrace(
-    const Matcher<absl::string_view>& stacktrace) {
-  return Property("stacktrace", &absl::LogEntry::stacktrace, stacktrace);
-}
-
-Matcher<absl::string_view> MatchesOstream(
-    const std::ostringstream& stream) {
-  return MakeMatcher(new MatchesOstreamImpl(stream.str()));
-}
-
-// We need to validate what is and isn't logged as the process dies due to
-// `FATAL`, `QFATAL`, `CHECK`, etc., but assertions inside a death test
-// subprocess don't directly affect the pass/fail status of the parent process.
-// Instead, we use the mock actions `DeathTestExpectedLogging` and
-// `DeathTestUnexpectedLogging` to write specific phrases to `stderr` that we
-// can validate in the parent process using this matcher.
-Matcher<const std::string&> DeathTestValidateExpectations() {
-  if (log_internal::LoggingEnabledAt(absl::LogSeverity::kFatal)) {
-    return Matcher<const std::string&>(
-        AllOf(HasSubstr("Mock received expected entry"),
-              Not(HasSubstr("Mock received unexpected entry"))));
-  }
-  // If `FATAL` logging is disabled, neither message should have been written.
-  return Matcher<const std::string&>(
-      AllOf(Not(HasSubstr("Mock received expected entry")),
-            Not(HasSubstr("Mock received unexpected entry"))));
-}
-
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/tests/googletest/include/absl/log/internal/test_matchers.h b/tests/googletest/include/absl/log/internal/test_matchers.h
deleted file mode 100644
index fc653a91..00000000
--- a/tests/googletest/include/absl/log/internal/test_matchers.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: log/internal/test_matchers.h
-// -----------------------------------------------------------------------------
-//
-// This file declares Googletest's matchers used in the Abseil Logging library
-// unit tests.
-
-#ifndef ABSL_LOG_INTERNAL_TEST_MATCHERS_H_
-#define ABSL_LOG_INTERNAL_TEST_MATCHERS_H_
-
-#include <iosfwd>
-#include <sstream>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/base/log_severity.h"
-#include "absl/log/internal/test_helpers.h"
-#include "absl/log/log_entry.h"
-#include "absl/strings/string_view.h"
-#include "absl/time/time.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-// In some configurations, Googletest's string matchers (e.g.
-// `::testing::EndsWith`) need help to match `absl::string_view`.
-::testing::Matcher<absl::string_view> AsString(
-    const ::testing::Matcher<const std::string&>& str_matcher);
-
-// These matchers correspond to the components of `absl::LogEntry`.
-::testing::Matcher<const absl::LogEntry&> SourceFilename(
-    const ::testing::Matcher<absl::string_view>& source_filename);
-::testing::Matcher<const absl::LogEntry&> SourceBasename(
-    const ::testing::Matcher<absl::string_view>& source_basename);
-// Be careful with this one; multi-line statements using `__LINE__` evaluate
-// differently on different platforms.  In particular, the MSVC implementation
-// of `EXPECT_DEATH` returns the line number of the macro expansion to all lines
-// within the code block that's expected to die.
-::testing::Matcher<const absl::LogEntry&> SourceLine(
-    const ::testing::Matcher<int>& source_line);
-::testing::Matcher<const absl::LogEntry&> Prefix(
-    const ::testing::Matcher<bool>& prefix);
-::testing::Matcher<const absl::LogEntry&> LogSeverity(
-    const ::testing::Matcher<absl::LogSeverity>& log_severity);
-::testing::Matcher<const absl::LogEntry&> Timestamp(
-    const ::testing::Matcher<absl::Time>& timestamp);
-// Matches if the `LogEntry`'s timestamp falls after the instantiation of this
-// matcher and before its execution, as is normal when used with EXPECT_CALL.
-::testing::Matcher<const absl::LogEntry&> TimestampInMatchWindow();
-::testing::Matcher<const absl::LogEntry&> ThreadID(
-    const ::testing::Matcher<absl::LogEntry::tid_t>&);
-::testing::Matcher<const absl::LogEntry&> TextMessageWithPrefixAndNewline(
-    const ::testing::Matcher<absl::string_view>&
-        text_message_with_prefix_and_newline);
-::testing::Matcher<const absl::LogEntry&> TextMessageWithPrefix(
-    const ::testing::Matcher<absl::string_view>& text_message_with_prefix);
-::testing::Matcher<const absl::LogEntry&> TextMessage(
-    const ::testing::Matcher<absl::string_view>& text_message);
-::testing::Matcher<const absl::LogEntry&> TextPrefix(
-    const ::testing::Matcher<absl::string_view>& text_prefix);
-::testing::Matcher<const absl::LogEntry&> Verbosity(
-    const ::testing::Matcher<int>& verbosity);
-::testing::Matcher<const absl::LogEntry&> Stacktrace(
-    const ::testing::Matcher<absl::string_view>& stacktrace);
-// Behaves as `Eq(stream.str())`, but produces better failure messages.
-::testing::Matcher<absl::string_view> MatchesOstream(
-    const std::ostringstream& stream);
-::testing::Matcher<const std::string&> DeathTestValidateExpectations();
-
-::testing::Matcher<const absl::LogEntry&> RawEncodedMessage(
-    const ::testing::Matcher<absl::string_view>& raw_encoded_message);
-#define ENCODED_MESSAGE(message_matcher) ::testing::_
-
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_LOG_INTERNAL_TEST_MATCHERS_H_
diff --git a/tests/googletest/include/absl/log/log_basic_test_impl.inc b/tests/googletest/include/absl/log/log_basic_test_impl.inc
deleted file mode 100644
index f3400095..00000000
--- a/tests/googletest/include/absl/log/log_basic_test_impl.inc
+++ /dev/null
@@ -1,455 +0,0 @@
-//
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// The testcases in this file are expected to pass or be skipped with any value
-// of ABSL_MIN_LOG_LEVEL
-
-#ifndef ABSL_LOG_LOG_BASIC_TEST_IMPL_H_
-#define ABSL_LOG_LOG_BASIC_TEST_IMPL_H_
-
-// Verify that both sets of macros behave identically by parameterizing the
-// entire test file.
-#ifndef ABSL_TEST_LOG
-#error ABSL_TEST_LOG must be defined for these tests to work.
-#endif
-
-#include <cerrno>
-#include <sstream>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/internal/sysinfo.h"
-#include "absl/base/log_severity.h"
-#include "absl/log/globals.h"
-#include "absl/log/internal/test_actions.h"
-#include "absl/log/internal/test_helpers.h"
-#include "absl/log/internal/test_matchers.h"
-#include "absl/log/log_entry.h"
-#include "absl/log/scoped_mock_log.h"
-
-namespace absl_log_internal {
-#if GTEST_HAS_DEATH_TEST
-using ::absl::log_internal::DeathTestExpectedLogging;
-using ::absl::log_internal::DeathTestUnexpectedLogging;
-using ::absl::log_internal::DeathTestValidateExpectations;
-using ::absl::log_internal::DiedOfFatal;
-using ::absl::log_internal::DiedOfQFatal;
-#endif
-using ::absl::log_internal::LoggingEnabledAt;
-using ::absl::log_internal::LogSeverity;
-using ::absl::log_internal::Prefix;
-using ::absl::log_internal::SourceBasename;
-using ::absl::log_internal::SourceFilename;
-using ::absl::log_internal::SourceLine;
-using ::absl::log_internal::Stacktrace;
-using ::absl::log_internal::TextMessage;
-using ::absl::log_internal::ThreadID;
-using ::absl::log_internal::TimestampInMatchWindow;
-using ::absl::log_internal::Verbosity;
-using ::testing::AnyNumber;
-using ::testing::Eq;
-using ::testing::IsEmpty;
-using ::testing::IsTrue;
-
-class BasicLogTest : public testing::TestWithParam<absl::LogSeverityAtLeast> {};
-
-std::string ThresholdName(
-    testing::TestParamInfo<absl::LogSeverityAtLeast> severity) {
-  std::stringstream ostr;
-  ostr << severity.param;
-  return ostr.str().substr(
-      severity.param == absl::LogSeverityAtLeast::kInfinity ? 0 : 2);
-}
-
-INSTANTIATE_TEST_SUITE_P(WithParam, BasicLogTest,
-                         testing::Values(absl::LogSeverityAtLeast::kInfo,
-                                         absl::LogSeverityAtLeast::kWarning,
-                                         absl::LogSeverityAtLeast::kError,
-                                         absl::LogSeverityAtLeast::kFatal,
-                                         absl::LogSeverityAtLeast::kInfinity),
-                         ThresholdName);
-
-TEST_P(BasicLogTest, Info) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [] { ABSL_TEST_LOG(INFO) << "hello world"; };
-
-  if (LoggingEnabledAt(absl::LogSeverity::kInfo)) {
-    EXPECT_CALL(
-        test_sink,
-        Send(AllOf(SourceFilename(Eq(__FILE__)),
-                   SourceBasename(Eq("log_basic_test_impl.inc")),
-                   SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                   LogSeverity(Eq(absl::LogSeverity::kInfo)),
-                   TimestampInMatchWindow(),
-                   ThreadID(Eq(absl::base_internal::GetTID())),
-                   TextMessage(Eq("hello world")),
-                   Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                   ENCODED_MESSAGE(EqualsProto(R"pb(value {
-                                                      literal: "hello world"
-                                                    })pb")),
-                   Stacktrace(IsEmpty()))));
-  }
-
-  test_sink.StartCapturingLogs();
-  do_log();
-}
-
-TEST_P(BasicLogTest, Warning) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [] { ABSL_TEST_LOG(WARNING) << "hello world"; };
-
-  if (LoggingEnabledAt(absl::LogSeverity::kWarning)) {
-    EXPECT_CALL(
-        test_sink,
-        Send(AllOf(SourceFilename(Eq(__FILE__)),
-                   SourceBasename(Eq("log_basic_test_impl.inc")),
-                   SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                   LogSeverity(Eq(absl::LogSeverity::kWarning)),
-                   TimestampInMatchWindow(),
-                   ThreadID(Eq(absl::base_internal::GetTID())),
-                   TextMessage(Eq("hello world")),
-                   Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                   ENCODED_MESSAGE(EqualsProto(R"pb(value {
-                                                      literal: "hello world"
-                                                    })pb")),
-                   Stacktrace(IsEmpty()))));
-  }
-
-  test_sink.StartCapturingLogs();
-  do_log();
-}
-
-TEST_P(BasicLogTest, Error) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [] { ABSL_TEST_LOG(ERROR) << "hello world"; };
-
-  if (LoggingEnabledAt(absl::LogSeverity::kError)) {
-    EXPECT_CALL(
-        test_sink,
-        Send(AllOf(SourceFilename(Eq(__FILE__)),
-                   SourceBasename(Eq("log_basic_test_impl.inc")),
-                   SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                   LogSeverity(Eq(absl::LogSeverity::kError)),
-                   TimestampInMatchWindow(),
-                   ThreadID(Eq(absl::base_internal::GetTID())),
-                   TextMessage(Eq("hello world")),
-                   Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                   ENCODED_MESSAGE(EqualsProto(R"pb(value {
-                                                      literal: "hello world"
-                                                    })pb")),
-                   Stacktrace(IsEmpty()))));
-  }
-
-  test_sink.StartCapturingLogs();
-  do_log();
-}
-
-#if GTEST_HAS_DEATH_TEST
-using BasicLogDeathTest = BasicLogTest;
-
-INSTANTIATE_TEST_SUITE_P(WithParam, BasicLogDeathTest,
-                         testing::Values(absl::LogSeverityAtLeast::kInfo,
-                                         absl::LogSeverityAtLeast::kFatal,
-                                         absl::LogSeverityAtLeast::kInfinity),
-                         ThresholdName);
-
-TEST_P(BasicLogDeathTest, Fatal) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [] { ABSL_TEST_LOG(FATAL) << "hello world"; };
-
-  EXPECT_EXIT(
-      {
-        absl::ScopedMockLog test_sink(
-            absl::MockLogDefault::kDisallowUnexpected);
-
-        EXPECT_CALL(test_sink, Send)
-            .Times(AnyNumber())
-            .WillRepeatedly(DeathTestUnexpectedLogging());
-
-        ::testing::InSequence s;
-
-        // Note the logic in DeathTestValidateExpectations() caters for the case
-        // of logging being disabled at FATAL level.
-
-        if (LoggingEnabledAt(absl::LogSeverity::kFatal)) {
-          // The first call without the stack trace.
-          EXPECT_CALL(
-              test_sink,
-              Send(AllOf(SourceFilename(Eq(__FILE__)),
-                         SourceBasename(Eq("log_basic_test_impl.inc")),
-                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
-                         TimestampInMatchWindow(),
-                         ThreadID(Eq(absl::base_internal::GetTID())),
-                         TextMessage(Eq("hello world")),
-                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                         ENCODED_MESSAGE(EqualsProto(
-                             R"pb(value { literal: "hello world" })pb")),
-                         Stacktrace(IsEmpty()))))
-              .WillOnce(DeathTestExpectedLogging());
-
-          // The second call with the stack trace.
-          EXPECT_CALL(
-              test_sink,
-              Send(AllOf(SourceFilename(Eq(__FILE__)),
-                         SourceBasename(Eq("log_basic_test_impl.inc")),
-                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
-                         TimestampInMatchWindow(),
-                         ThreadID(Eq(absl::base_internal::GetTID())),
-                         TextMessage(Eq("hello world")),
-                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                         ENCODED_MESSAGE(EqualsProto(
-                             R"pb(value { literal: "hello world" })pb")),
-                         Stacktrace(Not(IsEmpty())))))
-              .WillOnce(DeathTestExpectedLogging());
-        }
-
-        test_sink.StartCapturingLogs();
-        do_log();
-      },
-      DiedOfFatal, DeathTestValidateExpectations());
-}
-
-TEST_P(BasicLogDeathTest, QFatal) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [] { ABSL_TEST_LOG(QFATAL) << "hello world"; };
-
-  EXPECT_EXIT(
-      {
-        absl::ScopedMockLog test_sink(
-            absl::MockLogDefault::kDisallowUnexpected);
-
-        EXPECT_CALL(test_sink, Send)
-            .Times(AnyNumber())
-            .WillRepeatedly(DeathTestUnexpectedLogging());
-
-        if (LoggingEnabledAt(absl::LogSeverity::kFatal)) {
-          EXPECT_CALL(
-              test_sink,
-              Send(AllOf(SourceFilename(Eq(__FILE__)),
-                         SourceBasename(Eq("log_basic_test_impl.inc")),
-                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
-                         TimestampInMatchWindow(),
-                         ThreadID(Eq(absl::base_internal::GetTID())),
-                         TextMessage(Eq("hello world")),
-                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                         ENCODED_MESSAGE(EqualsProto(
-                             R"pb(value { literal: "hello world" })pb")),
-                         Stacktrace(IsEmpty()))))
-              .WillOnce(DeathTestExpectedLogging());
-        }
-
-        test_sink.StartCapturingLogs();
-        do_log();
-      },
-      DiedOfQFatal, DeathTestValidateExpectations());
-}
-#endif
-
-TEST_P(BasicLogTest, Level) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  for (auto severity : {absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
-                        absl::LogSeverity::kError}) {
-    absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-    const int log_line = __LINE__ + 2;
-    auto do_log = [severity] {
-      ABSL_TEST_LOG(LEVEL(severity)) << "hello world";
-    };
-
-    if (LoggingEnabledAt(severity)) {
-      EXPECT_CALL(
-          test_sink,
-          Send(AllOf(SourceFilename(Eq(__FILE__)),
-                     SourceBasename(Eq("log_basic_test_impl.inc")),
-                     SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                     LogSeverity(Eq(severity)), TimestampInMatchWindow(),
-                     ThreadID(Eq(absl::base_internal::GetTID())),
-                     TextMessage(Eq("hello world")),
-                     Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                     ENCODED_MESSAGE(EqualsProto(R"pb(value {
-                                                        literal: "hello world"
-                                                      })pb")),
-                     Stacktrace(IsEmpty()))));
-    }
-    test_sink.StartCapturingLogs();
-    do_log();
-  }
-}
-
-#if GTEST_HAS_DEATH_TEST
-TEST_P(BasicLogDeathTest, Level) {
-  // TODO(b/242568884): re-enable once bug is fixed.
-  // absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  // Ensure that `severity` is not a compile-time constant to prove that
-  // `LOG(LEVEL(severity))` works regardless:
-  auto volatile severity = absl::LogSeverity::kFatal;
-
-  const int log_line = __LINE__ + 1;
-  auto do_log = [severity] { ABSL_TEST_LOG(LEVEL(severity)) << "hello world"; };
-
-  EXPECT_EXIT(
-      {
-        absl::ScopedMockLog test_sink(
-            absl::MockLogDefault::kDisallowUnexpected);
-
-        EXPECT_CALL(test_sink, Send)
-            .Times(AnyNumber())
-            .WillRepeatedly(DeathTestUnexpectedLogging());
-
-        ::testing::InSequence s;
-
-        if (LoggingEnabledAt(absl::LogSeverity::kFatal)) {
-          EXPECT_CALL(
-              test_sink,
-              Send(AllOf(SourceFilename(Eq(__FILE__)),
-                         SourceBasename(Eq("log_basic_test_impl.inc")),
-                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
-                         TimestampInMatchWindow(),
-                         ThreadID(Eq(absl::base_internal::GetTID())),
-                         TextMessage(Eq("hello world")),
-                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                         ENCODED_MESSAGE(EqualsProto(
-                             R"pb(value { literal: "hello world" })pb")),
-                         Stacktrace(IsEmpty()))))
-              .WillOnce(DeathTestExpectedLogging());
-
-          EXPECT_CALL(
-              test_sink,
-              Send(AllOf(SourceFilename(Eq(__FILE__)),
-                         SourceBasename(Eq("log_basic_test_impl.inc")),
-                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
-                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
-                         TimestampInMatchWindow(),
-                         ThreadID(Eq(absl::base_internal::GetTID())),
-                         TextMessage(Eq("hello world")),
-                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
-                         ENCODED_MESSAGE(EqualsProto(
-                             R"pb(value { literal: "hello world" })pb")),
-                         Stacktrace(Not(IsEmpty())))))
-              .WillOnce(DeathTestExpectedLogging());
-        }
-
-        test_sink.StartCapturingLogs();
-        do_log();
-      },
-      DiedOfFatal, DeathTestValidateExpectations());
-}
-#endif
-
-TEST_P(BasicLogTest, LevelClampsNegativeValues) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  if (!LoggingEnabledAt(absl::LogSeverity::kInfo)) {
-    GTEST_SKIP() << "This test cases required INFO log to be enabled";
-    return;
-  }
-
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-  EXPECT_CALL(test_sink, Send(LogSeverity(Eq(absl::LogSeverity::kInfo))));
-
-  test_sink.StartCapturingLogs();
-  ABSL_TEST_LOG(LEVEL(-1)) << "hello world";
-}
-
-TEST_P(BasicLogTest, LevelClampsLargeValues) {
-  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
-
-  if (!LoggingEnabledAt(absl::LogSeverity::kError)) {
-    GTEST_SKIP() << "This test cases required ERROR log to be enabled";
-    return;
-  }
-
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-
-  EXPECT_CALL(test_sink, Send(LogSeverity(Eq(absl::LogSeverity::kError))));
-
-  test_sink.StartCapturingLogs();
-  ABSL_TEST_LOG(LEVEL(static_cast<int>(absl::LogSeverity::kFatal) + 1))
-      << "hello world";
-}
-
-TEST(ErrnoPreservationTest, InSeverityExpression) {
-  errno = 77;
-  int saved_errno;
-  ABSL_TEST_LOG(LEVEL((saved_errno = errno, absl::LogSeverity::kInfo)));
-  EXPECT_THAT(saved_errno, Eq(77));
-}
-
-TEST(ErrnoPreservationTest, InStreamedExpression) {
-  if (!LoggingEnabledAt(absl::LogSeverity::kInfo)) {
-    GTEST_SKIP() << "This test cases required INFO log to be enabled";
-    return;
-  }
-
-  errno = 77;
-  int saved_errno = 0;
-  ABSL_TEST_LOG(INFO) << (saved_errno = errno, "hello world");
-  EXPECT_THAT(saved_errno, Eq(77));
-}
-
-TEST(ErrnoPreservationTest, AfterStatement) {
-  errno = 77;
-  ABSL_TEST_LOG(INFO);
-  const int saved_errno = errno;
-  EXPECT_THAT(saved_errno, Eq(77));
-}
-
-// Tests that using a variable/parameter in a logging statement suppresses
-// unused-variable/parameter warnings.
-// -----------------------------------------------------------------------
-class UnusedVariableWarningCompileTest {
-  // These four don't prove anything unless `ABSL_MIN_LOG_LEVEL` is greater than
-  // `kInfo`.
-  static void LoggedVariable() {
-    const int x = 0;
-    ABSL_TEST_LOG(INFO) << x;
-  }
-  static void LoggedParameter(const int x) { ABSL_TEST_LOG(INFO) << x; }
-  static void SeverityVariable() {
-    const int x = 0;
-    ABSL_TEST_LOG(LEVEL(x)) << "hello world";
-  }
-  static void SeverityParameter(const int x) {
-    ABSL_TEST_LOG(LEVEL(x)) << "hello world";
-  }
-};
-
-}  // namespace absl_log_internal
-
-#endif  // ABSL_LOG_LOG_BASIC_TEST_IMPL_H_
diff --git a/tests/googletest/include/absl/log/scoped_mock_log.cc b/tests/googletest/include/absl/log/scoped_mock_log.cc
deleted file mode 100644
index 39a0a52a..00000000
--- a/tests/googletest/include/absl/log/scoped_mock_log.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/log/scoped_mock_log.h"
-
-#include <atomic>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/log/log_entry.h"
-#include "absl/log/log_sink.h"
-#include "absl/log/log_sink_registry.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-ScopedMockLog::ScopedMockLog(MockLogDefault default_exp)
-    : sink_(this), is_capturing_logs_(false), is_triggered_(false) {
-  if (default_exp == MockLogDefault::kIgnoreUnexpected) {
-    // Ignore all calls to Log we did not set expectations for.
-    EXPECT_CALL(*this, Log).Times(::testing::AnyNumber());
-  } else {
-    // Disallow all calls to Log we did not set expectations for.
-    EXPECT_CALL(*this, Log).Times(0);
-  }
-  // By default Send mock forwards to Log mock.
-  EXPECT_CALL(*this, Send)
-      .Times(::testing::AnyNumber())
-      .WillRepeatedly([this](const absl::LogEntry& entry) {
-        is_triggered_.store(true, std::memory_order_relaxed);
-        Log(entry.log_severity(), std::string(entry.source_filename()),
-            std::string(entry.text_message()));
-      });
-
-  // By default We ignore all Flush calls.
-  EXPECT_CALL(*this, Flush).Times(::testing::AnyNumber());
-}
-
-ScopedMockLog::~ScopedMockLog() {
-  ABSL_RAW_CHECK(is_triggered_.load(std::memory_order_relaxed),
-                 "Did you forget to call StartCapturingLogs()?");
-
-  if (is_capturing_logs_) StopCapturingLogs();
-}
-
-void ScopedMockLog::StartCapturingLogs() {
-  ABSL_RAW_CHECK(!is_capturing_logs_,
-                 "StartCapturingLogs() can be called only when the "
-                 "absl::ScopedMockLog object is not capturing logs.");
-
-  is_capturing_logs_ = true;
-  is_triggered_.store(true, std::memory_order_relaxed);
-  absl::AddLogSink(&sink_);
-}
-
-void ScopedMockLog::StopCapturingLogs() {
-  ABSL_RAW_CHECK(is_capturing_logs_,
-                 "StopCapturingLogs() can be called only when the "
-                 "absl::ScopedMockLog object is capturing logs.");
-
-  is_capturing_logs_ = false;
-  absl::RemoveLogSink(&sink_);
-}
-
-absl::LogSink& ScopedMockLog::UseAsLocalSink() {
-  is_triggered_.store(true, std::memory_order_relaxed);
-  return sink_;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/tests/googletest/include/absl/log/scoped_mock_log.h b/tests/googletest/include/absl/log/scoped_mock_log.h
deleted file mode 100644
index 399e604d..00000000
--- a/tests/googletest/include/absl/log/scoped_mock_log.h
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: log/scoped_mock_log.h
-// -----------------------------------------------------------------------------
-//
-// This header declares `class absl::ScopedMockLog`, for use in testing.
-
-#ifndef ABSL_LOG_SCOPED_MOCK_LOG_H_
-#define ABSL_LOG_SCOPED_MOCK_LOG_H_
-
-#include <atomic>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "absl/base/config.h"
-#include "absl/base/log_severity.h"
-#include "absl/log/log_entry.h"
-#include "absl/log/log_sink.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// MockLogDefault
-//
-// Controls how ScopedMockLog responds to unexpected calls by default.
-enum class MockLogDefault { kIgnoreUnexpected, kDisallowUnexpected };
-
-// ScopedMockLog
-//
-// ScopedMockLog is a LogSink that intercepts LOG() messages issued during its
-// lifespan.
-//
-// Using this together with GoogleTest, it's easy to test how a piece of code
-// calls LOG(). The typical usage, noting the distinction between
-// "uninteresting" and "unexpected", looks like this:
-//
-//   using ::testing::_;
-//   using ::testing::AnyNumber;
-//   using ::testing::EndsWith;
-//   using ::testing::kDoNotCaptureLogsYet;
-//   using ::testing::Lt;
-//
-//   TEST(FooTest, LogsCorrectly) {
-//     // Simple robust setup, ignores unexpected logs.
-//     absl::ScopedMockLog log;
-//
-//     // We expect the WARNING "Something bad!" exactly twice.
-//     EXPECT_CALL(log, Log(absl::LogSeverity::kWarning, _, "Something bad!"))
-//         .Times(2);
-//
-//     // But we want no messages from foo.cc.
-//     EXPECT_CALL(log, Log(_, EndsWith("/foo.cc"), _)).Times(0);
-//
-//     log.StartCapturingLogs();  // Call this after done setting expectations.
-//     Foo();  // Exercises the code under test.
-//   }
-//
-//   TEST(BarTest, LogsExactlyCorrectly) {
-//     // Strict checking, fails for unexpected logs.
-//     absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
-//
-//     // ... but ignore low severity messages
-//     EXPECT_CALL(log, Log(Lt(absl::LogSeverity::kWarning), _, _))
-//         .Times(AnyNumber());
-//
-//     // We expect the ERROR "Something bad!" exactly once.
-//     EXPECT_CALL(log, Log(absl::LogSeverity::kError, EndsWith("/foo.cc"),
-//                 "Something bad!"))
-//         .Times(1);
-//
-//     log.StartCapturingLogs();  // Call this after done setting expectations.
-//     Bar();  // Exercises the code under test.
-//    }
-//
-// Note that in a multi-threaded environment, all LOG() messages from a single
-// thread will be handled in sequence, but that cannot be guaranteed for
-// messages from different threads. In fact, if the same or multiple
-// expectations are matched on two threads concurrently, their actions will be
-// executed concurrently as well and may interleave.
-class ScopedMockLog final {
- public:
-  // ScopedMockLog::ScopedMockLog()
-  //
-  // Sets up the log and adds default expectations.
-  explicit ScopedMockLog(
-      MockLogDefault default_exp = MockLogDefault::kIgnoreUnexpected);
-  ScopedMockLog(const ScopedMockLog&) = delete;
-  ScopedMockLog& operator=(const ScopedMockLog&) = delete;
-
-  // ScopedMockLog::~ScopedMockLog()
-  //
-  // Stops intercepting logs and destroys this ScopedMockLog.
-  ~ScopedMockLog();
-
-  // ScopedMockLog::StartCapturingLogs()
-  //
-  // Starts log capturing if the object isn't already doing so. Otherwise
-  // crashes.
-  //
-  // Usually this method is called in the same thread that created this
-  // ScopedMockLog. It is the user's responsibility to not call this method if
-  // another thread may be calling it or StopCapturingLogs() at the same time.
-  // It is undefined behavior to add expectations while capturing logs is
-  // enabled.
-  void StartCapturingLogs();
-
-  // ScopedMockLog::StopCapturingLogs()
-  //
-  // Stops log capturing if the object is capturing logs. Otherwise crashes.
-  //
-  // Usually this method is called in the same thread that created this object.
-  // It is the user's responsibility to not call this method if another thread
-  // may be calling it or StartCapturingLogs() at the same time.
-  //
-  // It is UB to add expectations, while capturing logs is enabled.
-  void StopCapturingLogs();
-
-  // ScopedMockLog::UseAsLocalSink()
-  //
-  // Each `ScopedMockLog` is implemented with an `absl::LogSink`; this method
-  // returns a reference to that sink (e.g. for use with
-  // `LOG(...).ToSinkOnly()`) and marks the `ScopedMockLog` as having been used
-  // even if `StartCapturingLogs` is never called.
-  absl::LogSink& UseAsLocalSink();
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity, absl::string_view file_path,
-  //            absl::string_view message);
-  //
-  // The second argument to Log() is the full path of the source file in
-  // which the LOG() was issued.
-  //
-  // This is a shorthand form, which should be used by most users. Use the
-  // `Send` mock only if you want to add expectations for other log message
-  // attributes.
-  MOCK_METHOD(void, Log,
-              (absl::LogSeverity severity, const std::string& file_path,
-               const std::string& message));
-
-  // Implements the mock method:
-  //
-  //   void Send(const absl::LogEntry& entry);
-  //
-  // This is the most generic form of mock that can be specified. Use this mock
-  // only if you want to add expectations for log message attributes different
-  // from the log message text, log message path and log message severity.
-  //
-  // If no expectations are specified for this mock, the default action is to
-  // forward the call to the `Log` mock.
-  MOCK_METHOD(void, Send, (const absl::LogEntry&));
-
-  // Implements the mock method:
-  //
-  //   void Flush();
-  //
-  // Use this mock only if you want to add expectations for log flush calls.
-  MOCK_METHOD(void, Flush, ());
-
- private:
-  class ForwardingSink final : public absl::LogSink {
-   public:
-    explicit ForwardingSink(ScopedMockLog* sml) : sml_(sml) {}
-    ForwardingSink(const ForwardingSink&) = delete;
-    ForwardingSink& operator=(const ForwardingSink&) = delete;
-    void Send(const absl::LogEntry& entry) override { sml_->Send(entry); }
-    void Flush() override { sml_->Flush(); }
-
-   private:
-    ScopedMockLog* sml_;
-  };
-
-  ForwardingSink sink_;
-  bool is_capturing_logs_;
-  // Until C++20, the default constructor leaves the underlying value wrapped in
-  // std::atomic uninitialized, so all constructors should be sure to initialize
-  // is_triggered_.
-  std::atomic<bool> is_triggered_;
-};
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_LOG_SCOPED_MOCK_LOG_H_
diff --git a/tests/googletest/include/absl/random/internal/mock_overload_set.h b/tests/googletest/include/absl/random/internal/mock_overload_set.h
deleted file mode 100644
index 0d9c6c12..00000000
--- a/tests/googletest/include/absl/random/internal/mock_overload_set.h
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
-#define ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
-
-#include <type_traits>
-
-#include "gmock/gmock.h"
-#include "absl/random/internal/mock_helpers.h"
-#include "absl/random/mocking_bit_gen.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-template <typename DistrT, typename Fn>
-struct MockSingleOverload;
-
-// MockSingleOverload
-//
-// MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
-// EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
-// `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
-// the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
-// arguments to MockingBitGen::Register.
-//
-// The underlying KeyT must match the KeyT constructed by DistributionCaller.
-template <typename DistrT, typename Ret, typename... Args>
-struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> {
-  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
-                "Overload signature must have return type matching the "
-                "distribution result_type.");
-  using KeyT = Ret(DistrT, std::tuple<Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
-      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
-    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
-  }
-};
-
-template <typename DistrT, typename Ret, typename Arg, typename... Args>
-struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> {
-  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
-                "Overload signature must have return type matching the "
-                "distribution result_type.");
-  using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen,
-                  const ::testing::Matcher<Args>&... matchers)
-      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher,
-                                                             matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
-    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
-  }
-};
-
-// MockOverloadSet
-//
-// MockOverloadSet takes a distribution and a collection of signatures and
-// performs overload resolution amongst all the overloads. This makes
-// `EXPECT_CALL(mock_overload_set, Call(...))` expand and do overload resolution
-// correctly.
-template <typename DistrT, typename... Signatures>
-struct MockOverloadSet;
-
-template <typename DistrT, typename Sig>
-struct MockOverloadSet<DistrT, Sig> : public MockSingleOverload<DistrT, Sig> {
-  using MockSingleOverload<DistrT, Sig>::gmock_Call;
-};
-
-template <typename DistrT, typename FirstSig, typename... Rest>
-struct MockOverloadSet<DistrT, FirstSig, Rest...>
-    : public MockSingleOverload<DistrT, FirstSig>,
-      public MockOverloadSet<DistrT, Rest...> {
-  using MockSingleOverload<DistrT, FirstSig>::gmock_Call;
-  using MockOverloadSet<DistrT, Rest...>::gmock_Call;
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-#endif  // ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
diff --git a/tests/googletest/include/absl/random/mock_distributions.h b/tests/googletest/include/absl/random/mock_distributions.h
deleted file mode 100644
index 764ab370..00000000
--- a/tests/googletest/include/absl/random/mock_distributions.h
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: mock_distributions.h
-// -----------------------------------------------------------------------------
-//
-// This file contains mock distribution functions for use alongside an
-// `absl::MockingBitGen` object within the Googletest testing framework. Such
-// mocks are useful to provide deterministic values as return values within
-// (otherwise random) Abseil distribution functions.
-//
-// The return type of each function is a mock expectation object which
-// is used to set the match result.
-//
-// More information about the Googletest testing framework is available at
-// https://github.com/google/googletest
-//
-// EXPECT_CALL and ON_CALL need to be made within the same DLL component as
-// the call to absl::Uniform and related methods, otherwise mocking will fail
-// since the  underlying implementation creates a type-specific pointer which
-// will be distinct across different DLL boundaries.
-//
-// Example:
-//
-//   absl::MockingBitGen mock;
-//   EXPECT_CALL(absl::MockUniform<int>(), Call(mock, 1, 1000))
-//     .WillRepeatedly(testing::ReturnRoundRobin({20, 40}));
-//
-//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
-//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
-//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
-//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
-
-#ifndef ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
-#define ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
-
-#include <limits>
-#include <type_traits>
-#include <utility>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/meta/type_traits.h"
-#include "absl/random/distributions.h"
-#include "absl/random/internal/mock_overload_set.h"
-#include "absl/random/mocking_bit_gen.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// absl::MockUniform
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Uniform.
-//
-// `absl::MockUniform` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(mock))
-//     .WillOnce(Return(123456));
-//  auto x = absl::Uniform<uint32_t>(mock);
-//  assert(x == 123456)
-//
-template <typename R>
-using MockUniform = random_internal::MockOverloadSet<
-    random_internal::UniformDistributionWrapper<R>,
-    R(IntervalClosedOpenTag, MockingBitGen&, R, R),
-    R(IntervalClosedClosedTag, MockingBitGen&, R, R),
-    R(IntervalOpenOpenTag, MockingBitGen&, R, R),
-    R(IntervalOpenClosedTag, MockingBitGen&, R, R), R(MockingBitGen&, R, R),
-    R(MockingBitGen&)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockBernoulli
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Bernoulli.
-//
-// `absl::MockBernoulli` is a class used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockBernoulli(), Call(mock, testing::_))
-//     .WillOnce(Return(false));
-//  assert(absl::Bernoulli(mock, 0.5) == false);
-//
-using MockBernoulli =
-    random_internal::MockOverloadSet<absl::bernoulli_distribution,
-                                     bool(MockingBitGen&, double)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockBeta
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Beta.
-//
-// `absl::MockBeta` is a class used in conjunction with Googletest's `ON_CALL()`
-// and `EXPECT_CALL()` macros. To use it, default-construct an instance of it
-// inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the same way one
-// would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockBeta(), Call(mock, 3.0, 2.0))
-//     .WillOnce(Return(0.567));
-//  auto x = absl::Beta<double>(mock, 3.0, 2.0);
-//  assert(x == 0.567);
-//
-template <typename RealType>
-using MockBeta =
-    random_internal::MockOverloadSet<absl::beta_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType,
-                                              RealType)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockExponential
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Exponential.
-//
-// `absl::MockExponential` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockExponential<double>(), Call(mock, 0.5))
-//     .WillOnce(Return(12.3456789));
-//  auto x = absl::Exponential<double>(mock, 0.5);
-//  assert(x == 12.3456789)
-//
-template <typename RealType>
-using MockExponential =
-    random_internal::MockOverloadSet<absl::exponential_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockGaussian
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Gaussian.
-//
-// `absl::MockGaussian` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockGaussian<double>(), Call(mock, 16.3, 3.3))
-//     .WillOnce(Return(12.3456789));
-//  auto x = absl::Gaussian<double>(mock, 16.3, 3.3);
-//  assert(x == 12.3456789)
-//
-template <typename RealType>
-using MockGaussian =
-    random_internal::MockOverloadSet<absl::gaussian_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType,
-                                              RealType)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockLogUniform
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::LogUniform.
-//
-// `absl::MockLogUniform` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockLogUniform<int>(), Call(mock, 10, 10000, 10))
-//     .WillOnce(Return(1221));
-//  auto x = absl::LogUniform<int>(mock, 10, 10000, 10);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockLogUniform = random_internal::MockOverloadSet<
-    absl::log_uniform_int_distribution<IntType>,
-    IntType(MockingBitGen&, IntType, IntType, IntType)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockPoisson
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Poisson.
-//
-// `absl::MockPoisson` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockPoisson<int>(), Call(mock, 2.0))
-//     .WillOnce(Return(1221));
-//  auto x = absl::Poisson<int>(mock, 2.0);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockPoisson =
-    random_internal::MockOverloadSet<absl::poisson_distribution<IntType>,
-                                     IntType(MockingBitGen&, double)>;
-
-// -----------------------------------------------------------------------------
-// absl::MockZipf
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Zipf.
-//
-// `absl::MockZipf` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockZipf<int>(), Call(mock, 1000000, 2.0, 1.0))
-//     .WillOnce(Return(1221));
-//  auto x = absl::Zipf<int>(mock, 1000000, 2.0, 1.0);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockZipf =
-    random_internal::MockOverloadSet<absl::zipf_distribution<IntType>,
-                                     IntType(MockingBitGen&, IntType, double,
-                                             double)>;
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
diff --git a/tests/googletest/include/absl/random/mocking_bit_gen.h b/tests/googletest/include/absl/random/mocking_bit_gen.h
deleted file mode 100644
index 89fa5a47..00000000
--- a/tests/googletest/include/absl/random/mocking_bit_gen.h
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// mocking_bit_gen.h
-// -----------------------------------------------------------------------------
-//
-// This file includes an `absl::MockingBitGen` class to use as a mock within the
-// Googletest testing framework. Such a mock is useful to provide deterministic
-// values as return values within (otherwise random) Abseil distribution
-// functions. Such determinism within a mock is useful within testing frameworks
-// to test otherwise indeterminate APIs.
-//
-// More information about the Googletest testing framework is available at
-// https://github.com/google/googletest
-
-#ifndef ABSL_RANDOM_MOCKING_BIT_GEN_H_
-#define ABSL_RANDOM_MOCKING_BIT_GEN_H_
-
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/internal/fast_type_id.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/meta/type_traits.h"
-#include "absl/random/distributions.h"
-#include "absl/random/internal/distribution_caller.h"
-#include "absl/random/random.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/types/span.h"
-#include "absl/types/variant.h"
-#include "absl/utility/utility.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace random_internal {
-template <typename>
-struct DistributionCaller;
-class MockHelpers;
-
-}  // namespace random_internal
-class BitGenRef;
-
-// MockingBitGen
-//
-// `absl::MockingBitGen` is a mock Uniform Random Bit Generator (URBG) class
-// which can act in place of an `absl::BitGen` URBG within tests using the
-// Googletest testing framework.
-//
-// Usage:
-//
-// Use an `absl::MockingBitGen` along with a mock distribution object (within
-// mock_distributions.h) inside Googletest constructs such as ON_CALL(),
-// EXPECT_TRUE(), etc. to produce deterministic results conforming to the
-// distribution's API contract.
-//
-// Example:
-//
-//  // Mock a call to an `absl::Bernoulli` distribution using Googletest
-//   absl::MockingBitGen bitgen;
-//
-//   ON_CALL(absl::MockBernoulli(), Call(bitgen, 0.5))
-//       .WillByDefault(testing::Return(true));
-//   EXPECT_TRUE(absl::Bernoulli(bitgen, 0.5));
-//
-//  // Mock a call to an `absl::Uniform` distribution within Googletest
-//  absl::MockingBitGen bitgen;
-//
-//   ON_CALL(absl::MockUniform<int>(), Call(bitgen, testing::_, testing::_))
-//       .WillByDefault([] (int low, int high) {
-//           return low + (high - low) / 2;
-//       });
-//
-//   EXPECT_EQ(absl::Uniform<int>(gen, 0, 10), 5);
-//   EXPECT_EQ(absl::Uniform<int>(gen, 30, 40), 35);
-//
-// At this time, only mock distributions supplied within the Abseil random
-// library are officially supported.
-//
-// EXPECT_CALL and ON_CALL need to be made within the same DLL component as
-// the call to absl::Uniform and related methods, otherwise mocking will fail
-// since the  underlying implementation creates a type-specific pointer which
-// will be distinct across different DLL boundaries.
-//
-class MockingBitGen {
- public:
-  MockingBitGen() = default;
-  ~MockingBitGen() = default;
-
-  // URBG interface
-  using result_type = absl::BitGen::result_type;
-
-  static constexpr result_type(min)() { return (absl::BitGen::min)(); }
-  static constexpr result_type(max)() { return (absl::BitGen::max)(); }
-  result_type operator()() { return gen_(); }
-
- private:
-  // GetMockFnType returns the testing::MockFunction for a result and tuple.
-  // This method only exists for type deduction and is otherwise unimplemented.
-  template <typename ResultT, typename... Args>
-  static auto GetMockFnType(ResultT, std::tuple<Args...>)
-      -> ::testing::MockFunction<ResultT(Args...)>;
-
-  // MockFnCaller is a helper method for use with absl::apply to
-  // apply an ArgTupleT to a compatible MockFunction.
-  // NOTE: MockFnCaller is essentially equivalent to the lambda:
-  // [fn](auto... args) { return fn->Call(std::move(args)...)}
-  // however that fails to build on some supported platforms.
-  template <typename MockFnType, typename ResultT, typename Tuple>
-  struct MockFnCaller;
-
-  // specialization for std::tuple.
-  template <typename MockFnType, typename ResultT, typename... Args>
-  struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>> {
-    MockFnType* fn;
-    inline ResultT operator()(Args... args) {
-      return fn->Call(std::move(args)...);
-    }
-  };
-
-  // FunctionHolder owns a particular ::testing::MockFunction associated with
-  // a mocked type signature, and implement the type-erased Apply call, which
-  // applies type-erased arguments to the mock.
-  class FunctionHolder {
-   public:
-    virtual ~FunctionHolder() = default;
-
-    // Call is a dispatch function which converts the
-    // generic type-erased parameters into a specific mock invocation call.
-    virtual void Apply(/*ArgTupleT*/ void* args_tuple,
-                       /*ResultT*/ void* result) = 0;
-  };
-
-  template <typename MockFnType, typename ResultT, typename ArgTupleT>
-  class FunctionHolderImpl final : public FunctionHolder {
-   public:
-    void Apply(void* args_tuple, void* result) override {
-      // Requires tuple_args to point to a ArgTupleT, which is a
-      // std::tuple<Args...> used to invoke the mock function. Requires result
-      // to point to a ResultT, which is the result of the call.
-      *static_cast<ResultT*>(result) =
-          absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_},
-                      *static_cast<ArgTupleT*>(args_tuple));
-    }
-
-    MockFnType mock_fn_;
-  };
-
-  // MockingBitGen::RegisterMock
-  //
-  // RegisterMock<ResultT, ArgTupleT>(FastTypeIdType) is the main extension
-  // point for extending the MockingBitGen framework. It provides a mechanism to
-  // install a mock expectation for a function like ResultT(Args...) keyed by
-  // type_idex onto the MockingBitGen context. The key is that the type_index
-  // used to register must match the type index used to call the mock.
-  //
-  // The returned MockFunction<...> type can be used to setup additional
-  // distribution parameters of the expectation.
-  template <typename ResultT, typename ArgTupleT, typename SelfT>
-  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type)
-      -> decltype(GetMockFnType(std::declval<ResultT>(),
-                                std::declval<ArgTupleT>()))& {
-    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
-                                              std::declval<ArgTupleT>()));
-
-    using WrappedFnType = absl::conditional_t<
-        std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value,
-        ::testing::NiceMock<MockFnType>,
-        absl::conditional_t<
-            std::is_same<SelfT,
-                         ::testing::NaggyMock<absl::MockingBitGen>>::value,
-            ::testing::NaggyMock<MockFnType>,
-            absl::conditional_t<
-                std::is_same<SelfT,
-                             ::testing::StrictMock<absl::MockingBitGen>>::value,
-                ::testing::StrictMock<MockFnType>, MockFnType>>>;
-
-    using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>;
-    auto& mock = mocks_[type];
-    if (!mock) {
-      mock = absl::make_unique<ImplT>();
-    }
-    return static_cast<ImplT*>(mock.get())->mock_fn_;
-  }
-
-  // MockingBitGen::InvokeMock
-  //
-  // InvokeMock(FastTypeIdType, args, result) is the entrypoint for invoking
-  // mocks registered on MockingBitGen.
-  //
-  // When no mocks are registered on the provided FastTypeIdType, returns false.
-  // Otherwise attempts to invoke the mock function ResultT(Args...) that
-  // was previously registered via the type_index.
-  // Requires tuple_args to point to a ArgTupleT, which is a std::tuple<Args...>
-  // used to invoke the mock function.
-  // Requires result to point to a ResultT, which is the result of the call.
-  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
-                         void* result) {
-    // Trigger a mock, if there exists one that matches `param`.
-    auto it = mocks_.find(type);
-    if (it == mocks_.end()) return false;
-    it->second->Apply(args_tuple, result);
-    return true;
-  }
-
-  absl::flat_hash_map<base_internal::FastTypeIdType,
-                      std::unique_ptr<FunctionHolder>>
-      mocks_;
-  absl::BitGen gen_;
-
-  template <typename>
-  friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
-  friend class ::absl::BitGenRef;                             // for InvokeMock
-  friend class ::absl::random_internal::MockHelpers;  // for RegisterMock,
-                                                      // InvokeMock
-};
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_MOCKING_BIT_GEN_H_
diff --git a/tests/googletest/include/absl/strings/cordz_test_helpers.h b/tests/googletest/include/absl/strings/cordz_test_helpers.h
deleted file mode 100644
index e410eecf..00000000
--- a/tests/googletest/include/absl/strings/cordz_test_helpers.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
-#define ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
-
-#include <utility>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cordz_info.h"
-#include "absl/strings/internal/cordz_sample_token.h"
-#include "absl/strings/internal/cordz_statistics.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-#include "absl/strings/str_cat.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
-inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
-    const Cord& cord) {
-  if (!cord.contents_.is_tree()) return nullptr;
-  return cord.contents_.cordz_info();
-}
-
-// Returns true if the provided cordz_info is in the list of sampled cords.
-inline bool CordzInfoIsListed(const cord_internal::CordzInfo* cordz_info,
-                              cord_internal::CordzSampleToken token = {}) {
-  for (const cord_internal::CordzInfo& info : token) {
-    if (cordz_info == &info) return true;
-  }
-  return false;
-}
-
-// Matcher on Cord that verifies all of:
-// - the cord is sampled
-// - the CordzInfo of the cord is listed / discoverable.
-// - the reported CordzStatistics match the cord's actual properties
-// - the cord has an (initial) UpdateTracker count of 1 for `method`
-MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord") {
-  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  if (!CordzInfoIsListed(cord_info)) {
-    *result_listener << "cord is sampled, but not listed";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.size != arg.size()) {
-    *result_listener << "cordz size " << stat.size
-                     << " does not match cord size " << arg.size();
-    return false;
-  }
-  if (stat.update_tracker.Value(method) != 1) {
-    *result_listener << "Expected method count 1 for " << method << ", found "
-                     << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Matcher on Cord that verifies that the cord is sampled and that the CordzInfo
-// update tracker has 'method' with a call count of 'n'
-MATCHER_P2(CordzMethodCountEq, method, n,
-           absl::StrCat("CordzInfo method count equals ", n)) {
-  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.update_tracker.Value(method) != n) {
-    *result_listener << "Expected method count " << n << " for " << method
-                     << ", found " << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Cordz will only update with a new rate once the previously scheduled event
-// has fired. When we disable Cordz, a long delay takes place where we won't
-// consider profiling new Cords. CordzSampleIntervalHelper will burn through
-// that interval and allow for testing that assumes that the average sampling
-// interval is a particular value.
-class CordzSamplingIntervalHelper {
- public:
-  explicit CordzSamplingIntervalHelper(int32_t interval)
-      : orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval()) {
-    absl::cord_internal::set_cordz_mean_interval(interval);
-    absl::cord_internal::cordz_set_next_sample_for_testing(interval);
-  }
-
-  ~CordzSamplingIntervalHelper() {
-    absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
-    absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
-  }
-
- private:
-  int32_t orig_mean_interval_;
-};
-
-// Wrapper struct managing a small CordRep `rep`
-struct TestCordRep {
-  cord_internal::CordRepFlat* rep;
-
-  TestCordRep() {
-    rep = cord_internal::CordRepFlat::New(100);
-    rep->length = 100;
-    memset(rep->Data(), 1, 100);
-  }
-  ~TestCordRep() { cord_internal::CordRep::Unref(rep); }
-};
-
-// Wrapper struct managing a small CordRep `rep`, and
-// an InlineData `data` initialized with that CordRep.
-struct TestCordData {
-  TestCordRep rep;
-  cord_internal::InlineData data{rep.rep};
-};
-
-// Creates a Cord that is not sampled
-template <typename... Args>
-Cord UnsampledCord(Args... args) {
-  CordzSamplingIntervalHelper never(9999);
-  Cord cord(std::forward<Args>(args)...);
-  ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
-  return cord;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/tests/googletest/rules.mk b/tests/googletest/rules.mk
index 6ce521c2..fddbebc0 100644
--- a/tests/googletest/rules.mk
+++ b/tests/googletest/rules.mk
@@ -342,7 +342,6 @@ tests_googletest_libgtest_la_SOURCES += \
     tests/googletest/include/absl/log/internal/flags.h \
     tests/googletest/include/absl/log/internal/config.h \
     tests/googletest/include/absl/log/internal/nullguard.h \
-    tests/googletest/include/absl/log/internal/test_matchers.h \
     tests/googletest/include/absl/log/internal/log_sink_set.h \
     tests/googletest/include/absl/log/internal/check_impl.h \
     tests/googletest/include/absl/log/internal/test_helpers.h \
@@ -359,7 +358,6 @@ tests_googletest_libgtest_la_SOURCES += \
     tests/googletest/include/absl/log/log_sink.h \
     tests/googletest/include/absl/log/log_sink_registry.h \
     tests/googletest/include/absl/log/log_entry.h \
-    tests/googletest/include/absl/log/scoped_mock_log.h \
     tests/googletest/include/absl/log/absl_check.h \
     tests/googletest/include/absl/log/die_if_null.h \
     tests/googletest/include/absl/log/check.h \
@@ -592,14 +590,12 @@ tests_googletest_libgtest_la_SOURCES += \
     tests/googletest/include/absl/log/internal/proto.cc \
     tests/googletest/include/absl/log/internal/log_format.cc \
     tests/googletest/include/absl/log/internal/log_message.cc \
-    tests/googletest/include/absl/log/internal/test_matchers.cc \
     tests/googletest/include/absl/log/internal/log_sink_set.cc \
     tests/googletest/include/absl/log/internal/conditions.cc \
     tests/googletest/include/absl/log/internal/check_op.cc \
     tests/googletest/include/absl/log/internal/test_actions.cc \
     tests/googletest/include/absl/log/internal/test_helpers.cc \
     tests/googletest/include/absl/log/internal/globals.cc \
-    tests/googletest/include/absl/log/scoped_mock_log.cc \
     tests/googletest/include/absl/log/initialize.cc \
     tests/googletest/include/absl/log/flags.cc \
     tests/googletest/include/absl/log/log_entry.cc \