| // Copyright 2022 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/functional/any_invocable.h" |
| |
| #include <cstddef> |
| #include <initializer_list> |
| #include <memory> |
| #include <numeric> |
| #include <type_traits> |
| |
| #include "gtest/gtest.h" |
| #include "absl/base/config.h" |
| #include "absl/meta/type_traits.h" |
| #include "absl/utility/utility.h" |
| |
| static_assert(absl::internal_any_invocable::kStorageSize >= sizeof(void*), |
| "These tests assume that the small object storage is at least " |
| "the size of a pointer."); |
| |
| namespace { |
| |
| // Helper macro used to avoid spelling `noexcept` in language versions older |
| // than C++17, where it is not part of the type system, in order to avoid |
| // compilation failures and internal compiler errors. |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L |
| #define ABSL_INTERNAL_NOEXCEPT_SPEC(noex) noexcept(noex) |
| #else |
| #define ABSL_INTERNAL_NOEXCEPT_SPEC(noex) |
| #endif |
| |
| // A dummy type we use when passing qualifiers to metafunctions |
| struct _ {}; |
| |
| template <class T> |
| struct Wrapper { |
| template <class U, |
| class = absl::enable_if_t<std::is_convertible<U, T>::value>> |
| Wrapper(U&&); // NOLINT |
| }; |
| |
| // This will cause a recursive trait instantiation if the SFINAE checks are |
| // not ordered correctly for constructibility. |
| static_assert(std::is_constructible<Wrapper<absl::AnyInvocable<void()>>, |
| Wrapper<absl::AnyInvocable<void()>>>::value, |
| ""); |
| |
| // A metafunction that takes the cv and l-value reference qualifiers that were |
| // associated with a function type (here passed via qualifiers of an object |
| // type), and . |
| template <class Qualifiers, class This> |
| struct QualifiersForThisImpl { |
| static_assert(std::is_object<This>::value, ""); |
| using type = |
| absl::conditional_t<std::is_const<Qualifiers>::value, const This, This>&; |
| }; |
| |
| template <class Qualifiers, class This> |
| struct QualifiersForThisImpl<Qualifiers&, This> |
| : QualifiersForThisImpl<Qualifiers, This> {}; |
| |
| template <class Qualifiers, class This> |
| struct QualifiersForThisImpl<Qualifiers&&, This> { |
| static_assert(std::is_object<This>::value, ""); |
| using type = |
| absl::conditional_t<std::is_const<Qualifiers>::value, const This, This>&&; |
| }; |
| |
| template <class Qualifiers, class This> |
| using QualifiersForThis = |
| typename QualifiersForThisImpl<Qualifiers, This>::type; |
| |
| // A metafunction that takes the cv and l-value reference qualifier of T and |
| // applies them to U's function type qualifiers. |
| template <class T, class Fun> |
| struct GiveQualifiersToFunImpl; |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T, R(P...)> { |
| using type = |
| absl::conditional_t<std::is_const<T>::value, R(P...) const, R(P...)>; |
| }; |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T&, R(P...)> { |
| using type = |
| absl::conditional_t<std::is_const<T>::value, R(P...) const&, R(P...)&>; |
| }; |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T&&, R(P...)> { |
| using type = |
| absl::conditional_t<std::is_const<T>::value, R(P...) const&&, R(P...) &&>; |
| }; |
| |
| // If noexcept is a part of the type system, then provide the noexcept forms. |
| #if defined(__cpp_noexcept_function_type) |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T, R(P...) noexcept> { |
| using type = absl::conditional_t<std::is_const<T>::value, |
| R(P...) const noexcept, R(P...) noexcept>; |
| }; |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T&, R(P...) noexcept> { |
| using type = |
| absl::conditional_t<std::is_const<T>::value, R(P...) const & noexcept, |
| R(P...) & noexcept>; |
| }; |
| |
| template <class T, class R, class... P> |
| struct GiveQualifiersToFunImpl<T&&, R(P...) noexcept> { |
| using type = |
| absl::conditional_t<std::is_const<T>::value, R(P...) const && noexcept, |
| R(P...) && noexcept>; |
| }; |
| |
| #endif // defined(__cpp_noexcept_function_type) |
| |
| template <class T, class Fun> |
| using GiveQualifiersToFun = typename GiveQualifiersToFunImpl<T, Fun>::type; |
| |
| // This is used in template parameters to decide whether or not to use a type |
| // that fits in the small object optimization storage. |
| enum class ObjSize { small, large }; |
| |
| // A base type that is used with classes as a means to insert an |
| // appropriately-sized dummy datamember when Size is ObjSize::large so that the |
| // user's class type is guaranteed to not fit in small object storage. |
| template <ObjSize Size> |
| struct TypeErasedPadding; |
| |
| template <> |
| struct TypeErasedPadding<ObjSize::small> {}; |
| |
| template <> |
| struct TypeErasedPadding<ObjSize::large> { |
| char dummy_data[absl::internal_any_invocable::kStorageSize + 1] = {}; |
| }; |
| |
| struct Int { |
| Int(int v) noexcept : value(v) {} // NOLINT |
| #ifndef _MSC_VER |
| Int(Int&&) noexcept { |
| // NOTE: Prior to C++17, this not being called requires optimizations to |
| // take place when performing the top-level invocation. In practice, |
| // most supported compilers perform this optimization prior to C++17. |
| std::abort(); |
| } |
| #else |
| Int(Int&& v) noexcept = default; |
| #endif |
| operator int() && noexcept { return value; } // NOLINT |
| |
| int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT |
| return value + b + c; |
| } |
| |
| int value; |
| }; |
| |
| enum class Movable { no, yes, nothrow, trivial }; |
| |
| enum class NothrowCall { no, yes }; |
| |
| enum class Destructible { nothrow, trivial }; |
| |
| enum class ObjAlign : std::size_t { |
| normal = absl::internal_any_invocable::kAlignment, |
| large = absl::internal_any_invocable::kAlignment * 2, |
| }; |
| |
| // A function-object template that has knobs for each property that can affect |
| // how the object is stored in AnyInvocable. |
| template <Movable Movability, Destructible Destructibility, class Qual, |
| NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> |
| struct add; |
| |
| #define ABSL_INTERNALS_ADD(qual) \ |
| template <NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> \ |
| struct alignas(static_cast<std::size_t>(Alignment)) \ |
| add<Movable::trivial, Destructible::trivial, _ qual, CallExceptionSpec, \ |
| Size, Alignment> : TypeErasedPadding<Size> { \ |
| explicit add(int state_init) : state(state_init) {} \ |
| explicit add(std::initializer_list<int> state_init, int tail) \ |
| : state(std::accumulate(std::begin(state_init), std::end(state_init), \ |
| 0) + \ |
| tail) {} \ |
| add(add&& other) = default; /*NOLINT*/ \ |
| Int operator()(int a, int b, int c) qual \ |
| ABSL_INTERNAL_NOEXCEPT_SPEC(CallExceptionSpec == NothrowCall::yes) { \ |
| return state + a + b + c; \ |
| } \ |
| int state; \ |
| }; \ |
| \ |
| template <NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> \ |
| struct alignas(static_cast<std::size_t>(Alignment)) \ |
| add<Movable::trivial, Destructible::nothrow, _ qual, CallExceptionSpec, \ |
| Size, Alignment> : TypeErasedPadding<Size> { \ |
| explicit add(int state_init) : state(state_init) {} \ |
| explicit add(std::initializer_list<int> state_init, int tail) \ |
| : state(std::accumulate(std::begin(state_init), std::end(state_init), \ |
| 0) + \ |
| tail) {} \ |
| ~add() noexcept {} \ |
| add(add&& other) = default; /*NOLINT*/ \ |
| Int operator()(int a, int b, int c) qual \ |
| ABSL_INTERNAL_NOEXCEPT_SPEC(CallExceptionSpec == NothrowCall::yes) { \ |
| return state + a + b + c; \ |
| } \ |
| int state; \ |
| } |
| |
| // Explicitly specify an empty argument. |
| // MSVC (at least up to _MSC_VER 1931, if not beyond) warns that |
| // ABSL_INTERNALS_ADD() is an undefined zero-arg overload. |
| #define ABSL_INTERNALS_NOARG |
| ABSL_INTERNALS_ADD(ABSL_INTERNALS_NOARG); |
| #undef ABSL_INTERNALS_NOARG |
| |
| ABSL_INTERNALS_ADD(const); |
| ABSL_INTERNALS_ADD(&); |
| ABSL_INTERNALS_ADD(const&); |
| ABSL_INTERNALS_ADD(&&); // NOLINT |
| ABSL_INTERNALS_ADD(const&&); // NOLINT |
| |
| #undef ABSL_INTERNALS_ADD |
| |
| template <Destructible Destructibility, class Qual, |
| NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> |
| struct add<Movable::no, Destructibility, Qual, CallExceptionSpec, Size, |
| Alignment> : private add<Movable::trivial, Destructibility, Qual, |
| CallExceptionSpec, Size, Alignment> { |
| using Base = add<Movable::trivial, Destructibility, Qual, CallExceptionSpec, |
| Size, Alignment>; |
| |
| explicit add(int state_init) : Base(state_init) {} |
| |
| explicit add(std::initializer_list<int> state_init, int tail) |
| : Base(state_init, tail) {} |
| |
| add(add&&) = delete; |
| |
| using Base::operator(); |
| using Base::state; |
| }; |
| |
| template <Destructible Destructibility, class Qual, |
| NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> |
| struct add<Movable::yes, Destructibility, Qual, CallExceptionSpec, Size, |
| Alignment> : private add<Movable::trivial, Destructibility, Qual, |
| CallExceptionSpec, Size, Alignment> { |
| using Base = add<Movable::trivial, Destructibility, Qual, CallExceptionSpec, |
| Size, Alignment>; |
| |
| explicit add(int state_init) : Base(state_init) {} |
| |
| explicit add(std::initializer_list<int> state_init, int tail) |
| : Base(state_init, tail) {} |
| |
| add(add&& other) noexcept(false) : Base(other.state) {} // NOLINT |
| |
| using Base::operator(); |
| using Base::state; |
| }; |
| |
| template <Destructible Destructibility, class Qual, |
| NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> |
| struct add<Movable::nothrow, Destructibility, Qual, CallExceptionSpec, Size, |
| Alignment> : private add<Movable::trivial, Destructibility, Qual, |
| CallExceptionSpec, Size, Alignment> { |
| using Base = add<Movable::trivial, Destructibility, Qual, CallExceptionSpec, |
| Size, Alignment>; |
| |
| explicit add(int state_init) : Base(state_init) {} |
| |
| explicit add(std::initializer_list<int> state_init, int tail) |
| : Base(state_init, tail) {} |
| |
| add(add&& other) noexcept : Base(other.state) {} |
| |
| using Base::operator(); |
| using Base::state; |
| }; |
| |
| // Actual non-member functions rather than function objects |
| Int add_function(Int&& a, int b, int c) noexcept { return a.value + b + c; } |
| |
| Int mult_function(Int&& a, int b, int c) noexcept { return a.value * b * c; } |
| |
| Int square_function(Int const&& a) noexcept { return a.value * a.value; } |
| |
| template <class Sig> |
| using AnyInvocable = absl::AnyInvocable<Sig>; |
| |
| // Instantiations of this template contains all of the compile-time parameters |
| // for a given instantiation of the AnyInvocable test suite. |
| template <Movable Movability, Destructible Destructibility, class Qual, |
| NothrowCall CallExceptionSpec, ObjSize Size, ObjAlign Alignment> |
| struct TestParams { |
| static constexpr Movable kMovability = Movability; |
| static constexpr Destructible kDestructibility = Destructibility; |
| using Qualifiers = Qual; |
| static constexpr NothrowCall kCallExceptionSpec = CallExceptionSpec; |
| static constexpr bool kIsNoexcept = kCallExceptionSpec == NothrowCall::yes; |
| static constexpr bool kIsRvalueQualified = |
| std::is_rvalue_reference<Qual>::value; |
| static constexpr ObjSize kSize = Size; |
| static constexpr ObjAlign kAlignment = Alignment; |
| |
| // These types are used when testing with member object pointer Invocables |
| using UnqualifiedUnaryFunType = int(Int const&&) |
| ABSL_INTERNAL_NOEXCEPT_SPEC(CallExceptionSpec == NothrowCall::yes); |
| using UnaryFunType = GiveQualifiersToFun<Qualifiers, UnqualifiedUnaryFunType>; |
| using MemObjPtrType = int(Int::*); |
| using UnaryAnyInvType = AnyInvocable<UnaryFunType>; |
| using UnaryThisParamType = QualifiersForThis<Qualifiers, UnaryAnyInvType>; |
| |
| template <class T> |
| static UnaryThisParamType ToUnaryThisParam(T&& fun) { |
| return static_cast<UnaryThisParamType>(fun); |
| } |
| |
| // This function type intentionally uses 3 "kinds" of parameter types. |
| // - A user-defined type |
| // - A reference type |
| // - A scalar type |
| // |
| // These were chosen because internal forwarding takes place on parameters |
| // differently depending based on type properties (scalars are forwarded by |
| // value). |
| using ResultType = Int; |
| using AnyInvocableFunTypeNotNoexcept = Int(Int, const int&, int); |
| using UnqualifiedFunType = |
| typename std::conditional<kIsNoexcept, Int(Int, const int&, int) noexcept, |
| Int(Int, const int&, int)>::type; |
| using FunType = GiveQualifiersToFun<Qualifiers, UnqualifiedFunType>; |
| using MemFunPtrType = |
| typename std::conditional<kIsNoexcept, |
| Int (Int::*)(const int&, int) noexcept, |
| Int (Int::*)(const int&, int)>::type; |
| using AnyInvType = AnyInvocable<FunType>; |
| using AddType = add<kMovability, kDestructibility, Qualifiers, |
| kCallExceptionSpec, kSize, kAlignment>; |
| using ThisParamType = QualifiersForThis<Qualifiers, AnyInvType>; |
| |
| template <class T> |
| static ThisParamType ToThisParam(T&& fun) { |
| return static_cast<ThisParamType>(fun); |
| } |
| |
| // These typedefs are used when testing void return type covariance. |
| using UnqualifiedVoidFunType = |
| typename std::conditional<kIsNoexcept, |
| void(Int, const int&, int) noexcept, |
| void(Int, const int&, int)>::type; |
| using VoidFunType = GiveQualifiersToFun<Qualifiers, UnqualifiedVoidFunType>; |
| using VoidAnyInvType = AnyInvocable<VoidFunType>; |
| using VoidThisParamType = QualifiersForThis<Qualifiers, VoidAnyInvType>; |
| |
| template <class T> |
| static VoidThisParamType ToVoidThisParam(T&& fun) { |
| return static_cast<VoidThisParamType>(fun); |
| } |
| |
| using CompatibleAnyInvocableFunType = |
| absl::conditional_t<std::is_rvalue_reference<Qual>::value, |
| GiveQualifiersToFun<const _&&, UnqualifiedFunType>, |
| GiveQualifiersToFun<const _&, UnqualifiedFunType>>; |
| |
| using CompatibleAnyInvType = AnyInvocable<CompatibleAnyInvocableFunType>; |
| |
| using IncompatibleInvocable = |
| absl::conditional_t<std::is_rvalue_reference<Qual>::value, |
| GiveQualifiersToFun<_&, UnqualifiedFunType>(_::*), |
| GiveQualifiersToFun<_&&, UnqualifiedFunType>(_::*)>; |
| }; |
| |
| // Given a member-pointer type, this metafunction yields the target type of the |
| // pointer, not including the class-type. It is used to verify that the function |
| // call operator of AnyInvocable has the proper signature, corresponding to the |
| // function type that the user provided. |
| template <class MemberPtrType> |
| struct MemberTypeOfImpl; |
| |
| template <class Class, class T> |
| struct MemberTypeOfImpl<T(Class::*)> { |
| using type = T; |
| }; |
| |
| template <class MemberPtrType> |
| using MemberTypeOf = typename MemberTypeOfImpl<MemberPtrType>::type; |
| |
| template <class T, class = void> |
| struct IsMemberSwappableImpl : std::false_type { |
| static constexpr bool kIsNothrow = false; |
| }; |
| |
| template <class T> |
| struct IsMemberSwappableImpl< |
| T, absl::void_t<decltype(std::declval<T&>().swap(std::declval<T&>()))>> |
| : std::true_type { |
| static constexpr bool kIsNothrow = |
| noexcept(std::declval<T&>().swap(std::declval<T&>())); |
| }; |
| |
| template <class T> |
| using IsMemberSwappable = IsMemberSwappableImpl<T>; |
| |
| template <class T> |
| using IsNothrowMemberSwappable = |
| std::integral_constant<bool, IsMemberSwappableImpl<T>::kIsNothrow>; |
| |
| template <class T> |
| class AnyInvTestBasic : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestBasic); |
| |
| TYPED_TEST_P(AnyInvTestBasic, DefaultConstruction) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| |
| EXPECT_TRUE(std::is_nothrow_default_constructible<AnyInvType>::value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionNullptr) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = nullptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| |
| EXPECT_TRUE( |
| (std::is_nothrow_constructible<AnyInvType, std::nullptr_t>::value)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionNullFunctionPtr) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using UnqualifiedFunType = typename TypeParam::UnqualifiedFunType; |
| |
| UnqualifiedFunType* const null_fun_ptr = nullptr; |
| AnyInvType fun = null_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionNullMemberFunctionPtr) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using MemFunPtrType = typename TypeParam::MemFunPtrType; |
| |
| const MemFunPtrType null_mem_fun_ptr = nullptr; |
| AnyInvType fun = null_mem_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionNullMemberObjectPtr) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| using MemObjPtrType = typename TypeParam::MemObjPtrType; |
| |
| const MemObjPtrType null_mem_obj_ptr = nullptr; |
| UnaryAnyInvType fun = null_mem_obj_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionMemberFunctionPtr) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = &Int::MemberFunctionAdd; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionMemberObjectPtr) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| |
| UnaryAnyInvType fun = &Int::value; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(13, TypeParam::ToUnaryThisParam(fun)(13)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionFunctionReferenceDecay) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = add_function; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionCompatibleAnyInvocableEmpty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other; |
| AnyInvType fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| EXPECT_EQ(other, nullptr); // NOLINT |
| EXPECT_EQ(nullptr, other); // NOLINT |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConstructionCompatibleAnyInvocableNonempty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other = &add_function; |
| AnyInvType fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| EXPECT_EQ(other, nullptr); // NOLINT |
| EXPECT_EQ(nullptr, other); // NOLINT |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ConversionToBool) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| { |
| AnyInvType fun; |
| |
| // This tests contextually-convertible-to-bool. |
| EXPECT_FALSE(fun ? true : false); // NOLINT |
| |
| // Make sure that the conversion is not implicit. |
| EXPECT_TRUE( |
| (std::is_nothrow_constructible<bool, const AnyInvType&>::value)); |
| EXPECT_FALSE((std::is_convertible<const AnyInvType&, bool>::value)); |
| } |
| |
| { |
| AnyInvType fun = &add_function; |
| |
| // This tests contextually-convertible-to-bool. |
| EXPECT_TRUE(fun ? true : false); // NOLINT |
| } |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, Invocation) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| using FunType = typename TypeParam::FunType; |
| using AnyInvCallType = MemberTypeOf<decltype(&AnyInvType::operator())>; |
| |
| // Make sure the function call operator of AnyInvocable always has the |
| // type that was specified via the template argument. |
| EXPECT_TRUE((std::is_same<AnyInvCallType, FunType>::value)); |
| |
| AnyInvType fun = &add_function; |
| |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceConstruction) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceConstructionInitializerList) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun(absl::in_place_type<AddType>, {1, 2, 3, 4}, 5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(39, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullFunPtrConstruction) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using UnqualifiedFunType = typename TypeParam::UnqualifiedFunType; |
| |
| AnyInvType fun(absl::in_place_type<UnqualifiedFunType*>, nullptr); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullFunPtrConstructionValueInit) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using UnqualifiedFunType = typename TypeParam::UnqualifiedFunType; |
| |
| AnyInvType fun(absl::in_place_type<UnqualifiedFunType*>); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemFunPtrConstruction) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using MemFunPtrType = typename TypeParam::MemFunPtrType; |
| |
| AnyInvType fun(absl::in_place_type<MemFunPtrType>, nullptr); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemFunPtrConstructionValueInit) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using MemFunPtrType = typename TypeParam::MemFunPtrType; |
| |
| AnyInvType fun(absl::in_place_type<MemFunPtrType>); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemObjPtrConstruction) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| using MemObjPtrType = typename TypeParam::MemObjPtrType; |
| |
| UnaryAnyInvType fun(absl::in_place_type<MemObjPtrType>, nullptr); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemObjPtrConstructionValueInit) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| using MemObjPtrType = typename TypeParam::MemObjPtrType; |
| |
| UnaryAnyInvType fun(absl::in_place_type<MemObjPtrType>); |
| |
| // In-place construction does not lead to empty. |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, InPlaceVoidCovarianceConstruction) { |
| using VoidAnyInvType = typename TypeParam::VoidAnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| VoidAnyInvType fun(absl::in_place_type<AddType>, 5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, MoveConstructionFromEmpty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType source_fun; |
| AnyInvType fun(std::move(source_fun)); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| |
| EXPECT_TRUE(std::is_nothrow_move_constructible<AnyInvType>::value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, MoveConstructionFromNonEmpty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType source_fun(absl::in_place_type<AddType>, 5); |
| AnyInvType fun(std::move(source_fun)); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE(std::is_nothrow_move_constructible<AnyInvType>::value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ComparisonWithNullptrEmpty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun; |
| |
| EXPECT_TRUE(fun == nullptr); |
| EXPECT_TRUE(nullptr == fun); |
| |
| EXPECT_FALSE(fun != nullptr); |
| EXPECT_FALSE(nullptr != fun); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ComparisonWithNullptrNonempty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| |
| EXPECT_FALSE(fun == nullptr); |
| EXPECT_FALSE(nullptr == fun); |
| |
| EXPECT_TRUE(fun != nullptr); |
| EXPECT_TRUE(nullptr != fun); |
| } |
| |
| TYPED_TEST_P(AnyInvTestBasic, ResultType) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using ExpectedResultType = typename TypeParam::ResultType; |
| |
| EXPECT_TRUE((std::is_same<typename AnyInvType::result_type, |
| ExpectedResultType>::value)); |
| } |
| |
| template <class T> |
| class AnyInvTestCombinatoric : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestCombinatoric); |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignEmptyEmptyLhsRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType source_fun; |
| AnyInvType fun; |
| |
| fun = std::move(source_fun); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignEmptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType source_fun(absl::in_place_type<AddType>, 5); |
| AnyInvType fun; |
| |
| fun = std::move(source_fun); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignNonemptyEmptyLhsRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType source_fun; |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| |
| fun = std::move(source_fun); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignNonemptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType source_fun(absl::in_place_type<AddType>, 5); |
| AnyInvType fun(absl::in_place_type<AddType>, 20); |
| |
| fun = std::move(source_fun); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SelfMoveAssignEmpty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType source_fun; |
| source_fun = std::move(source_fun); |
| |
| // This space intentionally left blank. |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SelfMoveAssignNonempty) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType source_fun(absl::in_place_type<AddType>, 5); |
| source_fun = std::move(source_fun); |
| |
| // This space intentionally left blank. |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullptrEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun; |
| fun = nullptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullFunctionPtrEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using UnqualifiedFunType = typename TypeParam::UnqualifiedFunType; |
| |
| UnqualifiedFunType* const null_fun_ptr = nullptr; |
| AnyInvType fun; |
| fun = null_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberFunctionPtrEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using MemFunPtrType = typename TypeParam::MemFunPtrType; |
| |
| const MemFunPtrType null_mem_fun_ptr = nullptr; |
| AnyInvType fun; |
| fun = null_mem_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberObjectPtrEmptyLhs) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| using MemObjPtrType = typename TypeParam::MemObjPtrType; |
| |
| const MemObjPtrType null_mem_obj_ptr = nullptr; |
| UnaryAnyInvType fun; |
| fun = null_mem_obj_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberFunctionPtrEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun; |
| fun = &Int::MemberFunctionAdd; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberObjectPtrEmptyLhs) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| |
| UnaryAnyInvType fun; |
| fun = &Int::value; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(13, TypeParam::ToUnaryThisParam(fun)(13)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignFunctionReferenceDecayEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun; |
| fun = add_function; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, |
| AssignCompatibleAnyInvocableEmptyLhsEmptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other; |
| AnyInvType fun; |
| fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| EXPECT_EQ(other, nullptr); // NOLINT |
| EXPECT_EQ(nullptr, other); // NOLINT |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, |
| AssignCompatibleAnyInvocableEmptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other = &add_function; |
| AnyInvType fun; |
| fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullptrNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = &mult_function; |
| fun = nullptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullFunctionPtrNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using UnqualifiedFunType = typename TypeParam::UnqualifiedFunType; |
| |
| UnqualifiedFunType* const null_fun_ptr = nullptr; |
| AnyInvType fun = &mult_function; |
| fun = null_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberFunctionPtrNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using MemFunPtrType = typename TypeParam::MemFunPtrType; |
| |
| const MemFunPtrType null_mem_fun_ptr = nullptr; |
| AnyInvType fun = &mult_function; |
| fun = null_mem_fun_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberObjectPtrNonemptyLhs) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| using MemObjPtrType = typename TypeParam::MemObjPtrType; |
| |
| const MemObjPtrType null_mem_obj_ptr = nullptr; |
| UnaryAnyInvType fun = &square_function; |
| fun = null_mem_obj_ptr; |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberFunctionPtrNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = &mult_function; |
| fun = &Int::MemberFunctionAdd; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberObjectPtrNonemptyLhs) { |
| using UnaryAnyInvType = typename TypeParam::UnaryAnyInvType; |
| |
| UnaryAnyInvType fun = &square_function; |
| fun = &Int::value; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(13, TypeParam::ToUnaryThisParam(fun)(13)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, AssignFunctionReferenceDecayNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| AnyInvType fun = &mult_function; |
| fun = add_function; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, |
| AssignCompatibleAnyInvocableNonemptyLhsEmptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other; |
| AnyInvType fun = &mult_function; |
| fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| EXPECT_EQ(other, nullptr); // NOLINT |
| EXPECT_EQ(nullptr, other); // NOLINT |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, |
| AssignCompatibleAnyInvocableNonemptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using CompatibleAnyInvType = typename TypeParam::CompatibleAnyInvType; |
| |
| CompatibleAnyInvType other = &add_function; |
| AnyInvType fun = &mult_function; |
| fun = std::move(other); |
| |
| EXPECT_FALSE(static_cast<bool>(other)); // NOLINT |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(24, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SwapEmptyLhsEmptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| // Swap idiom |
| { |
| AnyInvType fun; |
| AnyInvType other; |
| |
| using std::swap; |
| swap(fun, other); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| EXPECT_FALSE(static_cast<bool>(other)); |
| |
| EXPECT_TRUE( |
| absl::type_traits_internal::IsNothrowSwappable<AnyInvType>::value); |
| } |
| |
| // Member swap |
| { |
| AnyInvType fun; |
| AnyInvType other; |
| |
| fun.swap(other); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| EXPECT_FALSE(static_cast<bool>(other)); |
| |
| EXPECT_TRUE(IsNothrowMemberSwappable<AnyInvType>::value); |
| } |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SwapEmptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| // Swap idiom |
| { |
| AnyInvType fun; |
| AnyInvType other(absl::in_place_type<AddType>, 5); |
| |
| using std::swap; |
| swap(fun, other); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_FALSE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE( |
| absl::type_traits_internal::IsNothrowSwappable<AnyInvType>::value); |
| } |
| |
| // Member swap |
| { |
| AnyInvType fun; |
| AnyInvType other(absl::in_place_type<AddType>, 5); |
| |
| fun.swap(other); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_FALSE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE(IsNothrowMemberSwappable<AnyInvType>::value); |
| } |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SwapNonemptyLhsEmptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| // Swap idiom |
| { |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| AnyInvType other; |
| |
| using std::swap; |
| swap(fun, other); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| EXPECT_TRUE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(29, TypeParam::ToThisParam(other)(7, 8, 9).value); |
| |
| EXPECT_TRUE( |
| absl::type_traits_internal::IsNothrowSwappable<AnyInvType>::value); |
| } |
| |
| // Member swap |
| { |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| AnyInvType other; |
| |
| fun.swap(other); |
| |
| EXPECT_FALSE(static_cast<bool>(fun)); |
| EXPECT_TRUE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(29, TypeParam::ToThisParam(other)(7, 8, 9).value); |
| |
| EXPECT_TRUE(IsNothrowMemberSwappable<AnyInvType>::value); |
| } |
| } |
| |
| TYPED_TEST_P(AnyInvTestCombinatoric, SwapNonemptyLhsNonemptyRhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| // Swap idiom |
| { |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| AnyInvType other(absl::in_place_type<AddType>, 6); |
| |
| using std::swap; |
| swap(fun, other); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_TRUE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(30, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| EXPECT_EQ(29, TypeParam::ToThisParam(other)(7, 8, 9).value); |
| |
| EXPECT_TRUE( |
| absl::type_traits_internal::IsNothrowSwappable<AnyInvType>::value); |
| } |
| |
| // Member swap |
| { |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| AnyInvType other(absl::in_place_type<AddType>, 6); |
| |
| fun.swap(other); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_TRUE(static_cast<bool>(other)); |
| |
| EXPECT_EQ(30, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| EXPECT_EQ(29, TypeParam::ToThisParam(other)(7, 8, 9).value); |
| |
| EXPECT_TRUE(IsNothrowMemberSwappable<AnyInvType>::value); |
| } |
| } |
| |
| template <class T> |
| class AnyInvTestMovable : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestMovable); |
| |
| TYPED_TEST_P(AnyInvTestMovable, ConversionConstructionUserDefinedType) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun(AddType(5)); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestMovable, ConversionConstructionVoidCovariance) { |
| using VoidAnyInvType = typename TypeParam::VoidAnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| VoidAnyInvType fun(AddType(5)); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestMovable, ConversionAssignUserDefinedTypeEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun; |
| fun = AddType(5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestMovable, ConversionAssignUserDefinedTypeNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun = &add_function; |
| fun = AddType(5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestMovable, ConversionAssignVoidCovariance) { |
| using VoidAnyInvType = typename TypeParam::VoidAnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| VoidAnyInvType fun; |
| fun = AddType(5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| } |
| |
| template <class T> |
| class AnyInvTestNoexceptFalse : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestNoexceptFalse); |
| |
| TYPED_TEST_P(AnyInvTestNoexceptFalse, ConversionConstructionConstraints) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| EXPECT_TRUE((std::is_constructible< |
| AnyInvType, |
| typename TypeParam::AnyInvocableFunTypeNotNoexcept*>::value)); |
| EXPECT_FALSE(( |
| std::is_constructible<AnyInvType, |
| typename TypeParam::IncompatibleInvocable>::value)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestNoexceptFalse, ConversionAssignConstraints) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| EXPECT_TRUE((std::is_assignable< |
| AnyInvType&, |
| typename TypeParam::AnyInvocableFunTypeNotNoexcept*>::value)); |
| EXPECT_FALSE( |
| (std::is_assignable<AnyInvType&, |
| typename TypeParam::IncompatibleInvocable>::value)); |
| } |
| |
| template <class T> |
| class AnyInvTestNoexceptTrue : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestNoexceptTrue); |
| |
| TYPED_TEST_P(AnyInvTestNoexceptTrue, ConversionConstructionConstraints) { |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L |
| GTEST_SKIP() << "Noexcept was not part of the type system before C++17."; |
| #else |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| EXPECT_FALSE((std::is_constructible< |
| AnyInvType, |
| typename TypeParam::AnyInvocableFunTypeNotNoexcept*>::value)); |
| EXPECT_FALSE(( |
| std::is_constructible<AnyInvType, |
| typename TypeParam::IncompatibleInvocable>::value)); |
| #endif |
| } |
| |
| TYPED_TEST_P(AnyInvTestNoexceptTrue, ConversionAssignConstraints) { |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L |
| GTEST_SKIP() << "Noexcept was not part of the type system before C++17."; |
| #else |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| EXPECT_FALSE((std::is_assignable< |
| AnyInvType&, |
| typename TypeParam::AnyInvocableFunTypeNotNoexcept*>::value)); |
| EXPECT_FALSE( |
| (std::is_assignable<AnyInvType&, |
| typename TypeParam::IncompatibleInvocable>::value)); |
| #endif |
| } |
| |
| template <class T> |
| class AnyInvTestNonRvalue : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestNonRvalue); |
| |
| TYPED_TEST_P(AnyInvTestNonRvalue, ConversionConstructionReferenceWrapper) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AddType add(4); |
| AnyInvType fun = std::ref(add); |
| add.state = 5; |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(38, TypeParam::ToThisParam(fun)(10, 11, 12).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestNonRvalue, NonMoveableResultType) { |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L |
| GTEST_SKIP() << "Copy/move elision was not standard before C++17"; |
| #else |
| // Define a result type that cannot be copy- or move-constructed. |
| struct Result { |
| int x; |
| |
| explicit Result(const int x_in) : x(x_in) {} |
| Result(Result&&) = delete; |
| }; |
| |
| static_assert(!std::is_move_constructible<Result>::value, ""); |
| static_assert(!std::is_copy_constructible<Result>::value, ""); |
| |
| // Assumption check: it should nevertheless be possible to use functors that |
| // return a Result struct according to the language rules. |
| const auto return_17 = []() noexcept { return Result(17); }; |
| EXPECT_EQ(17, return_17().x); |
| |
| // Just like plain functors, it should work fine to use an AnyInvocable that |
| // returns the non-moveable type. |
| using UnqualifiedFun = |
| absl::conditional_t<TypeParam::kIsNoexcept, Result() noexcept, Result()>; |
| |
| using Fun = |
| GiveQualifiersToFun<typename TypeParam::Qualifiers, UnqualifiedFun>; |
| |
| AnyInvocable<Fun> any_inv(return_17); |
| EXPECT_EQ(17, any_inv().x); |
| #endif |
| } |
| |
| TYPED_TEST_P(AnyInvTestNonRvalue, ConversionAssignReferenceWrapperEmptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AddType add(4); |
| AnyInvType fun; |
| fun = std::ref(add); |
| add.state = 5; |
| EXPECT_TRUE( |
| (std::is_nothrow_assignable<AnyInvType&, |
| std::reference_wrapper<AddType>>::value)); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(38, TypeParam::ToThisParam(fun)(10, 11, 12).value); |
| } |
| |
| TYPED_TEST_P(AnyInvTestNonRvalue, ConversionAssignReferenceWrapperNonemptyLhs) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AddType add(4); |
| AnyInvType fun = &mult_function; |
| fun = std::ref(add); |
| add.state = 5; |
| EXPECT_TRUE( |
| (std::is_nothrow_assignable<AnyInvType&, |
| std::reference_wrapper<AddType>>::value)); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(29, TypeParam::ToThisParam(fun)(7, 8, 9).value); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| EXPECT_EQ(38, TypeParam::ToThisParam(fun)(10, 11, 12).value); |
| } |
| |
| template <class T> |
| class AnyInvTestRvalue : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(AnyInvTestRvalue); |
| |
| TYPED_TEST_P(AnyInvTestRvalue, ConversionConstructionReferenceWrapper) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| EXPECT_FALSE(( |
| std::is_convertible<std::reference_wrapper<AddType>, AnyInvType>::value)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestRvalue, NonMoveableResultType) { |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L |
| GTEST_SKIP() << "Copy/move elision was not standard before C++17"; |
| #else |
| // Define a result type that cannot be copy- or move-constructed. |
| struct Result { |
| int x; |
| |
| explicit Result(const int x_in) : x(x_in) {} |
| Result(Result&&) = delete; |
| }; |
| |
| static_assert(!std::is_move_constructible<Result>::value, ""); |
| static_assert(!std::is_copy_constructible<Result>::value, ""); |
| |
| // Assumption check: it should nevertheless be possible to use functors that |
| // return a Result struct according to the language rules. |
| const auto return_17 = []() noexcept { return Result(17); }; |
| EXPECT_EQ(17, return_17().x); |
| |
| // Just like plain functors, it should work fine to use an AnyInvocable that |
| // returns the non-moveable type. |
| using UnqualifiedFun = |
| absl::conditional_t<TypeParam::kIsNoexcept, Result() noexcept, Result()>; |
| |
| using Fun = |
| GiveQualifiersToFun<typename TypeParam::Qualifiers, UnqualifiedFun>; |
| |
| EXPECT_EQ(17, AnyInvocable<Fun>(return_17)().x); |
| #endif |
| } |
| |
| TYPED_TEST_P(AnyInvTestRvalue, ConversionAssignReferenceWrapper) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| EXPECT_FALSE(( |
| std::is_assignable<AnyInvType&, std::reference_wrapper<AddType>>::value)); |
| } |
| |
| TYPED_TEST_P(AnyInvTestRvalue, NonConstCrashesOnSecondCall) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| using AddType = typename TypeParam::AddType; |
| |
| AnyInvType fun(absl::in_place_type<AddType>, 5); |
| |
| EXPECT_TRUE(static_cast<bool>(fun)); |
| std::move(fun)(7, 8, 9); |
| |
| // Ensure we're still valid |
| EXPECT_TRUE(static_cast<bool>(fun)); // NOLINT(bugprone-use-after-move) |
| |
| #if !defined(NDEBUG) |
| EXPECT_DEATH_IF_SUPPORTED(std::move(fun)(7, 8, 9), ""); |
| #endif |
| } |
| |
| // Ensure that any qualifiers (in particular &&-qualifiers) do not affect |
| // when the destructor is actually run. |
| TYPED_TEST_P(AnyInvTestRvalue, QualifierIndependentObjectLifetime) { |
| using AnyInvType = typename TypeParam::AnyInvType; |
| |
| auto refs = std::make_shared<std::nullptr_t>(); |
| { |
| AnyInvType fun([refs](auto&&...) noexcept { return 0; }); |
| EXPECT_GT(refs.use_count(), 1); |
| |
| std::move(fun)(7, 8, 9); |
| |
| // Ensure destructor hasn't run even if rref-qualified |
| EXPECT_GT(refs.use_count(), 1); |
| } |
| EXPECT_EQ(refs.use_count(), 1); |
| } |
| |
| // NOTE: This test suite originally attempted to enumerate all possible |
| // combinations of type properties but the build-time started getting too large. |
| // Instead, it is now assumed that certain parameters are orthogonal and so |
| // some combinations are elided. |
| |
| // A metafunction to form a TypeList of all cv and non-rvalue ref combinations, |
| // coupled with all of the other explicitly specified parameters. |
| template <Movable Mov, Destructible Dest, NothrowCall CallExceptionSpec, |
| ObjSize Size, ObjAlign Align> |
| using NonRvalueQualifiedTestParams = ::testing::Types< // |
| TestParams<Mov, Dest, _, CallExceptionSpec, Size, Align>, // |
| TestParams<Mov, Dest, const _, CallExceptionSpec, Size, Align>, // |
| TestParams<Mov, Dest, _&, CallExceptionSpec, Size, Align>, // |
| TestParams<Mov, Dest, const _&, CallExceptionSpec, Size, Align>>; |
| |
| // A metafunction to form a TypeList of const and non-const rvalue ref |
| // qualifiers, coupled with all of the other explicitly specified parameters. |
| template <Movable Mov, Destructible Dest, NothrowCall CallExceptionSpec, |
| ObjSize Size, ObjAlign Align> |
| using RvalueQualifiedTestParams = ::testing::Types< |
| TestParams<Mov, Dest, _&&, CallExceptionSpec, Size, Align>, // |
| TestParams<Mov, Dest, const _&&, CallExceptionSpec, Size, Align> // |
| >; |
| |
| // All qualifier combinations and a noexcept function type |
| using TestParameterListNonRvalueQualifiersNothrowCall = |
| NonRvalueQualifiedTestParams<Movable::trivial, Destructible::trivial, |
| NothrowCall::yes, ObjSize::small, |
| ObjAlign::normal>; |
| using TestParameterListRvalueQualifiersNothrowCall = |
| RvalueQualifiedTestParams<Movable::trivial, Destructible::trivial, |
| NothrowCall::yes, ObjSize::small, |
| ObjAlign::normal>; |
| |
| // All qualifier combinations and a non-noexcept function type |
| using TestParameterListNonRvalueQualifiersCallMayThrow = |
| NonRvalueQualifiedTestParams<Movable::trivial, Destructible::trivial, |
| NothrowCall::no, ObjSize::small, |
| ObjAlign::normal>; |
| using TestParameterListRvalueQualifiersCallMayThrow = |
| RvalueQualifiedTestParams<Movable::trivial, Destructible::trivial, |
| NothrowCall::no, ObjSize::small, |
| ObjAlign::normal>; |
| |
| // Lists of various cases that should lead to remote storage |
| using TestParameterListRemoteMovable = ::testing::Types< |
| // "Normal" aligned types that are large and have trivial destructors |
| TestParams<Movable::trivial, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| TestParams<Movable::nothrow, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| TestParams<Movable::yes, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::yes, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| |
| // Same as above but with non-trivial destructors |
| TestParams<Movable::trivial, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| TestParams<Movable::nothrow, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| TestParams<Movable::yes, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::yes, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal> // |
| |
| // Dynamic memory allocation for over-aligned data was introduced in C++17. |
| // See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0035r4.html |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L |
| // Types that must use remote storage because of a large alignment. |
| , |
| TestParams<Movable::trivial, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::large>, // |
| TestParams<Movable::nothrow, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::large>, // |
| TestParams<Movable::trivial, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::large>, // |
| TestParams<Movable::nothrow, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::large> // |
| #endif |
| >; |
| using TestParameterListRemoteNonMovable = ::testing::Types< |
| // "Normal" aligned types that are large and have trivial destructors |
| TestParams<Movable::no, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::no, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal>, // |
| // Same as above but with non-trivial destructors |
| TestParams<Movable::no, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::no, Destructible::nothrow, _, NothrowCall::no, |
| ObjSize::large, ObjAlign::normal> // |
| >; |
| |
| // Parameters that lead to local storage |
| using TestParameterListLocal = ::testing::Types< |
| // Types that meet the requirements and have trivial destructors |
| TestParams<Movable::trivial, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::nothrow, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| |
| // Same as above but with non-trivial destructors |
| TestParams<Movable::trivial, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal>, // |
| TestParams<Movable::nothrow, Destructible::trivial, _, NothrowCall::no, |
| ObjSize::small, ObjAlign::normal> // |
| >; |
| |
| // All of the tests that are run for every possible combination of types. |
| REGISTER_TYPED_TEST_SUITE_P( |
| AnyInvTestBasic, DefaultConstruction, ConstructionNullptr, |
| ConstructionNullFunctionPtr, ConstructionNullMemberFunctionPtr, |
| ConstructionNullMemberObjectPtr, ConstructionMemberFunctionPtr, |
| ConstructionMemberObjectPtr, ConstructionFunctionReferenceDecay, |
| ConstructionCompatibleAnyInvocableEmpty, |
| ConstructionCompatibleAnyInvocableNonempty, InPlaceConstruction, |
| ConversionToBool, Invocation, InPlaceConstructionInitializerList, |
| InPlaceNullFunPtrConstruction, InPlaceNullFunPtrConstructionValueInit, |
| InPlaceNullMemFunPtrConstruction, InPlaceNullMemFunPtrConstructionValueInit, |
| InPlaceNullMemObjPtrConstruction, InPlaceNullMemObjPtrConstructionValueInit, |
| InPlaceVoidCovarianceConstruction, MoveConstructionFromEmpty, |
| MoveConstructionFromNonEmpty, ComparisonWithNullptrEmpty, |
| ComparisonWithNullptrNonempty, ResultType); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P( |
| NonRvalueCallMayThrow, AnyInvTestBasic, |
| TestParameterListNonRvalueQualifiersCallMayThrow); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallMayThrow, AnyInvTestBasic, |
| TestParameterListRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteMovable, AnyInvTestBasic, |
| TestParameterListRemoteMovable); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteNonMovable, AnyInvTestBasic, |
| TestParameterListRemoteNonMovable); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Local, AnyInvTestBasic, TestParameterListLocal); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(NonRvalueCallNothrow, AnyInvTestBasic, |
| TestParameterListNonRvalueQualifiersNothrowCall); |
| INSTANTIATE_TYPED_TEST_SUITE_P(CallNothrowRvalue, AnyInvTestBasic, |
| TestParameterListRvalueQualifiersNothrowCall); |
| |
| // Tests for functions that take two operands. |
| REGISTER_TYPED_TEST_SUITE_P( |
| AnyInvTestCombinatoric, MoveAssignEmptyEmptyLhsRhs, |
| MoveAssignEmptyLhsNonemptyRhs, MoveAssignNonemptyEmptyLhsRhs, |
| MoveAssignNonemptyLhsNonemptyRhs, SelfMoveAssignEmpty, |
| SelfMoveAssignNonempty, AssignNullptrEmptyLhs, |
| AssignNullFunctionPtrEmptyLhs, AssignNullMemberFunctionPtrEmptyLhs, |
| AssignNullMemberObjectPtrEmptyLhs, AssignMemberFunctionPtrEmptyLhs, |
| AssignMemberObjectPtrEmptyLhs, AssignFunctionReferenceDecayEmptyLhs, |
| AssignCompatibleAnyInvocableEmptyLhsEmptyRhs, |
| AssignCompatibleAnyInvocableEmptyLhsNonemptyRhs, AssignNullptrNonemptyLhs, |
| AssignNullFunctionPtrNonemptyLhs, AssignNullMemberFunctionPtrNonemptyLhs, |
| AssignNullMemberObjectPtrNonemptyLhs, AssignMemberFunctionPtrNonemptyLhs, |
| AssignMemberObjectPtrNonemptyLhs, AssignFunctionReferenceDecayNonemptyLhs, |
| AssignCompatibleAnyInvocableNonemptyLhsEmptyRhs, |
| AssignCompatibleAnyInvocableNonemptyLhsNonemptyRhs, SwapEmptyLhsEmptyRhs, |
| SwapEmptyLhsNonemptyRhs, SwapNonemptyLhsEmptyRhs, |
| SwapNonemptyLhsNonemptyRhs); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P( |
| NonRvalueCallMayThrow, AnyInvTestCombinatoric, |
| TestParameterListNonRvalueQualifiersCallMayThrow); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallMayThrow, AnyInvTestCombinatoric, |
| TestParameterListRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteMovable, AnyInvTestCombinatoric, |
| TestParameterListRemoteMovable); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteNonMovable, AnyInvTestCombinatoric, |
| TestParameterListRemoteNonMovable); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Local, AnyInvTestCombinatoric, |
| TestParameterListLocal); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(NonRvalueCallNothrow, AnyInvTestCombinatoric, |
| TestParameterListNonRvalueQualifiersNothrowCall); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallNothrow, AnyInvTestCombinatoric, |
| TestParameterListRvalueQualifiersNothrowCall); |
| |
| REGISTER_TYPED_TEST_SUITE_P(AnyInvTestMovable, |
| ConversionConstructionUserDefinedType, |
| ConversionConstructionVoidCovariance, |
| ConversionAssignUserDefinedTypeEmptyLhs, |
| ConversionAssignUserDefinedTypeNonemptyLhs, |
| ConversionAssignVoidCovariance); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P( |
| NonRvalueCallMayThrow, AnyInvTestMovable, |
| TestParameterListNonRvalueQualifiersCallMayThrow); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallMayThrow, AnyInvTestMovable, |
| TestParameterListRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteMovable, AnyInvTestMovable, |
| TestParameterListRemoteMovable); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Local, AnyInvTestMovable, |
| TestParameterListLocal); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(NonRvalueCallNothrow, AnyInvTestMovable, |
| TestParameterListNonRvalueQualifiersNothrowCall); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallNothrow, AnyInvTestMovable, |
| TestParameterListRvalueQualifiersNothrowCall); |
| |
| REGISTER_TYPED_TEST_SUITE_P(AnyInvTestNoexceptFalse, |
| ConversionConstructionConstraints, |
| ConversionAssignConstraints); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P( |
| NonRvalueCallMayThrow, AnyInvTestNoexceptFalse, |
| TestParameterListNonRvalueQualifiersCallMayThrow); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallMayThrow, AnyInvTestNoexceptFalse, |
| TestParameterListRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteMovable, AnyInvTestNoexceptFalse, |
| TestParameterListRemoteMovable); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteNonMovable, AnyInvTestNoexceptFalse, |
| TestParameterListRemoteNonMovable); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Local, AnyInvTestNoexceptFalse, |
| TestParameterListLocal); |
| |
| REGISTER_TYPED_TEST_SUITE_P(AnyInvTestNoexceptTrue, |
| ConversionConstructionConstraints, |
| ConversionAssignConstraints); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(NonRvalueCallNothrow, AnyInvTestNoexceptTrue, |
| TestParameterListNonRvalueQualifiersNothrowCall); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallNothrow, AnyInvTestNoexceptTrue, |
| TestParameterListRvalueQualifiersNothrowCall); |
| |
| REGISTER_TYPED_TEST_SUITE_P(AnyInvTestNonRvalue, |
| ConversionConstructionReferenceWrapper, |
| NonMoveableResultType, |
| ConversionAssignReferenceWrapperEmptyLhs, |
| ConversionAssignReferenceWrapperNonemptyLhs); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P( |
| NonRvalueCallMayThrow, AnyInvTestNonRvalue, |
| TestParameterListNonRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteMovable, AnyInvTestNonRvalue, |
| TestParameterListRemoteMovable); |
| INSTANTIATE_TYPED_TEST_SUITE_P(RemoteNonMovable, AnyInvTestNonRvalue, |
| TestParameterListRemoteNonMovable); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Local, AnyInvTestNonRvalue, |
| TestParameterListLocal); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(NonRvalueCallNothrow, AnyInvTestNonRvalue, |
| TestParameterListNonRvalueQualifiersNothrowCall); |
| |
| REGISTER_TYPED_TEST_SUITE_P(AnyInvTestRvalue, |
| ConversionConstructionReferenceWrapper, |
| NonMoveableResultType, |
| ConversionAssignReferenceWrapper, |
| NonConstCrashesOnSecondCall, |
| QualifierIndependentObjectLifetime); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(RvalueCallMayThrow, AnyInvTestRvalue, |
| TestParameterListRvalueQualifiersCallMayThrow); |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(CallNothrowRvalue, AnyInvTestRvalue, |
| TestParameterListRvalueQualifiersNothrowCall); |
| |
| // Minimal SFINAE testing for platforms where we can't run the tests, but we can |
| // build binaries for. |
| static_assert( |
| std::is_convertible<void (*)(), absl::AnyInvocable<void() &&>>::value, ""); |
| static_assert(!std::is_convertible<void*, absl::AnyInvocable<void() &&>>::value, |
| ""); |
| |
| #undef ABSL_INTERNAL_NOEXCEPT_SPEC |
| |
| } // namespace |
