1 files changed, 2 insertions, 69 deletions
diff --git a/absl/container/internal/container_memory_test.cc b/absl/container/internal/container_memory_test.cc
index fb9c4dde..7942c7be 100644
--- a/absl/container/internal/container_memory_test.cc
+++ b/absl/container/internal/container_memory_test.cc
@@ -16,13 +16,10 @@
 
 #include <cstdint>
 #include <tuple>
-#include <typeindex>
-#include <typeinfo>
 #include <utility>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/container/internal/test_instance_tracker.h"
 #include "absl/strings/string_view.h"
 
 namespace absl {
@@ -30,11 +27,6 @@ ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace {
 
-using ::absl::test_internal::CopyableMovableInstance;
-using ::absl::test_internal::InstanceTracker;
-using ::testing::_;
-using ::testing::ElementsAre;
-using ::testing::Gt;
 using ::testing::Pair;
 
 TEST(Memory, AlignmentLargerThanBase) {
@@ -53,39 +45,6 @@ TEST(Memory, AlignmentSmallerThanBase) {
   Deallocate<2>(&alloc, mem, 3);
 }
 
-std::map<std::type_index, int>& AllocationMap() {
-  static auto* map = new std::map<std::type_index, int>;
-  return *map;
-}
-
-template <typename T>
-struct TypeCountingAllocator {
-  TypeCountingAllocator() = default;
-  template <typename U>
-  TypeCountingAllocator(const TypeCountingAllocator<U>&) {}  // NOLINT
-
-  using value_type = T;
-
-  T* allocate(size_t n, const void* = nullptr) {
-    AllocationMap()[typeid(T)] += n;
-    return std::allocator<T>().allocate(n);
-  }
-  void deallocate(T* p, std::size_t n) {
-    AllocationMap()[typeid(T)] -= n;
-    return std::allocator<T>().deallocate(p, n);
-  }
-};
-
-TEST(Memory, AllocateDeallocateMatchType) {
-  TypeCountingAllocator<int> alloc;
-  void* mem = Allocate<1>(&alloc, 1);
-  // Verify that it was allocated
-  EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, Gt(0))));
-  Deallocate<1>(&alloc, mem, 1);
-  // Verify that the deallocation matched.
-  EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, 0)));
-}
-
 class Fixture : public ::testing::Test {
   using Alloc = std::allocator<std::string>;
 
@@ -166,7 +125,7 @@ TryDecomposeValue(F&& f, Arg&& arg) {
 }
 
 TEST(DecomposeValue, Decomposable) {
-  auto f = [](const int& x, int&& y) {  // NOLINT
+  auto f = [](const int& x, int&& y) {
     EXPECT_EQ(&x, &y);
     EXPECT_EQ(42, x);
     return 'A';
@@ -200,8 +159,7 @@ TryDecomposePair(F&& f, Args&&... args) {
 }
 
 TEST(DecomposePair, Decomposable) {
-  auto f = [](const int& x,  // NOLINT
-              std::piecewise_construct_t, std::tuple<int&&> k,
+  auto f = [](const int& x, std::piecewise_construct_t, std::tuple<int&&> k,
               std::tuple<double>&& v) {
     EXPECT_EQ(&x, &std::get<0>(k));
     EXPECT_EQ(42, x);
@@ -226,31 +184,6 @@ TEST(DecomposePair, NotDecomposable) {
                                 std::make_tuple(0.5)));
 }
 
-TEST(MapSlotPolicy, ConstKeyAndValue) {
-  using slot_policy = map_slot_policy<const CopyableMovableInstance,
-                                      const CopyableMovableInstance>;
-  using slot_type = typename slot_policy::slot_type;
-
-  union Slots {
-    Slots() {}
-    ~Slots() {}
-    slot_type slots[100];
-  } slots;
-
-  std::allocator<
-      std::pair<const CopyableMovableInstance, const CopyableMovableInstance>>
-      alloc;
-  InstanceTracker tracker;
-  slot_policy::construct(&alloc, &slots.slots[0], CopyableMovableInstance(1),
-                         CopyableMovableInstance(1));
-  for (int i = 0; i < 99; ++i) {
-    slot_policy::transfer(&alloc, &slots.slots[i + 1], &slots.slots[i]);
-  }
-  slot_policy::destroy(&alloc, &slots.slots[99]);
-
-  EXPECT_EQ(tracker.copies(), 0);
-}
-
 }  // namespace
 }  // namespace container_internal
 ABSL_NAMESPACE_END