@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/container/internal/test_allocator.h

@@ -1,387 +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_TEST_ALLOCATOR_H_
-#define ABSL_CONTAINER_INTERNAL_TEST_ALLOCATOR_H_
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <type_traits>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// This is a stateful allocator, but the state lives outside of the
-// allocator (in whatever test is using the allocator). This is odd
-// but helps in tests where the allocator is propagated into nested
-// containers - that chain of allocators uses the same state and is
-// thus easier to query for aggregate allocation information.
-template <typename T>
-class CountingAllocator {
- public:
-  using Allocator = std::allocator<T>;
-  using AllocatorTraits = std::allocator_traits<Allocator>;
-  using value_type = typename AllocatorTraits::value_type;
-  using pointer = typename AllocatorTraits::pointer;
-  using const_pointer = typename AllocatorTraits::const_pointer;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
-
-  CountingAllocator() = default;
-  explicit CountingAllocator(int64_t* bytes_used) : bytes_used_(bytes_used) {}
-  CountingAllocator(int64_t* bytes_used, int64_t* instance_count)
-      : bytes_used_(bytes_used), instance_count_(instance_count) {}
-
-  template <typename U>
-  CountingAllocator(const CountingAllocator<U>& x)
-      : bytes_used_(x.bytes_used_), instance_count_(x.instance_count_) {}
-
-  pointer allocate(
-      size_type n,
-      typename AllocatorTraits::const_void_pointer hint = nullptr) {
-    Allocator allocator;
-    pointer ptr = AllocatorTraits::allocate(allocator, n, hint);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ += n * sizeof(T);
-    }
-    return ptr;
-  }
-
-  void deallocate(pointer p, size_type n) {
-    Allocator allocator;
-    AllocatorTraits::deallocate(allocator, p, n);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ -= n * sizeof(T);
-    }
-  }
-
-  template <typename U, typename... Args>
-  void construct(U* p, Args&&... args) {
-    Allocator allocator;
-    AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...);
-    if (instance_count_ != nullptr) {
-      *instance_count_ += 1;
-    }
-  }
-
-  template <typename U>
-  void destroy(U* p) {
-    Allocator allocator;
-    // Ignore GCC warning bug.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuse-after-free"
-#endif
-    AllocatorTraits::destroy(allocator, p);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic pop
-#endif
-    if (instance_count_ != nullptr) {
-      *instance_count_ -= 1;
-    }
-  }
-
-  template <typename U>
-  class rebind {
-   public:
-    using other = CountingAllocator<U>;
-  };
-
-  friend bool operator==(const CountingAllocator& a,
-                         const CountingAllocator& b) {
-    return a.bytes_used_ == b.bytes_used_ &&
-           a.instance_count_ == b.instance_count_;
-  }
-
-  friend bool operator!=(const CountingAllocator& a,
-                         const CountingAllocator& b) {
-    return !(a == b);
-  }
-
-  int64_t* bytes_used_ = nullptr;
-  int64_t* instance_count_ = nullptr;
-};
-
-template <typename T>
-struct CopyAssignPropagatingCountingAlloc : public CountingAllocator<T> {
-  using propagate_on_container_copy_assignment = std::true_type;
-
-  using Base = CountingAllocator<T>;
-  using Base::Base;
-
-  template <typename U>
-  explicit CopyAssignPropagatingCountingAlloc(
-      const CopyAssignPropagatingCountingAlloc<U>& other)
-      : Base(other.bytes_used_, other.instance_count_) {}
-
-  template <typename U>
-  struct rebind {
-    using other = CopyAssignPropagatingCountingAlloc<U>;
-  };
-};
-
-template <typename T>
-struct MoveAssignPropagatingCountingAlloc : public CountingAllocator<T> {
-  using propagate_on_container_move_assignment = std::true_type;
-
-  using Base = CountingAllocator<T>;
-  using Base::Base;
-
-  template <typename U>
-  explicit MoveAssignPropagatingCountingAlloc(
-      const MoveAssignPropagatingCountingAlloc<U>& other)
-      : Base(other.bytes_used_, other.instance_count_) {}
-
-  template <typename U>
-  struct rebind {
-    using other = MoveAssignPropagatingCountingAlloc<U>;
-  };
-};
-
-template <typename T>
-struct SwapPropagatingCountingAlloc : public CountingAllocator<T> {
-  using propagate_on_container_swap = std::true_type;
-
-  using Base = CountingAllocator<T>;
-  using Base::Base;
-
-  template <typename U>
-  explicit SwapPropagatingCountingAlloc(
-      const SwapPropagatingCountingAlloc<U>& other)
-      : Base(other.bytes_used_, other.instance_count_) {}
-
-  template <typename U>
-  struct rebind {
-    using other = SwapPropagatingCountingAlloc<U>;
-  };
-};
-
-// Tries to allocate memory at the minimum alignment even when the default
-// allocator uses a higher alignment.
-template <typename T>
-struct MinimumAlignmentAlloc : std::allocator<T> {
-  MinimumAlignmentAlloc() = default;
-
-  template <typename U>
-  explicit MinimumAlignmentAlloc(const MinimumAlignmentAlloc<U>& /*other*/) {}
-
-  template <class U>
-  struct rebind {
-    using other = MinimumAlignmentAlloc<U>;
-  };
-
-  T* allocate(size_t n) {
-    T* ptr = std::allocator<T>::allocate(n + 1);
-    char* cptr = reinterpret_cast<char*>(ptr);
-    cptr += alignof(T);
-    return reinterpret_cast<T*>(cptr);
-  }
-
-  void deallocate(T* ptr, size_t n) {
-    char* cptr = reinterpret_cast<char*>(ptr);
-    cptr -= alignof(T);
-    std::allocator<T>::deallocate(reinterpret_cast<T*>(cptr), n + 1);
-  }
-};
-
-inline bool IsAssertEnabled() {
-  // Use an assert with side-effects to figure out if they are actually enabled.
-  bool assert_enabled = false;
-  assert([&]() {  // NOLINT
-    assert_enabled = true;
-    return true;
-  }());
-  return assert_enabled;
-}
-
-template <template <class Alloc> class Container>
-void TestCopyAssignAllocPropagation() {
-  int64_t bytes1 = 0, instances1 = 0, bytes2 = 0, instances2 = 0;
-  CopyAssignPropagatingCountingAlloc<int> allocator1(&bytes1, &instances1);
-  CopyAssignPropagatingCountingAlloc<int> allocator2(&bytes2, &instances2);
-
-  // Test propagating allocator_type.
-  {
-    Container<CopyAssignPropagatingCountingAlloc<int>> c1(allocator1);
-    Container<CopyAssignPropagatingCountingAlloc<int>> c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_NE(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2 = c1;
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 200);
-    EXPECT_EQ(instances2, 0);
-  }
-  // Test non-propagating allocator_type with different allocators.
-  {
-    Container<CountingAllocator<int>> c1(allocator1), c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_EQ(c2.get_allocator(), allocator2);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2 = c1;
-
-    EXPECT_EQ(c2.get_allocator(), allocator2);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 100);
-  }
-  EXPECT_EQ(bytes1, 0);
-  EXPECT_EQ(instances1, 0);
-  EXPECT_EQ(bytes2, 0);
-  EXPECT_EQ(instances2, 0);
-}
-
-template <template <class Alloc> class Container>
-void TestMoveAssignAllocPropagation() {
-  int64_t bytes1 = 0, instances1 = 0, bytes2 = 0, instances2 = 0;
-  MoveAssignPropagatingCountingAlloc<int> allocator1(&bytes1, &instances1);
-  MoveAssignPropagatingCountingAlloc<int> allocator2(&bytes2, &instances2);
-
-  // Test propagating allocator_type.
-  {
-    Container<MoveAssignPropagatingCountingAlloc<int>> c1(allocator1);
-    Container<MoveAssignPropagatingCountingAlloc<int>> c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_NE(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2 = std::move(c1);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-  }
-  // Test non-propagating allocator_type with equal allocators.
-  {
-    Container<CountingAllocator<int>> c1(allocator1), c2(allocator1);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2 = std::move(c1);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-  }
-  // Test non-propagating allocator_type with different allocators.
-  {
-    Container<CountingAllocator<int>> c1(allocator1), c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_NE(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2 = std::move(c1);
-
-    EXPECT_EQ(c2.get_allocator(), allocator2);
-    EXPECT_LE(instances1, 100);  // The values in c1 may or may not have been
-                                 // destroyed at this point.
-    EXPECT_EQ(instances2, 100);
-  }
-  EXPECT_EQ(bytes1, 0);
-  EXPECT_EQ(instances1, 0);
-  EXPECT_EQ(bytes2, 0);
-  EXPECT_EQ(instances2, 0);
-}
-
-template <template <class Alloc> class Container>
-void TestSwapAllocPropagation() {
-  int64_t bytes1 = 0, instances1 = 0, bytes2 = 0, instances2 = 0;
-  SwapPropagatingCountingAlloc<int> allocator1(&bytes1, &instances1);
-  SwapPropagatingCountingAlloc<int> allocator2(&bytes2, &instances2);
-
-  // Test propagating allocator_type.
-  {
-    Container<SwapPropagatingCountingAlloc<int>> c1(allocator1), c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_NE(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2.swap(c1);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-  }
-  // Test non-propagating allocator_type with equal allocators.
-  {
-    Container<CountingAllocator<int>> c1(allocator1), c2(allocator1);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-
-    c2.swap(c1);
-
-    EXPECT_EQ(c2.get_allocator(), allocator1);
-    EXPECT_EQ(instances1, 100);
-    EXPECT_EQ(instances2, 0);
-  }
-  // Test non-propagating allocator_type with different allocators.
-  {
-    Container<CountingAllocator<int>> c1(allocator1), c2(allocator2);
-
-    for (int i = 0; i < 100; ++i) c1.insert(i);
-
-    EXPECT_NE(c1.get_allocator(), c2.get_allocator());
-    if (IsAssertEnabled()) {
-      EXPECT_DEATH_IF_SUPPORTED(c2.swap(c1), "");
-    }
-  }
-  EXPECT_EQ(bytes1, 0);
-  EXPECT_EQ(instances1, 0);
-  EXPECT_EQ(bytes2, 0);
-  EXPECT_EQ(instances2, 0);
-}
-
-template <template <class Alloc> class Container>
-void TestAllocPropagation() {
-  TestCopyAssignAllocPropagation<Container>();
-  TestMoveAssignAllocPropagation<Container>();
-  TestSwapAllocPropagation<Container>();
-}
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_TEST_ALLOCATOR_H_

package/deps/abseil-cpp/absl/container/internal/test_instance_tracker.cc

@@ -1,29 +0,0 @@
-// Copyright 2017 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/container/internal/test_instance_tracker.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace test_internal {
-int BaseCountedInstance::num_instances_ = 0;
-int BaseCountedInstance::num_live_instances_ = 0;
-int BaseCountedInstance::num_moves_ = 0;
-int BaseCountedInstance::num_copies_ = 0;
-int BaseCountedInstance::num_swaps_ = 0;
-int BaseCountedInstance::num_comparisons_ = 0;
-
-}  // namespace test_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/container/internal/test_instance_tracker.h

@@ -1,274 +0,0 @@
-// Copyright 2017 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_TEST_INSTANCE_TRACKER_H_
-#define ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
-
-#include <cstdlib>
-#include <ostream>
-
-#include "absl/types/compare.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace test_internal {
-
-// A type that counts number of occurrences of the type, the live occurrences of
-// the type, as well as the number of copies, moves, swaps, and comparisons that
-// have occurred on the type. This is used as a base class for the copyable,
-// copyable+movable, and movable types below that are used in actual tests. Use
-// InstanceTracker in tests to track the number of instances.
-class BaseCountedInstance {
- public:
-  explicit BaseCountedInstance(int x) : value_(x) {
-    ++num_instances_;
-    ++num_live_instances_;
-  }
-  BaseCountedInstance(const BaseCountedInstance& x)
-      : value_(x.value_), is_live_(x.is_live_) {
-    ++num_instances_;
-    if (is_live_) ++num_live_instances_;
-    ++num_copies_;
-  }
-  BaseCountedInstance(BaseCountedInstance&& x)
-      : value_(x.value_), is_live_(x.is_live_) {
-    x.is_live_ = false;
-    ++num_instances_;
-    ++num_moves_;
-  }
-  ~BaseCountedInstance() {
-    --num_instances_;
-    if (is_live_) --num_live_instances_;
-  }
-
-  BaseCountedInstance& operator=(const BaseCountedInstance& x) {
-    value_ = x.value_;
-    if (is_live_) --num_live_instances_;
-    is_live_ = x.is_live_;
-    if (is_live_) ++num_live_instances_;
-    ++num_copies_;
-    return *this;
-  }
-  BaseCountedInstance& operator=(BaseCountedInstance&& x) {
-    value_ = x.value_;
-    if (is_live_) --num_live_instances_;
-    is_live_ = x.is_live_;
-    x.is_live_ = false;
-    ++num_moves_;
-    return *this;
-  }
-
-  bool operator==(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ == x.value_;
-  }
-
-  bool operator!=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ != x.value_;
-  }
-
-  bool operator<(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ < x.value_;
-  }
-
-  bool operator>(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ > x.value_;
-  }
-
-  bool operator<=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ <= x.value_;
-  }
-
-  bool operator>=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ >= x.value_;
-  }
-
-  absl::weak_ordering compare(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ < x.value_
-               ? absl::weak_ordering::less
-               : value_ == x.value_ ? absl::weak_ordering::equivalent
-                                    : absl::weak_ordering::greater;
-  }
-
-  int value() const {
-    if (!is_live_) std::abort();
-    return value_;
-  }
-
-  friend std::ostream& operator<<(std::ostream& o,
-                                  const BaseCountedInstance& v) {
-    return o << "[value:" << v.value() << "]";
-  }
-
-  // Implementation of efficient swap() that counts swaps.
-  static void SwapImpl(
-      BaseCountedInstance& lhs,    // NOLINT(runtime/references)
-      BaseCountedInstance& rhs) {  // NOLINT(runtime/references)
-    using std::swap;
-    swap(lhs.value_, rhs.value_);
-    swap(lhs.is_live_, rhs.is_live_);
-    ++BaseCountedInstance::num_swaps_;
-  }
-
- private:
-  friend class InstanceTracker;
-
-  int value_;
-
-  // Indicates if the value is live, ie it hasn't been moved away from.
-  bool is_live_ = true;
-
-  // Number of instances.
-  static int num_instances_;
-
-  // Number of live instances (those that have not been moved away from.)
-  static int num_live_instances_;
-
-  // Number of times that BaseCountedInstance objects were moved.
-  static int num_moves_;
-
-  // Number of times that BaseCountedInstance objects were copied.
-  static int num_copies_;
-
-  // Number of times that BaseCountedInstance objects were swapped.
-  static int num_swaps_;
-
-  // Number of times that BaseCountedInstance objects were compared.
-  static int num_comparisons_;
-};
-
-// Helper to track the BaseCountedInstance instance counters. Expects that the
-// number of instances and live_instances are the same when it is constructed
-// and when it is destructed.
-class InstanceTracker {
- public:
-  InstanceTracker()
-      : start_instances_(BaseCountedInstance::num_instances_),
-        start_live_instances_(BaseCountedInstance::num_live_instances_) {
-    ResetCopiesMovesSwaps();
-  }
-  ~InstanceTracker() {
-    if (instances() != 0) std::abort();
-    if (live_instances() != 0) std::abort();
-  }
-
-  // Returns the number of BaseCountedInstance instances both containing valid
-  // values and those moved away from compared to when the InstanceTracker was
-  // constructed
-  int instances() const {
-    return BaseCountedInstance::num_instances_ - start_instances_;
-  }
-
-  // Returns the number of live BaseCountedInstance instances compared to when
-  // the InstanceTracker was constructed
-  int live_instances() const {
-    return BaseCountedInstance::num_live_instances_ - start_live_instances_;
-  }
-
-  // Returns the number of moves on BaseCountedInstance objects since
-  // construction or since the last call to ResetCopiesMovesSwaps().
-  int moves() const { return BaseCountedInstance::num_moves_ - start_moves_; }
-
-  // Returns the number of copies on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int copies() const {
-    return BaseCountedInstance::num_copies_ - start_copies_;
-  }
-
-  // Returns the number of swaps on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int swaps() const { return BaseCountedInstance::num_swaps_ - start_swaps_; }
-
-  // Returns the number of comparisons on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int comparisons() const {
-    return BaseCountedInstance::num_comparisons_ - start_comparisons_;
-  }
-
-  // Resets the base values for moves, copies, comparisons, and swaps to the
-  // current values, so that subsequent Get*() calls for moves, copies,
-  // comparisons, and swaps will compare to the situation at the point of this
-  // call.
-  void ResetCopiesMovesSwaps() {
-    start_moves_ = BaseCountedInstance::num_moves_;
-    start_copies_ = BaseCountedInstance::num_copies_;
-    start_swaps_ = BaseCountedInstance::num_swaps_;
-    start_comparisons_ = BaseCountedInstance::num_comparisons_;
-  }
-
- private:
-  int start_instances_;
-  int start_live_instances_;
-  int start_moves_;
-  int start_copies_;
-  int start_swaps_;
-  int start_comparisons_;
-};
-
-// Copyable, not movable.
-class CopyableOnlyInstance : public BaseCountedInstance {
- public:
-  explicit CopyableOnlyInstance(int x) : BaseCountedInstance(x) {}
-  CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
-  CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;
-
-  friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return false; }
-};
-
-// Copyable and movable.
-class CopyableMovableInstance : public BaseCountedInstance {
- public:
-  explicit CopyableMovableInstance(int x) : BaseCountedInstance(x) {}
-  CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
-  CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
-  CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
-      default;
-  CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;
-
-  friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return true; }
-};
-
-// Only movable, not default-constructible.
-class MovableOnlyInstance : public BaseCountedInstance {
- public:
-  explicit MovableOnlyInstance(int x) : BaseCountedInstance(x) {}
-  MovableOnlyInstance(MovableOnlyInstance&& other) = default;
-  MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;
-
-  friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return true; }
-};
-
-}  // namespace test_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_