blob: 666ea5b6a420d6738b7eafc7f01e5d700cca6d0e [file] [log] [blame]
// 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)