//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <any>
// template <class ValueType>
// ValueType const any_cast(any const&);
//
// template <class ValueType>
// ValueType any_cast(any &);
//
// template <class ValueType>
// ValueType any_cast(any &&);
#include <any>
#include <type_traits>
#include <cassert>
#include "any_helpers.h"
#include "count_new.h"
#include "test_macros.h"
// Test that the operators are NOT marked noexcept.
void test_cast_is_not_noexcept() {
std::any a;
static_assert(!noexcept(std::any_cast<int>(static_cast<std::any&>(a))), "");
static_assert(!noexcept(std::any_cast<int>(static_cast<std::any const&>(a))), "");
static_assert(!noexcept(std::any_cast<int>(static_cast<std::any &&>(a))), "");
}
// Test that the return type of any_cast is correct.
void test_cast_return_type() {
std::any a;
static_assert(std::is_same<decltype(std::any_cast<int>(a)), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const>(a)), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int&>(a)), int&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&>(a)), int const&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int&&>(a)), int&&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&&>(a)), int const&&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int>(std::move(a))), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const>(std::move(a))), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int&>(std::move(a))), int&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&>(std::move(a))), int const&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int&&>(std::move(a))), int&&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&&>(std::move(a))), int const&&>::value, "");
const std::any& ca = a;
static_assert(std::is_same<decltype(std::any_cast<int>(ca)), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const>(ca)), int>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&>(ca)), int const&>::value, "");
static_assert(std::is_same<decltype(std::any_cast<int const&&>(ca)), int const&&>::value, "");
}
template <class Type, class ConstT = Type>
void checkThrows(std::any& a)
{
#if !defined(TEST_HAS_NO_EXCEPTIONS)
try {
TEST_IGNORE_NODISCARD std::any_cast<Type>(a);
assert(false);
} catch (const std::bad_any_cast&) {
// do nothing
} catch (...) {
assert(false);
}
try {
TEST_IGNORE_NODISCARD std::any_cast<ConstT>(static_cast<const std::any&>(a));
assert(false);
} catch (const std::bad_any_cast&) {
// do nothing
} catch (...) {
assert(false);
}
try {
using RefType = typename std::conditional<
std::is_lvalue_reference<Type>::value,
typename std::remove_reference<Type>::type&&,
Type
>::type;
TEST_IGNORE_NODISCARD std::any_cast<RefType>(static_cast<std::any&&>(a));
assert(false);
} catch (const std::bad_any_cast&) {
// do nothing
} catch (...) {
assert(false);
}
#else
(TEST_IGNORE_NODISCARD a);
#endif
}
void test_cast_empty() {
// None of these operations should allocate.
DisableAllocationGuard g; (TEST_IGNORE_NODISCARD g);
std::any a;
checkThrows<int>(a);
}
template <class Type>
void test_cast_to_reference() {
assert(Type::count == 0);
Type::reset();
{
std::any a = Type(42);
const std::any& ca = a;
assert(Type::count == 1);
assert(Type::copied == 0);
assert(Type::moved == 1);
// Try a cast to a bad type.
// NOTE: Type cannot be an int.
checkThrows<int>(a);
checkThrows<int&, int const&>(a);
checkThrows<Type*, Type const*>(a);
checkThrows<Type const*>(a);
// Check getting a type by reference from a non-const lvalue any.
{
Type& v = std::any_cast<Type&>(a);
assert(v.value == 42);
Type const &cv = std::any_cast<Type const&>(a);
assert(&cv == &v);
}
// Check getting a type by reference from a const lvalue any.
{
Type const& v = std::any_cast<Type const&>(ca);
assert(v.value == 42);
Type const &cv = std::any_cast<Type const&>(ca);
assert(&cv == &v);
}
// Check getting a type by reference from a const rvalue any.
{
Type const& v = std::any_cast<Type const&>(std::move(ca));
assert(v.value == 42);
Type const &cv = std::any_cast<Type const&>(std::move(ca));
assert(&cv == &v);
}
// Check getting a type by reference from a const rvalue any.
{
Type&& v = std::any_cast<Type&&>(std::move(a));
assert(v.value == 42);
assert(std::any_cast<Type&>(a).value == 42);
Type&& cv = std::any_cast<Type&&>(std::move(a));
assert(&cv == &v);
assert(std::any_cast<Type&>(a).value == 42);
}
// Check getting a type by reference from a const rvalue any.
{
Type const&& v = std::any_cast<Type const&&>(std::move(a));
assert(v.value == 42);
assert(std::any_cast<Type&>(a).value == 42);
Type const&& cv = std::any_cast<Type const&&>(std::move(a));
assert(&cv == &v);
assert(std::any_cast<Type&>(a).value == 42);
}
// Check that the original object hasn't been changed.
assertContains<Type>(a, 42);
// Check that no objects have been created/copied/moved.
assert(Type::count == 1);
assert(Type::copied == 0);
assert(Type::moved == 1);
}
assert(Type::count == 0);
}
template <class Type>
void test_cast_to_value() {
assert(Type::count == 0);
Type::reset();
{
std::any a = Type(42);
assert(Type::count == 1);
assert(Type::copied == 0);
assert(Type::moved == 1);
// Try a cast to a bad type.
// NOTE: Type cannot be an int.
checkThrows<int>(a);
checkThrows<int&, int const&>(a);
checkThrows<Type*, Type const*>(a);
checkThrows<Type const*>(a);
Type::reset(); // NOTE: reset does not modify Type::count
// Check getting Type by value from a non-const lvalue any.
// This should cause the non-const copy constructor to be called.
{
Type t = std::any_cast<Type>(a);
assert(Type::count == 2);
assert(Type::copied == 1);
assert(Type::const_copied == 0);
assert(Type::non_const_copied == 1);
assert(Type::moved == 0);
assert(t.value == 42);
}
assert(Type::count == 1);
Type::reset();
// Check getting const Type by value from a non-const lvalue any.
// This should cause the const copy constructor to be called.
{
Type t = std::any_cast<Type const>(a);
assert(Type::count == 2);
assert(Type::copied == 1);
assert(Type::const_copied == 0);
assert(Type::non_const_copied == 1);
assert(Type::moved == 0);
assert(t.value == 42);
}
assert(Type::count == 1);
Type::reset();
// Check getting Type by value from a non-const lvalue any.
// This should cause the const copy constructor to be called.
{
Type t = std::any_cast<Type>(static_cast<const std::any&>(a));
assert(Type::count == 2);
assert(Type::copied == 1);
assert(Type::const_copied == 1);
assert(Type::non_const_copied == 0);
assert(Type::moved == 0);
assert(t.value == 42);
}
assert(Type::count == 1);
Type::reset();
// Check getting Type by value from a non-const rvalue any.
// This should cause the non-const copy constructor to be called.
{
Type t = std::any_cast<Type>(static_cast<std::any&&>(a));
assert(Type::count == 2);
assert(Type::moved == 1);
assert(Type::copied == 0);
assert(Type::const_copied == 0);
assert(Type::non_const_copied == 0);
assert(t.value == 42);
assert(std::any_cast<Type&>(a).value == 0);
std::any_cast<Type&>(a).value = 42; // reset the value
}
assert(Type::count == 1);
Type::reset();
// Check getting const Type by value from a non-const rvalue any.
// This should cause the const copy constructor to be called.
{
Type t = std::any_cast<Type const>(static_cast<std::any&&>(a));
assert(Type::count == 2);
assert(Type::copied == 0);
assert(Type::const_copied == 0);
assert(Type::non_const_copied == 0);
assert(Type::moved == 1);
assert(t.value == 42);
assert(std::any_cast<Type&>(a).value == 0);
std::any_cast<Type&>(a).value = 42; // reset the value
}
assert(Type::count == 1);
Type::reset();
// Check getting Type by value from a const rvalue any.
// This should cause the const copy constructor to be called.
{
Type t = std::any_cast<Type>(static_cast<const std::any&&>(a));
assert(Type::count == 2);
assert(Type::copied == 1);
assert(Type::const_copied == 1);
assert(Type::non_const_copied == 0);
assert(Type::moved == 0);
assert(t.value == 42);
assert(std::any_cast<Type&>(a).value == 42);
}
// Ensure we still only have 1 Type object alive.
assert(Type::count == 1);
// Check that the original object hasn't been changed.
assertContains<Type>(a, 42);
}
assert(Type::count == 0);
}
int main(int, char**) {
test_cast_is_not_noexcept();
test_cast_return_type();
test_cast_empty();
test_cast_to_reference<small>();
test_cast_to_reference<large>();
test_cast_to_value<small>();
test_cast_to_value<large>();
return 0;
}
Codebase Browser
llvm