re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/types/any_test.cc

@@ -1,778 +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/types/any.h"
-
-// This test is a no-op when absl::any is an alias for std::any.
-#if !defined(ABSL_USES_STD_ANY)
-
-#include <initializer_list>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/exception_testing.h"
-#include "absl/container/internal/test_instance_tracker.h"
-#include "absl/log/log.h"
-
-namespace {
-using absl::test_internal::CopyableOnlyInstance;
-using absl::test_internal::InstanceTracker;
-
-template <typename T>
-const T& AsConst(const T& t) {
-  return t;
-}
-
-struct MoveOnly {
-  MoveOnly() = default;
-  explicit MoveOnly(int value) : value(value) {}
-  MoveOnly(MoveOnly&&) = default;
-  MoveOnly& operator=(MoveOnly&&) = default;
-
-  int value = 0;
-};
-
-struct CopyOnly {
-  CopyOnly() = default;
-  explicit CopyOnly(int value) : value(value) {}
-  CopyOnly(CopyOnly&&) = delete;
-  CopyOnly& operator=(CopyOnly&&) = delete;
-  CopyOnly(const CopyOnly&) = default;
-  CopyOnly& operator=(const CopyOnly&) = default;
-
-  int value = 0;
-};
-
-struct MoveOnlyWithListConstructor {
-  MoveOnlyWithListConstructor() = default;
-  explicit MoveOnlyWithListConstructor(std::initializer_list<int> /*ilist*/,
-                                       int value)
-      : value(value) {}
-  MoveOnlyWithListConstructor(MoveOnlyWithListConstructor&&) = default;
-  MoveOnlyWithListConstructor& operator=(MoveOnlyWithListConstructor&&) =
-      default;
-
-  int value = 0;
-};
-
-struct IntMoveOnlyCopyOnly {
-  IntMoveOnlyCopyOnly(int value, MoveOnly /*move_only*/, CopyOnly /*copy_only*/)
-      : value(value) {}
-
-  int value;
-};
-
-struct ListMoveOnlyCopyOnly {
-  ListMoveOnlyCopyOnly(std::initializer_list<int> ilist, MoveOnly /*move_only*/,
-                       CopyOnly /*copy_only*/)
-      : values(ilist) {}
-
-  std::vector<int> values;
-};
-
-using FunctionType = void();
-void FunctionToEmplace() {}
-
-using ArrayType = int[2];
-using DecayedArray = absl::decay_t<ArrayType>;
-
-TEST(AnyTest, Noexcept) {
-  static_assert(std::is_nothrow_default_constructible<absl::any>(), "");
-  static_assert(std::is_nothrow_move_constructible<absl::any>(), "");
-  static_assert(std::is_nothrow_move_assignable<absl::any>(), "");
-  static_assert(noexcept(std::declval<absl::any&>().has_value()), "");
-  static_assert(noexcept(std::declval<absl::any&>().type()), "");
-  static_assert(noexcept(absl::any_cast<int>(std::declval<absl::any*>())), "");
-  static_assert(
-      noexcept(std::declval<absl::any&>().swap(std::declval<absl::any&>())),
-      "");
-
-  using std::swap;
-  static_assert(
-      noexcept(swap(std::declval<absl::any&>(), std::declval<absl::any&>())),
-      "");
-}
-
-TEST(AnyTest, HasValue) {
-  absl::any o;
-  EXPECT_FALSE(o.has_value());
-  o.emplace<int>();
-  EXPECT_TRUE(o.has_value());
-  o.reset();
-  EXPECT_FALSE(o.has_value());
-}
-
-TEST(AnyTest, Type) {
-  absl::any o;
-  EXPECT_EQ(typeid(void), o.type());
-  o.emplace<int>(5);
-  EXPECT_EQ(typeid(int), o.type());
-  o.emplace<float>(5.f);
-  EXPECT_EQ(typeid(float), o.type());
-  o.reset();
-  EXPECT_EQ(typeid(void), o.type());
-}
-
-TEST(AnyTest, EmptyPointerCast) {
-  // pointer-to-unqualified overload
-  {
-    absl::any o;
-    EXPECT_EQ(nullptr, absl::any_cast<int>(&o));
-    o.emplace<int>();
-    EXPECT_NE(nullptr, absl::any_cast<int>(&o));
-    o.reset();
-    EXPECT_EQ(nullptr, absl::any_cast<int>(&o));
-  }
-
-  // pointer-to-const overload
-  {
-    absl::any o;
-    EXPECT_EQ(nullptr, absl::any_cast<int>(&AsConst(o)));
-    o.emplace<int>();
-    EXPECT_NE(nullptr, absl::any_cast<int>(&AsConst(o)));
-    o.reset();
-    EXPECT_EQ(nullptr, absl::any_cast<int>(&AsConst(o)));
-  }
-}
-
-TEST(AnyTest, InPlaceConstruction) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type_t<IntMoveOnlyCopyOnly>(), 5, MoveOnly(),
-              copy_only);
-  IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-}
-
-TEST(AnyTest, InPlaceConstructionVariableTemplate) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type<IntMoveOnlyCopyOnly>, 5, MoveOnly(),
-              copy_only);
-  auto& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-}
-
-TEST(AnyTest, InPlaceConstructionWithCV) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type_t<const volatile IntMoveOnlyCopyOnly>(), 5,
-              MoveOnly(), copy_only);
-  IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-}
-
-TEST(AnyTest, InPlaceConstructionWithCVVariableTemplate) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type<const volatile IntMoveOnlyCopyOnly>, 5,
-              MoveOnly(), copy_only);
-  auto& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-}
-
-TEST(AnyTest, InPlaceConstructionWithFunction) {
-  absl::any o(absl::in_place_type_t<FunctionType>(), FunctionToEmplace);
-  FunctionType*& construction_result = absl::any_cast<FunctionType*&>(o);
-  EXPECT_EQ(&FunctionToEmplace, construction_result);
-}
-
-TEST(AnyTest, InPlaceConstructionWithFunctionVariableTemplate) {
-  absl::any o(absl::in_place_type<FunctionType>, FunctionToEmplace);
-  auto& construction_result = absl::any_cast<FunctionType*&>(o);
-  EXPECT_EQ(&FunctionToEmplace, construction_result);
-}
-
-TEST(AnyTest, InPlaceConstructionWithArray) {
-  ArrayType ar = {5, 42};
-  absl::any o(absl::in_place_type_t<ArrayType>(), ar);
-  DecayedArray& construction_result = absl::any_cast<DecayedArray&>(o);
-  EXPECT_EQ(&ar[0], construction_result);
-}
-
-TEST(AnyTest, InPlaceConstructionWithArrayVariableTemplate) {
-  ArrayType ar = {5, 42};
-  absl::any o(absl::in_place_type<ArrayType>, ar);
-  auto& construction_result = absl::any_cast<DecayedArray&>(o);
-  EXPECT_EQ(&ar[0], construction_result);
-}
-
-TEST(AnyTest, InPlaceConstructionIlist) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type_t<ListMoveOnlyCopyOnly>(), {1, 2, 3, 4},
-              MoveOnly(), copy_only);
-  ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-TEST(AnyTest, InPlaceConstructionIlistVariableTemplate) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type<ListMoveOnlyCopyOnly>, {1, 2, 3, 4},
-              MoveOnly(), copy_only);
-  auto& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-TEST(AnyTest, InPlaceConstructionIlistWithCV) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type_t<const volatile ListMoveOnlyCopyOnly>(),
-              {1, 2, 3, 4}, MoveOnly(), copy_only);
-  ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-TEST(AnyTest, InPlaceConstructionIlistWithCVVariableTemplate) {
-  const CopyOnly copy_only{};
-  absl::any o(absl::in_place_type<const volatile ListMoveOnlyCopyOnly>,
-              {1, 2, 3, 4}, MoveOnly(), copy_only);
-  auto& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-TEST(AnyTest, InPlaceNoArgs) {
-  absl::any o(absl::in_place_type_t<int>{});
-  EXPECT_EQ(0, absl::any_cast<int&>(o));
-}
-
-TEST(AnyTest, InPlaceNoArgsVariableTemplate) {
-  absl::any o(absl::in_place_type<int>);
-  EXPECT_EQ(0, absl::any_cast<int&>(o));
-}
-
-template <typename Enabler, typename T, typename... Args>
-struct CanEmplaceAnyImpl : std::false_type {};
-
-template <typename T, typename... Args>
-struct CanEmplaceAnyImpl<
-    absl::void_t<decltype(
-        std::declval<absl::any&>().emplace<T>(std::declval<Args>()...))>,
-    T, Args...> : std::true_type {};
-
-template <typename T, typename... Args>
-using CanEmplaceAny = CanEmplaceAnyImpl<void, T, Args...>;
-
-TEST(AnyTest, Emplace) {
-  const CopyOnly copy_only{};
-  absl::any o;
-  EXPECT_TRUE((std::is_same<decltype(o.emplace<IntMoveOnlyCopyOnly>(
-                                5, MoveOnly(), copy_only)),
-                            IntMoveOnlyCopyOnly&>::value));
-  IntMoveOnlyCopyOnly& emplace_result =
-      o.emplace<IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
-  EXPECT_EQ(5, emplace_result.value);
-  IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-  EXPECT_EQ(&emplace_result, &v);
-
-  static_assert(!CanEmplaceAny<int, int, int>::value, "");
-  static_assert(!CanEmplaceAny<MoveOnly, MoveOnly>::value, "");
-}
-
-TEST(AnyTest, EmplaceWithCV) {
-  const CopyOnly copy_only{};
-  absl::any o;
-  EXPECT_TRUE(
-      (std::is_same<decltype(o.emplace<const volatile IntMoveOnlyCopyOnly>(
-                        5, MoveOnly(), copy_only)),
-                    IntMoveOnlyCopyOnly&>::value));
-  IntMoveOnlyCopyOnly& emplace_result =
-      o.emplace<const volatile IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
-  EXPECT_EQ(5, emplace_result.value);
-  IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(5, v.value);
-  EXPECT_EQ(&emplace_result, &v);
-}
-
-TEST(AnyTest, EmplaceWithFunction) {
-  absl::any o;
-  EXPECT_TRUE(
-      (std::is_same<decltype(o.emplace<FunctionType>(FunctionToEmplace)),
-                    FunctionType*&>::value));
-  FunctionType*& emplace_result = o.emplace<FunctionType>(FunctionToEmplace);
-  EXPECT_EQ(&FunctionToEmplace, emplace_result);
-}
-
-TEST(AnyTest, EmplaceWithArray) {
-  absl::any o;
-  ArrayType ar = {5, 42};
-  EXPECT_TRUE(
-      (std::is_same<decltype(o.emplace<ArrayType>(ar)), DecayedArray&>::value));
-  DecayedArray& emplace_result = o.emplace<ArrayType>(ar);
-  EXPECT_EQ(&ar[0], emplace_result);
-}
-
-TEST(AnyTest, EmplaceIlist) {
-  const CopyOnly copy_only{};
-  absl::any o;
-  EXPECT_TRUE((std::is_same<decltype(o.emplace<ListMoveOnlyCopyOnly>(
-                                {1, 2, 3, 4}, MoveOnly(), copy_only)),
-                            ListMoveOnlyCopyOnly&>::value));
-  ListMoveOnlyCopyOnly& emplace_result =
-      o.emplace<ListMoveOnlyCopyOnly>({1, 2, 3, 4}, MoveOnly(), copy_only);
-  ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(&v, &emplace_result);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-
-  static_assert(!CanEmplaceAny<int, std::initializer_list<int>>::value, "");
-  static_assert(!CanEmplaceAny<MoveOnlyWithListConstructor,
-                               std::initializer_list<int>, int>::value,
-                "");
-}
-
-TEST(AnyTest, EmplaceIlistWithCV) {
-  const CopyOnly copy_only{};
-  absl::any o;
-  EXPECT_TRUE(
-      (std::is_same<decltype(o.emplace<const volatile ListMoveOnlyCopyOnly>(
-                        {1, 2, 3, 4}, MoveOnly(), copy_only)),
-                    ListMoveOnlyCopyOnly&>::value));
-  ListMoveOnlyCopyOnly& emplace_result =
-      o.emplace<const volatile ListMoveOnlyCopyOnly>({1, 2, 3, 4}, MoveOnly(),
-                                                     copy_only);
-  ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  EXPECT_EQ(&v, &emplace_result);
-  std::vector<int> expected_values = {1, 2, 3, 4};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-TEST(AnyTest, EmplaceNoArgs) {
-  absl::any o;
-  o.emplace<int>();
-  EXPECT_EQ(0, absl::any_cast<int>(o));
-}
-
-TEST(AnyTest, ConversionConstruction) {
-  {
-    absl::any o = 5;
-    EXPECT_EQ(5, absl::any_cast<int>(o));
-  }
-
-  {
-    const CopyOnly copy_only(5);
-    absl::any o = copy_only;
-    EXPECT_EQ(5, absl::any_cast<CopyOnly&>(o).value);
-  }
-
-  static_assert(!std::is_convertible<MoveOnly, absl::any>::value, "");
-}
-
-TEST(AnyTest, ConversionAssignment) {
-  {
-    absl::any o;
-    o = 5;
-    EXPECT_EQ(5, absl::any_cast<int>(o));
-  }
-
-  {
-    const CopyOnly copy_only(5);
-    absl::any o;
-    o = copy_only;
-    EXPECT_EQ(5, absl::any_cast<CopyOnly&>(o).value);
-  }
-
-  static_assert(!std::is_assignable<MoveOnly, absl::any>::value, "");
-}
-
-// Suppress MSVC warnings.
-// 4521: multiple copy constructors specified
-// We wrote multiple of them to test that the correct overloads are selected.
-#ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4521)
-#endif
-
-// Weird type for testing, only used to make sure we "properly" perfect-forward
-// when being placed into an absl::any (use the l-value constructor if given an
-// l-value rather than use the copy constructor).
-struct WeirdConstructor42 {
-  explicit WeirdConstructor42(int value) : value(value) {}
-
-  // Copy-constructor
-  WeirdConstructor42(const WeirdConstructor42& other) : value(other.value) {}
-
-  // L-value "weird" constructor (used when given an l-value)
-  WeirdConstructor42(
-      WeirdConstructor42& /*other*/)  // NOLINT(runtime/references)
-      : value(42) {}
-
-  int value;
-};
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif
-
-TEST(AnyTest, WeirdConversionConstruction) {
-  {
-    const WeirdConstructor42 source(5);
-    absl::any o = source;  // Actual copy
-    EXPECT_EQ(5, absl::any_cast<WeirdConstructor42&>(o).value);
-  }
-
-  {
-    WeirdConstructor42 source(5);
-    absl::any o = source;  // Weird "conversion"
-    EXPECT_EQ(42, absl::any_cast<WeirdConstructor42&>(o).value);
-  }
-}
-
-TEST(AnyTest, WeirdConversionAssignment) {
-  {
-    const WeirdConstructor42 source(5);
-    absl::any o;
-    o = source;  // Actual copy
-    EXPECT_EQ(5, absl::any_cast<WeirdConstructor42&>(o).value);
-  }
-
-  {
-    WeirdConstructor42 source(5);
-    absl::any o;
-    o = source;  // Weird "conversion"
-    EXPECT_EQ(42, absl::any_cast<WeirdConstructor42&>(o).value);
-  }
-}
-
-struct Value {};
-
-TEST(AnyTest, AnyCastValue) {
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<int>(o));
-    EXPECT_EQ(5, absl::any_cast<int>(AsConst(o)));
-    static_assert(
-        std::is_same<decltype(absl::any_cast<Value>(o)), Value>::value, "");
-  }
-
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<const int>(o));
-    EXPECT_EQ(5, absl::any_cast<const int>(AsConst(o)));
-    static_assert(std::is_same<decltype(absl::any_cast<const Value>(o)),
-                               const Value>::value,
-                  "");
-  }
-}
-
-TEST(AnyTest, AnyCastReference) {
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<int&>(o));
-    EXPECT_EQ(5, absl::any_cast<const int&>(AsConst(o)));
-    static_assert(
-        std::is_same<decltype(absl::any_cast<Value&>(o)), Value&>::value, "");
-  }
-
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<const int>(o));
-    EXPECT_EQ(5, absl::any_cast<const int>(AsConst(o)));
-    static_assert(std::is_same<decltype(absl::any_cast<const Value&>(o)),
-                               const Value&>::value,
-                  "");
-  }
-
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<int&&>(std::move(o)));
-    static_assert(std::is_same<decltype(absl::any_cast<Value&&>(std::move(o))),
-                               Value&&>::value,
-                  "");
-  }
-
-  {
-    absl::any o;
-    o.emplace<int>(5);
-    EXPECT_EQ(5, absl::any_cast<const int>(std::move(o)));
-    static_assert(
-        std::is_same<decltype(absl::any_cast<const Value&&>(std::move(o))),
-                     const Value&&>::value,
-        "");
-  }
-}
-
-TEST(AnyTest, AnyCastPointer) {
-  {
-    absl::any o;
-    EXPECT_EQ(nullptr, absl::any_cast<char>(&o));
-    o.emplace<int>(5);
-    EXPECT_EQ(nullptr, absl::any_cast<char>(&o));
-    o.emplace<char>('a');
-    EXPECT_EQ('a', *absl::any_cast<char>(&o));
-    static_assert(
-        std::is_same<decltype(absl::any_cast<Value>(&o)), Value*>::value, "");
-  }
-
-  {
-    absl::any o;
-    EXPECT_EQ(nullptr, absl::any_cast<const char>(&o));
-    o.emplace<int>(5);
-    EXPECT_EQ(nullptr, absl::any_cast<const char>(&o));
-    o.emplace<char>('a');
-    EXPECT_EQ('a', *absl::any_cast<const char>(&o));
-    static_assert(std::is_same<decltype(absl::any_cast<const Value>(&o)),
-                               const Value*>::value,
-                  "");
-  }
-}
-
-TEST(AnyTest, MakeAny) {
-  const CopyOnly copy_only{};
-  auto o = absl::make_any<IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
-  static_assert(std::is_same<decltype(o), absl::any>::value, "");
-  EXPECT_EQ(5, absl::any_cast<IntMoveOnlyCopyOnly&>(o).value);
-}
-
-TEST(AnyTest, MakeAnyIList) {
-  const CopyOnly copy_only{};
-  auto o =
-      absl::make_any<ListMoveOnlyCopyOnly>({1, 2, 3}, MoveOnly(), copy_only);
-  static_assert(std::is_same<decltype(o), absl::any>::value, "");
-  ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
-  std::vector<int> expected_values = {1, 2, 3};
-  EXPECT_EQ(expected_values, v.values);
-}
-
-// Test the use of copy constructor and operator=
-TEST(AnyTest, Copy) {
-  InstanceTracker tracker_raii;
-
-  {
-    absl::any o(absl::in_place_type<CopyableOnlyInstance>, 123);
-    CopyableOnlyInstance* f1 = absl::any_cast<CopyableOnlyInstance>(&o);
-
-    absl::any o2(o);
-    const CopyableOnlyInstance* f2 = absl::any_cast<CopyableOnlyInstance>(&o2);
-    EXPECT_EQ(123, f2->value());
-    EXPECT_NE(f1, f2);
-
-    absl::any o3;
-    o3 = o2;
-    const CopyableOnlyInstance* f3 = absl::any_cast<CopyableOnlyInstance>(&o3);
-    EXPECT_EQ(123, f3->value());
-    EXPECT_NE(f2, f3);
-
-    const absl::any o4(4);
-    // copy construct from const lvalue ref.
-    absl::any o5 = o4;
-    EXPECT_EQ(4, absl::any_cast<int>(o4));
-    EXPECT_EQ(4, absl::any_cast<int>(o5));
-
-    // Copy construct from const rvalue ref.
-    absl::any o6 = std::move(o4);  // NOLINT
-    EXPECT_EQ(4, absl::any_cast<int>(o4));
-    EXPECT_EQ(4, absl::any_cast<int>(o6));
-  }
-}
-
-TEST(AnyTest, Move) {
-  InstanceTracker tracker_raii;
-
-  absl::any any1;
-  any1.emplace<CopyableOnlyInstance>(5);
-
-  // This is a copy, so copy count increases to 1.
-  absl::any any2 = any1;
-  EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any1).value());
-  EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any2).value());
-  EXPECT_EQ(1, tracker_raii.copies());
-
-  // This isn't a copy, so copy count doesn't increase.
-  absl::any any3 = std::move(any2);
-  EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any3).value());
-  EXPECT_EQ(1, tracker_raii.copies());
-
-  absl::any any4;
-  any4 = std::move(any3);
-  EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any4).value());
-  EXPECT_EQ(1, tracker_raii.copies());
-
-  absl::any tmp4(4);
-  absl::any o4(std::move(tmp4));  // move construct
-  EXPECT_EQ(4, absl::any_cast<int>(o4));
-  o4 = *&o4;  // self assign
-  EXPECT_EQ(4, absl::any_cast<int>(o4));
-  EXPECT_TRUE(o4.has_value());
-
-  absl::any o5;
-  absl::any tmp5(5);
-  o5 = std::move(tmp5);  // move assign
-  EXPECT_EQ(5, absl::any_cast<int>(o5));
-}
-
-// Reset the ObjectOwner with an object of a different type
-TEST(AnyTest, Reset) {
-  absl::any o;
-  o.emplace<int>();
-
-  o.reset();
-  EXPECT_FALSE(o.has_value());
-
-  o.emplace<char>();
-  EXPECT_TRUE(o.has_value());
-}
-
-TEST(AnyTest, ConversionConstructionCausesOneCopy) {
-  InstanceTracker tracker_raii;
-  CopyableOnlyInstance counter(5);
-  absl::any o(counter);
-  EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(o).value());
-  EXPECT_EQ(1, tracker_raii.copies());
-}
-
-//////////////////////////////////
-// Tests for Exception Behavior //
-//////////////////////////////////
-
-#if defined(ABSL_USES_STD_ANY)
-
-// If using a std `any` implementation, we can't check for a specific message.
-#define ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(...)                      \
-  ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), absl::bad_any_cast, \
-                                 "")
-
-#else
-
-// If using the absl `any` implementation, we can rely on a specific message.
-#define ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(...)                      \
-  ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), absl::bad_any_cast, \
-                                 "Bad any cast")
-
-#endif  // defined(ABSL_USES_STD_ANY)
-
-TEST(AnyTest, ThrowBadAlloc) {
-  {
-    absl::any a;
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int&>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int&&>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&&>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(absl::any{}));
-
-    // const absl::any operand
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&>(AsConst(a)));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(AsConst(a)));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(AsConst(a)));
-  }
-
-  {
-    absl::any a(absl::in_place_type<int>);
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float&>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float&>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float&&>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(
-        absl::any_cast<const float&&>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(a));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(absl::any{}));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(absl::any{}));
-
-    // const absl::any operand
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float&>(AsConst(a)));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(AsConst(a)));
-    ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(AsConst(a)));
-  }
-}
-
-class BadCopy {};
-
-struct BadCopyable {
-  BadCopyable() = default;
-  BadCopyable(BadCopyable&&) = default;
-  BadCopyable(const BadCopyable&) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-    throw BadCopy();
-#else
-    LOG(FATAL) << "Bad copy";
-#endif
-  }
-};
-
-#define ABSL_ANY_TEST_EXPECT_BAD_COPY(...) \
-  ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), BadCopy, "Bad copy")
-
-// Test the guarantees regarding exceptions in copy/assign.
-TEST(AnyTest, FailedCopy) {
-  {
-    const BadCopyable bad{};
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(absl::any{bad});
-  }
-
-  {
-    absl::any src(absl::in_place_type<BadCopyable>);
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(absl::any{src});
-  }
-
-  {
-    BadCopyable bad;
-    absl::any target;
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(target = bad);
-  }
-
-  {
-    BadCopyable bad;
-    absl::any target(absl::in_place_type<BadCopyable>);
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(target = bad);
-    EXPECT_TRUE(target.has_value());
-  }
-
-  {
-    absl::any src(absl::in_place_type<BadCopyable>);
-    absl::any target;
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(target = src);
-    EXPECT_FALSE(target.has_value());
-  }
-
-  {
-    absl::any src(absl::in_place_type<BadCopyable>);
-    absl::any target(absl::in_place_type<BadCopyable>);
-    ABSL_ANY_TEST_EXPECT_BAD_COPY(target = src);
-    EXPECT_TRUE(target.has_value());
-  }
-}
-
-// Test the guarantees regarding exceptions in emplace.
-TEST(AnyTest, FailedEmplace) {
-  BadCopyable bad;
-  absl::any target;
-  ABSL_ANY_TEST_EXPECT_BAD_COPY(target.emplace<BadCopyable>(bad));
-}
-
-// GCC and Clang have a bug here.
-// Ine some cases, the exception seems to be thrown at the wrong time, and
-// target may contain a value.
-#ifdef __GNUC__
-TEST(AnyTest, DISABLED_FailedEmplaceInPlace) {
-#else
-TEST(AnyTest, FailedEmplaceInPlace) {
-#endif
-  BadCopyable bad;
-  absl::any target(absl::in_place_type<int>);
-  ABSL_ANY_TEST_EXPECT_BAD_COPY(target.emplace<BadCopyable>(bad));
-  EXPECT_FALSE(target.has_value());
-}
-
-}  // namespace
-
-#endif  // #if !defined(ABSL_USES_STD_ANY)