| // Copyright 2019 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/internal/conformance_testing.h" |
| |
| #include <new> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "gtest/gtest.h" |
| #include "absl/meta/type_traits.h" |
| #include "absl/types/internal/conformance_aliases.h" |
| #include "absl/types/internal/conformance_profile.h" |
| |
| namespace { |
| |
| namespace ti = absl::types_internal; |
| |
| template <class T> |
| using DefaultConstructibleWithNewImpl = decltype(::new (std::nothrow) T); |
| |
| template <class T> |
| using DefaultConstructibleWithNew = |
| absl::type_traits_internal::is_detected<DefaultConstructibleWithNewImpl, T>; |
| |
| template <class T> |
| using MoveConstructibleWithNewImpl = |
| decltype(::new (std::nothrow) T(std::declval<T>())); |
| |
| template <class T> |
| using MoveConstructibleWithNew = |
| absl::type_traits_internal::is_detected<MoveConstructibleWithNewImpl, T>; |
| |
| template <class T> |
| using CopyConstructibleWithNewImpl = |
| decltype(::new (std::nothrow) T(std::declval<const T&>())); |
| |
| template <class T> |
| using CopyConstructibleWithNew = |
| absl::type_traits_internal::is_detected<CopyConstructibleWithNewImpl, T>; |
| |
| template <class T, |
| class Result = |
| std::integral_constant<bool, noexcept(::new (std::nothrow) T)>> |
| using NothrowDefaultConstructibleWithNewImpl = |
| typename std::enable_if<Result::value>::type; |
| |
| template <class T> |
| using NothrowDefaultConstructibleWithNew = |
| absl::type_traits_internal::is_detected< |
| NothrowDefaultConstructibleWithNewImpl, T>; |
| |
| template <class T, |
| class Result = std::integral_constant< |
| bool, noexcept(::new (std::nothrow) T(std::declval<T>()))>> |
| using NothrowMoveConstructibleWithNewImpl = |
| typename std::enable_if<Result::value>::type; |
| |
| template <class T> |
| using NothrowMoveConstructibleWithNew = |
| absl::type_traits_internal::is_detected<NothrowMoveConstructibleWithNewImpl, |
| T>; |
| |
| template <class T, |
| class Result = std::integral_constant< |
| bool, noexcept(::new (std::nothrow) T(std::declval<const T&>()))>> |
| using NothrowCopyConstructibleWithNewImpl = |
| typename std::enable_if<Result::value>::type; |
| |
| template <class T> |
| using NothrowCopyConstructibleWithNew = |
| absl::type_traits_internal::is_detected<NothrowCopyConstructibleWithNewImpl, |
| T>; |
| |
| // NOTE: ?: is used to verify contextually-convertible to bool and not simply |
| // implicit or explicit convertibility. |
| #define ABSL_INTERNAL_COMPARISON_OP_EXPR(op) \ |
| ((std::declval<const T&>() op std::declval<const T&>()) ? true : true) |
| |
| #define ABSL_INTERNAL_COMPARISON_OP_TRAIT(name, op) \ |
| template <class T> \ |
| using name##Impl = decltype(ABSL_INTERNAL_COMPARISON_OP_EXPR(op)); \ |
| \ |
| template <class T> \ |
| using name = absl::type_traits_internal::is_detected<name##Impl, T>; \ |
| \ |
| template <class T, \ |
| class Result = std::integral_constant< \ |
| bool, noexcept(ABSL_INTERNAL_COMPARISON_OP_EXPR(op))>> \ |
| using Nothrow##name##Impl = typename std::enable_if<Result::value>::type; \ |
| \ |
| template <class T> \ |
| using Nothrow##name = \ |
| absl::type_traits_internal::is_detected<Nothrow##name##Impl, T> |
| |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(EqualityComparable, ==); |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(InequalityComparable, !=); |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(LessThanComparable, <); |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(LessEqualComparable, <=); |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(GreaterEqualComparable, >=); |
| ABSL_INTERNAL_COMPARISON_OP_TRAIT(GreaterThanComparable, >); |
| |
| #undef ABSL_INTERNAL_COMPARISON_OP_TRAIT |
| |
| template <class T> |
| class ProfileTest : public ::testing::Test {}; |
| |
| TYPED_TEST_SUITE_P(ProfileTest); |
| |
| TYPED_TEST_P(ProfileTest, HasAppropriateConstructionProperties) { |
| using profile = typename TypeParam::profile; |
| using arch = typename TypeParam::arch; |
| using expected_profile = typename TypeParam::expected_profile; |
| |
| using props = ti::PropertiesOfT<profile>; |
| using arch_props = ti::PropertiesOfArchetypeT<arch>; |
| using expected_props = ti::PropertiesOfT<expected_profile>; |
| |
| // Make sure all of the properties are as expected. |
| // There are seemingly redundant tests here to make it easier to diagnose |
| // the specifics of the failure if something were to go wrong. |
| EXPECT_TRUE((std::is_same<props, arch_props>::value)); |
| EXPECT_TRUE((std::is_same<props, expected_props>::value)); |
| EXPECT_TRUE((std::is_same<arch_props, expected_props>::value)); |
| |
| EXPECT_EQ(props::default_constructible_support, |
| expected_props::default_constructible_support); |
| |
| EXPECT_EQ(props::move_constructible_support, |
| expected_props::move_constructible_support); |
| |
| EXPECT_EQ(props::copy_constructible_support, |
| expected_props::copy_constructible_support); |
| |
| EXPECT_EQ(props::destructible_support, expected_props::destructible_support); |
| |
| // Avoid additional error message noise when profile and archetype match with |
| // each other but were not what was expected. |
| if (!std::is_same<props, arch_props>::value) { |
| EXPECT_EQ(arch_props::default_constructible_support, |
| expected_props::default_constructible_support); |
| |
| EXPECT_EQ(arch_props::move_constructible_support, |
| expected_props::move_constructible_support); |
| |
| EXPECT_EQ(arch_props::copy_constructible_support, |
| expected_props::copy_constructible_support); |
| |
| EXPECT_EQ(arch_props::destructible_support, |
| expected_props::destructible_support); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Default constructor checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::default_constructible_support, |
| expected_props::default_constructible_support); |
| |
| switch (expected_props::default_constructible_support) { |
| case ti::default_constructible::maybe: |
| EXPECT_FALSE(DefaultConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowDefaultConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_FALSE(std::is_default_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_default_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value); |
| } |
| break; |
| case ti::default_constructible::yes: |
| EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowDefaultConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_default_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_default_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value); |
| } |
| break; |
| case ti::default_constructible::nothrow: |
| EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowDefaultConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_default_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value); |
| |
| // Constructor traits also check the destructor. |
| if (std::is_nothrow_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value); |
| } |
| } |
| break; |
| case ti::default_constructible::trivial: |
| EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowDefaultConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_default_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value); |
| |
| // Constructor triviality traits require trivially destructible types. |
| if (absl::is_trivially_destructible<arch>::value) { |
| EXPECT_TRUE(absl::is_trivially_default_constructible<arch>::value); |
| } |
| } |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Move constructor checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::move_constructible_support, |
| expected_props::move_constructible_support); |
| |
| switch (expected_props::move_constructible_support) { |
| case ti::move_constructible::maybe: |
| EXPECT_FALSE(MoveConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowMoveConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_FALSE(std::is_move_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_move_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value); |
| } |
| break; |
| case ti::move_constructible::yes: |
| EXPECT_TRUE(MoveConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowMoveConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_move_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_move_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value); |
| } |
| break; |
| case ti::move_constructible::nothrow: |
| EXPECT_TRUE(MoveConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowMoveConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_move_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value); |
| |
| // Constructor traits also check the destructor. |
| if (std::is_nothrow_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value); |
| } |
| } |
| break; |
| case ti::move_constructible::trivial: |
| EXPECT_TRUE(MoveConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowMoveConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_move_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value); |
| |
| // Constructor triviality traits require trivially destructible types. |
| if (absl::is_trivially_destructible<arch>::value) { |
| EXPECT_TRUE(absl::is_trivially_move_constructible<arch>::value); |
| } |
| } |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Copy constructor checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::copy_constructible_support, |
| expected_props::copy_constructible_support); |
| |
| switch (expected_props::copy_constructible_support) { |
| case ti::copy_constructible::maybe: |
| EXPECT_FALSE(CopyConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowCopyConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_FALSE(std::is_copy_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_copy_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value); |
| } |
| break; |
| case ti::copy_constructible::yes: |
| EXPECT_TRUE(CopyConstructibleWithNew<arch>::value); |
| EXPECT_FALSE(NothrowCopyConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_copy_constructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_copy_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value); |
| } |
| break; |
| case ti::copy_constructible::nothrow: |
| EXPECT_TRUE(CopyConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowCopyConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_copy_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value); |
| |
| // Constructor traits also check the destructor. |
| if (std::is_nothrow_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value); |
| } |
| } |
| break; |
| case ti::copy_constructible::trivial: |
| EXPECT_TRUE(CopyConstructibleWithNew<arch>::value); |
| EXPECT_TRUE(NothrowCopyConstructibleWithNew<arch>::value); |
| |
| // Standard constructible traits depend on the destructor. |
| if (std::is_destructible<arch>::value) { |
| EXPECT_TRUE(std::is_copy_constructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value); |
| |
| // Constructor triviality traits require trivially destructible types. |
| if (absl::is_trivially_destructible<arch>::value) { |
| EXPECT_TRUE(absl::is_trivially_copy_constructible<arch>::value); |
| } |
| } |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Destructible checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::destructible_support, expected_props::destructible_support); |
| |
| switch (expected_props::destructible_support) { |
| case ti::destructible::maybe: |
| EXPECT_FALSE(std::is_destructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_destructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_destructible<arch>::value); |
| break; |
| case ti::destructible::yes: |
| EXPECT_TRUE(std::is_destructible<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_destructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_destructible<arch>::value); |
| break; |
| case ti::destructible::nothrow: |
| EXPECT_TRUE(std::is_destructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_destructible<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_destructible<arch>::value); |
| break; |
| case ti::destructible::trivial: |
| EXPECT_TRUE(std::is_destructible<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_destructible<arch>::value); |
| EXPECT_TRUE(absl::is_trivially_destructible<arch>::value); |
| break; |
| } |
| } |
| |
| TYPED_TEST_P(ProfileTest, HasAppropriateAssignmentProperties) { |
| using profile = typename TypeParam::profile; |
| using arch = typename TypeParam::arch; |
| using expected_profile = typename TypeParam::expected_profile; |
| |
| using props = ti::PropertiesOfT<profile>; |
| using arch_props = ti::PropertiesOfArchetypeT<arch>; |
| using expected_props = ti::PropertiesOfT<expected_profile>; |
| |
| // Make sure all of the properties are as expected. |
| // There are seemingly redundant tests here to make it easier to diagnose |
| // the specifics of the failure if something were to go wrong. |
| EXPECT_TRUE((std::is_same<props, arch_props>::value)); |
| EXPECT_TRUE((std::is_same<props, expected_props>::value)); |
| EXPECT_TRUE((std::is_same<arch_props, expected_props>::value)); |
| |
| EXPECT_EQ(props::move_assignable_support, |
| expected_props::move_assignable_support); |
| |
| EXPECT_EQ(props::copy_assignable_support, |
| expected_props::copy_assignable_support); |
| |
| // Avoid additional error message noise when profile and archetype match with |
| // each other but were not what was expected. |
| if (!std::is_same<props, arch_props>::value) { |
| EXPECT_EQ(arch_props::move_assignable_support, |
| expected_props::move_assignable_support); |
| |
| EXPECT_EQ(arch_props::copy_assignable_support, |
| expected_props::copy_assignable_support); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Move assignment checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::move_assignable_support, |
| expected_props::move_assignable_support); |
| |
| switch (expected_props::move_assignable_support) { |
| case ti::move_assignable::maybe: |
| EXPECT_FALSE(std::is_move_assignable<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_move_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value); |
| break; |
| case ti::move_assignable::yes: |
| EXPECT_TRUE(std::is_move_assignable<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_move_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value); |
| break; |
| case ti::move_assignable::nothrow: |
| EXPECT_TRUE(std::is_move_assignable<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_move_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value); |
| break; |
| case ti::move_assignable::trivial: |
| EXPECT_TRUE(std::is_move_assignable<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_move_assignable<arch>::value); |
| EXPECT_TRUE(absl::is_trivially_move_assignable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Copy assignment checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| EXPECT_EQ(props::copy_assignable_support, |
| expected_props::copy_assignable_support); |
| |
| switch (expected_props::copy_assignable_support) { |
| case ti::copy_assignable::maybe: |
| EXPECT_FALSE(std::is_copy_assignable<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_copy_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value); |
| break; |
| case ti::copy_assignable::yes: |
| EXPECT_TRUE(std::is_copy_assignable<arch>::value); |
| EXPECT_FALSE(std::is_nothrow_copy_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value); |
| break; |
| case ti::copy_assignable::nothrow: |
| EXPECT_TRUE(std::is_copy_assignable<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_copy_assignable<arch>::value); |
| EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value); |
| break; |
| case ti::copy_assignable::trivial: |
| EXPECT_TRUE(std::is_copy_assignable<arch>::value); |
| EXPECT_TRUE(std::is_nothrow_copy_assignable<arch>::value); |
| EXPECT_TRUE(absl::is_trivially_copy_assignable<arch>::value); |
| break; |
| } |
| } |
| |
| TYPED_TEST_P(ProfileTest, HasAppropriateComparisonProperties) { |
| using profile = typename TypeParam::profile; |
| using arch = typename TypeParam::arch; |
| using expected_profile = typename TypeParam::expected_profile; |
| |
| using props = ti::PropertiesOfT<profile>; |
| using arch_props = ti::PropertiesOfArchetypeT<arch>; |
| using expected_props = ti::PropertiesOfT<expected_profile>; |
| |
| // Make sure all of the properties are as expected. |
| // There are seemingly redundant tests here to make it easier to diagnose |
| // the specifics of the failure if something were to go wrong. |
| EXPECT_TRUE((std::is_same<props, arch_props>::value)); |
| EXPECT_TRUE((std::is_same<props, expected_props>::value)); |
| EXPECT_TRUE((std::is_same<arch_props, expected_props>::value)); |
| |
| EXPECT_EQ(props::equality_comparable_support, |
| expected_props::equality_comparable_support); |
| |
| EXPECT_EQ(props::inequality_comparable_support, |
| expected_props::inequality_comparable_support); |
| |
| EXPECT_EQ(props::less_than_comparable_support, |
| expected_props::less_than_comparable_support); |
| |
| EXPECT_EQ(props::less_equal_comparable_support, |
| expected_props::less_equal_comparable_support); |
| |
| EXPECT_EQ(props::greater_equal_comparable_support, |
| expected_props::greater_equal_comparable_support); |
| |
| EXPECT_EQ(props::greater_than_comparable_support, |
| expected_props::greater_than_comparable_support); |
| |
| // Avoid additional error message noise when profile and archetype match with |
| // each other but were not what was expected. |
| if (!std::is_same<props, arch_props>::value) { |
| EXPECT_EQ(arch_props::equality_comparable_support, |
| expected_props::equality_comparable_support); |
| |
| EXPECT_EQ(arch_props::inequality_comparable_support, |
| expected_props::inequality_comparable_support); |
| |
| EXPECT_EQ(arch_props::less_than_comparable_support, |
| expected_props::less_than_comparable_support); |
| |
| EXPECT_EQ(arch_props::less_equal_comparable_support, |
| expected_props::less_equal_comparable_support); |
| |
| EXPECT_EQ(arch_props::greater_equal_comparable_support, |
| expected_props::greater_equal_comparable_support); |
| |
| EXPECT_EQ(arch_props::greater_than_comparable_support, |
| expected_props::greater_than_comparable_support); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Equality comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::equality_comparable_support) { |
| case ti::equality_comparable::maybe: |
| EXPECT_FALSE(EqualityComparable<arch>::value); |
| EXPECT_FALSE(NothrowEqualityComparable<arch>::value); |
| break; |
| case ti::equality_comparable::yes: |
| EXPECT_TRUE(EqualityComparable<arch>::value); |
| EXPECT_FALSE(NothrowEqualityComparable<arch>::value); |
| break; |
| case ti::equality_comparable::nothrow: |
| EXPECT_TRUE(EqualityComparable<arch>::value); |
| EXPECT_TRUE(NothrowEqualityComparable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Inequality comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::inequality_comparable_support) { |
| case ti::inequality_comparable::maybe: |
| EXPECT_FALSE(InequalityComparable<arch>::value); |
| EXPECT_FALSE(NothrowInequalityComparable<arch>::value); |
| break; |
| case ti::inequality_comparable::yes: |
| EXPECT_TRUE(InequalityComparable<arch>::value); |
| EXPECT_FALSE(NothrowInequalityComparable<arch>::value); |
| break; |
| case ti::inequality_comparable::nothrow: |
| EXPECT_TRUE(InequalityComparable<arch>::value); |
| EXPECT_TRUE(NothrowInequalityComparable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Less than comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::less_than_comparable_support) { |
| case ti::less_than_comparable::maybe: |
| EXPECT_FALSE(LessThanComparable<arch>::value); |
| EXPECT_FALSE(NothrowLessThanComparable<arch>::value); |
| break; |
| case ti::less_than_comparable::yes: |
| EXPECT_TRUE(LessThanComparable<arch>::value); |
| EXPECT_FALSE(NothrowLessThanComparable<arch>::value); |
| break; |
| case ti::less_than_comparable::nothrow: |
| EXPECT_TRUE(LessThanComparable<arch>::value); |
| EXPECT_TRUE(NothrowLessThanComparable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Less equal comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::less_equal_comparable_support) { |
| case ti::less_equal_comparable::maybe: |
| EXPECT_FALSE(LessEqualComparable<arch>::value); |
| EXPECT_FALSE(NothrowLessEqualComparable<arch>::value); |
| break; |
| case ti::less_equal_comparable::yes: |
| EXPECT_TRUE(LessEqualComparable<arch>::value); |
| EXPECT_FALSE(NothrowLessEqualComparable<arch>::value); |
| break; |
| case ti::less_equal_comparable::nothrow: |
| EXPECT_TRUE(LessEqualComparable<arch>::value); |
| EXPECT_TRUE(NothrowLessEqualComparable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Greater equal comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::greater_equal_comparable_support) { |
| case ti::greater_equal_comparable::maybe: |
| EXPECT_FALSE(GreaterEqualComparable<arch>::value); |
| EXPECT_FALSE(NothrowGreaterEqualComparable<arch>::value); |
| break; |
| case ti::greater_equal_comparable::yes: |
| EXPECT_TRUE(GreaterEqualComparable<arch>::value); |
| EXPECT_FALSE(NothrowGreaterEqualComparable<arch>::value); |
| break; |
| case ti::greater_equal_comparable::nothrow: |
| EXPECT_TRUE(GreaterEqualComparable<arch>::value); |
| EXPECT_TRUE(NothrowGreaterEqualComparable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Greater than comparable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::greater_than_comparable_support) { |
| case ti::greater_than_comparable::maybe: |
| EXPECT_FALSE(GreaterThanComparable<arch>::value); |
| EXPECT_FALSE(NothrowGreaterThanComparable<arch>::value); |
| break; |
| case ti::greater_than_comparable::yes: |
| EXPECT_TRUE(GreaterThanComparable<arch>::value); |
| EXPECT_FALSE(NothrowGreaterThanComparable<arch>::value); |
| break; |
| case ti::greater_than_comparable::nothrow: |
| EXPECT_TRUE(GreaterThanComparable<arch>::value); |
| EXPECT_TRUE(NothrowGreaterThanComparable<arch>::value); |
| break; |
| } |
| } |
| |
| TYPED_TEST_P(ProfileTest, HasAppropriateAuxilliaryProperties) { |
| using profile = typename TypeParam::profile; |
| using arch = typename TypeParam::arch; |
| using expected_profile = typename TypeParam::expected_profile; |
| |
| using props = ti::PropertiesOfT<profile>; |
| using arch_props = ti::PropertiesOfArchetypeT<arch>; |
| using expected_props = ti::PropertiesOfT<expected_profile>; |
| |
| // Make sure all of the properties are as expected. |
| // There are seemingly redundant tests here to make it easier to diagnose |
| // the specifics of the failure if something were to go wrong. |
| EXPECT_TRUE((std::is_same<props, arch_props>::value)); |
| EXPECT_TRUE((std::is_same<props, expected_props>::value)); |
| EXPECT_TRUE((std::is_same<arch_props, expected_props>::value)); |
| |
| EXPECT_EQ(props::swappable_support, expected_props::swappable_support); |
| |
| EXPECT_EQ(props::hashable_support, expected_props::hashable_support); |
| |
| // Avoid additional error message noise when profile and archetype match with |
| // each other but were not what was expected. |
| if (!std::is_same<props, arch_props>::value) { |
| EXPECT_EQ(arch_props::swappable_support, expected_props::swappable_support); |
| |
| EXPECT_EQ(arch_props::hashable_support, expected_props::hashable_support); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Swappable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::swappable_support) { |
| case ti::swappable::maybe: |
| EXPECT_FALSE(absl::type_traits_internal::IsSwappable<arch>::value); |
| EXPECT_FALSE(absl::type_traits_internal::IsNothrowSwappable<arch>::value); |
| break; |
| case ti::swappable::yes: |
| EXPECT_TRUE(absl::type_traits_internal::IsSwappable<arch>::value); |
| EXPECT_FALSE(absl::type_traits_internal::IsNothrowSwappable<arch>::value); |
| break; |
| case ti::swappable::nothrow: |
| EXPECT_TRUE(absl::type_traits_internal::IsSwappable<arch>::value); |
| EXPECT_TRUE(absl::type_traits_internal::IsNothrowSwappable<arch>::value); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Hashable checks // |
| ////////////////////////////////////////////////////////////////////////////// |
| switch (expected_props::hashable_support) { |
| case ti::hashable::maybe: |
| #if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ |
| EXPECT_FALSE(absl::type_traits_internal::IsHashable<arch>::value); |
| #endif // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ |
| break; |
| case ti::hashable::yes: |
| EXPECT_TRUE(absl::type_traits_internal::IsHashable<arch>::value); |
| break; |
| } |
| } |
| |
| REGISTER_TYPED_TEST_SUITE_P(ProfileTest, HasAppropriateConstructionProperties, |
| HasAppropriateAssignmentProperties, |
| HasAppropriateComparisonProperties, |
| HasAppropriateAuxilliaryProperties); |
| |
| template <class Profile, class Arch, class ExpectedProfile> |
| struct ProfileAndExpectation { |
| using profile = Profile; |
| using arch = Arch; |
| using expected_profile = ExpectedProfile; |
| }; |
| |
| using CoreProfilesToTest = ::testing::Types< |
| // The terminating case of combine (all properties are "maybe"). |
| ProfileAndExpectation<ti::CombineProfiles<>, |
| ti::Archetype<ti::CombineProfiles<>>, |
| ti::ConformanceProfile<>>, |
| |
| // Core default constructor profiles |
| ProfileAndExpectation< |
| ti::HasDefaultConstructorProfile, ti::HasDefaultConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowDefaultConstructorProfile, |
| ti::HasNothrowDefaultConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialDefaultConstructorProfile, |
| ti::HasTrivialDefaultConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::trivial>>, |
| |
| // Core move constructor profiles |
| ProfileAndExpectation< |
| ti::HasMoveConstructorProfile, ti::HasMoveConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowMoveConstructorProfile, |
| ti::HasNothrowMoveConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialMoveConstructorProfile, |
| ti::HasTrivialMoveConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::trivial>>, |
| |
| // Core copy constructor profiles |
| ProfileAndExpectation< |
| ti::HasCopyConstructorProfile, ti::HasCopyConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::maybe, |
| ti::copy_constructible::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowCopyConstructorProfile, |
| ti::HasNothrowCopyConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::maybe, |
| ti::copy_constructible::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialCopyConstructorProfile, |
| ti::HasTrivialCopyConstructorArchetype, |
| ti::ConformanceProfile<ti::default_constructible::maybe, |
| ti::move_constructible::maybe, |
| ti::copy_constructible::trivial>>, |
| |
| // Core move assignment profiles |
| ProfileAndExpectation< |
| ti::HasMoveAssignProfile, ti::HasMoveAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowMoveAssignProfile, ti::HasNothrowMoveAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialMoveAssignProfile, ti::HasTrivialMoveAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::trivial>>, |
| |
| // Core copy assignment profiles |
| ProfileAndExpectation< |
| ti::HasCopyAssignProfile, ti::HasCopyAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowCopyAssignProfile, ti::HasNothrowCopyAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialCopyAssignProfile, ti::HasTrivialCopyAssignArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::trivial>>, |
| |
| // Core destructor profiles |
| ProfileAndExpectation< |
| ti::HasDestructorProfile, ti::HasDestructorArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowDestructorProfile, ti::HasNothrowDestructorArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow>>, |
| ProfileAndExpectation< |
| ti::HasTrivialDestructorProfile, ti::HasTrivialDestructorArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::trivial>>, |
| |
| // Core equality comparable profiles |
| ProfileAndExpectation< |
| ti::HasEqualityProfile, ti::HasEqualityArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowEqualityProfile, ti::HasNothrowEqualityArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::nothrow>>, |
| |
| // Core inequality comparable profiles |
| ProfileAndExpectation< |
| ti::HasInequalityProfile, ti::HasInequalityArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowInequalityProfile, ti::HasNothrowInequalityArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, |
| ti::inequality_comparable::nothrow>>, |
| |
| // Core less than comparable profiles |
| ProfileAndExpectation< |
| ti::HasLessThanProfile, ti::HasLessThanArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowLessThanProfile, ti::HasNothrowLessThanArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::nothrow>>, |
| |
| // Core less equal comparable profiles |
| ProfileAndExpectation< |
| ti::HasLessEqualProfile, ti::HasLessEqualArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowLessEqualProfile, ti::HasNothrowLessEqualArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, |
| ti::less_equal_comparable::nothrow>>, |
| |
| // Core greater equal comparable profiles |
| ProfileAndExpectation< |
| ti::HasGreaterEqualProfile, ti::HasGreaterEqualArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowGreaterEqualProfile, ti::HasNothrowGreaterEqualArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::nothrow>>, |
| |
| // Core greater than comparable profiles |
| ProfileAndExpectation< |
| ti::HasGreaterThanProfile, ti::HasGreaterThanArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowGreaterThanProfile, ti::HasNothrowGreaterThanArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::nothrow>>, |
| |
| // Core swappable profiles |
| ProfileAndExpectation< |
| ti::HasSwapProfile, ti::HasSwapArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::yes>>, |
| ProfileAndExpectation< |
| ti::HasNothrowSwapProfile, ti::HasNothrowSwapArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>, |
| |
| // Core hashable profiles |
| ProfileAndExpectation< |
| ti::HasStdHashSpecializationProfile, |
| ti::HasStdHashSpecializationArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::maybe, |
| ti::hashable::yes>>>; |
| |
| using CommonProfilesToTest = ::testing::Types< |
| // NothrowMoveConstructible |
| ProfileAndExpectation< |
| ti::NothrowMoveConstructibleProfile, |
| ti::NothrowMoveConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow>>, |
| |
| // CopyConstructible |
| ProfileAndExpectation< |
| ti::CopyConstructibleProfile, ti::CopyConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow>>, |
| |
| // NothrowMovable |
| ProfileAndExpectation< |
| ti::NothrowMovableProfile, ti::NothrowMovableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::nothrow, |
| ti::copy_assignable::maybe, ti::destructible::nothrow, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>, |
| |
| // Value |
| ProfileAndExpectation< |
| ti::ValueProfile, ti::ValueArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::nothrow, |
| ti::copy_assignable::yes, ti::destructible::nothrow, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>, |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Common but also DefaultConstructible // |
| //////////////////////////////////////////////////////////////////////////// |
| |
| // DefaultConstructibleNothrowMoveConstructible |
| ProfileAndExpectation< |
| ti::DefaultConstructibleNothrowMoveConstructibleProfile, |
| ti::DefaultConstructibleNothrowMoveConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::yes, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow>>, |
| |
| // DefaultConstructibleCopyConstructible |
| ProfileAndExpectation< |
| ti::DefaultConstructibleCopyConstructibleProfile, |
| ti::DefaultConstructibleCopyConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::yes, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow>>, |
| |
| // DefaultConstructibleNothrowMovable |
| ProfileAndExpectation< |
| ti::DefaultConstructibleNothrowMovableProfile, |
| ti::DefaultConstructibleNothrowMovableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::yes, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::nothrow, |
| ti::copy_assignable::maybe, ti::destructible::nothrow, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>, |
| |
| // DefaultConstructibleValue |
| ProfileAndExpectation< |
| ti::DefaultConstructibleValueProfile, |
| ti::DefaultConstructibleValueArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::yes, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::nothrow, |
| ti::copy_assignable::yes, ti::destructible::nothrow, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>>; |
| |
| using ComparableHelpersProfilesToTest = ::testing::Types< |
| // Equatable |
| ProfileAndExpectation< |
| ti::EquatableProfile, ti::EquatableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes>>, |
| |
| // Comparable |
| ProfileAndExpectation< |
| ti::ComparableProfile, ti::ComparableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, |
| ti::greater_than_comparable::yes>>, |
| |
| // NothrowEquatable |
| ProfileAndExpectation< |
| ti::NothrowEquatableProfile, ti::NothrowEquatableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::nothrow, |
| ti::inequality_comparable::nothrow>>, |
| |
| // NothrowComparable |
| ProfileAndExpectation< |
| ti::NothrowComparableProfile, ti::NothrowComparableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::maybe, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::maybe, |
| ti::equality_comparable::nothrow, |
| ti::inequality_comparable::nothrow, |
| ti::less_than_comparable::nothrow, |
| ti::less_equal_comparable::nothrow, |
| ti::greater_equal_comparable::nothrow, |
| ti::greater_than_comparable::nothrow>>>; |
| |
| using CommonComparableProfilesToTest = ::testing::Types< |
| // ComparableNothrowMoveConstructible |
| ProfileAndExpectation< |
| ti::ComparableNothrowMoveConstructibleProfile, |
| ti::ComparableNothrowMoveConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, |
| ti::greater_than_comparable::yes>>, |
| |
| // ComparableCopyConstructible |
| ProfileAndExpectation< |
| ti::ComparableCopyConstructibleProfile, |
| ti::ComparableCopyConstructibleArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::maybe, |
| ti::copy_assignable::maybe, ti::destructible::nothrow, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, |
| ti::greater_than_comparable::yes>>, |
| |
| // ComparableNothrowMovable |
| ProfileAndExpectation< |
| ti::ComparableNothrowMovableProfile, |
| ti::ComparableNothrowMovableArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::maybe, ti::move_assignable::nothrow, |
| ti::copy_assignable::maybe, ti::destructible::nothrow, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes, |
| ti::swappable::nothrow>>, |
| |
| // ComparableValue |
| ProfileAndExpectation< |
| ti::ComparableValueProfile, ti::ComparableValueArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::maybe, ti::move_constructible::nothrow, |
| ti::copy_constructible::yes, ti::move_assignable::nothrow, |
| ti::copy_assignable::yes, ti::destructible::nothrow, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes, |
| ti::swappable::nothrow>>>; |
| |
| using TrivialProfilesToTest = ::testing::Types< |
| ProfileAndExpectation< |
| ti::TrivialSpecialMemberFunctionsProfile, |
| ti::TrivialSpecialMemberFunctionsArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::trivial, ti::move_constructible::trivial, |
| ti::copy_constructible::trivial, ti::move_assignable::trivial, |
| ti::copy_assignable::trivial, ti::destructible::trivial, |
| ti::equality_comparable::maybe, ti::inequality_comparable::maybe, |
| ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe, |
| ti::greater_equal_comparable::maybe, |
| ti::greater_than_comparable::maybe, ti::swappable::nothrow>>, |
| |
| ProfileAndExpectation< |
| ti::TriviallyCompleteProfile, ti::TriviallyCompleteArchetype, |
| ti::ConformanceProfile< |
| ti::default_constructible::trivial, ti::move_constructible::trivial, |
| ti::copy_constructible::trivial, ti::move_assignable::trivial, |
| ti::copy_assignable::trivial, ti::destructible::trivial, |
| ti::equality_comparable::yes, ti::inequality_comparable::yes, |
| ti::less_than_comparable::yes, ti::less_equal_comparable::yes, |
| ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes, |
| ti::swappable::nothrow, ti::hashable::yes>>>; |
| |
| INSTANTIATE_TYPED_TEST_SUITE_P(Core, ProfileTest, CoreProfilesToTest); |
| INSTANTIATE_TYPED_TEST_SUITE_P(Common, ProfileTest, CommonProfilesToTest); |
| INSTANTIATE_TYPED_TEST_SUITE_P(ComparableHelpers, ProfileTest, |
| ComparableHelpersProfilesToTest); |
| INSTANTIATE_TYPED_TEST_SUITE_P(CommonComparable, ProfileTest, |
| CommonComparableProfilesToTest); |
| INSTANTIATE_TYPED_TEST_SUITE_P(Trivial, ProfileTest, TrivialProfilesToTest); |
| |
| TEST(ConformanceTestingTest, Basic) { |
| using profile = ti::CombineProfiles<ti::TriviallyCompleteProfile, |
| ti::NothrowComparableProfile>; |
| |
| using lim = std::numeric_limits<float>; |
| |
| ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(float) |
| .INITIALIZER(-lim::infinity()) |
| .INITIALIZER(lim::lowest()) |
| .INITIALIZER(-1.f) |
| .INITIALIZER(-lim::min()) |
| .EQUIVALENCE_CLASS(INITIALIZER(-0.f), INITIALIZER(0.f)) |
| .INITIALIZER(lim::min()) |
| .INITIALIZER(1.f) |
| .INITIALIZER(lim::max()) |
| .INITIALIZER(lim::infinity()) |
| .WITH_STRICT_PROFILE(absl::types_internal::RegularityDomain, profile); |
| } |
| |
| struct BadMoveConstruct { |
| BadMoveConstruct() = default; |
| BadMoveConstruct(BadMoveConstruct&& other) noexcept |
| : value(other.value + 1) {} |
| BadMoveConstruct& operator=(BadMoveConstruct&& other) noexcept = default; |
| int value = 0; |
| |
| friend bool operator==(BadMoveConstruct const& lhs, |
| BadMoveConstruct const& rhs) { |
| return lhs.value == rhs.value; |
| } |
| friend bool operator!=(BadMoveConstruct const& lhs, |
| BadMoveConstruct const& rhs) { |
| return lhs.value != rhs.value; |
| } |
| }; |
| |
| struct BadMoveAssign { |
| BadMoveAssign() = default; |
| BadMoveAssign(BadMoveAssign&& other) noexcept = default; |
| BadMoveAssign& operator=(BadMoveAssign&& other) noexcept { |
| int new_value = other.value + 1; |
| value = new_value; |
| return *this; |
| } |
| int value = 0; |
| |
| friend bool operator==(BadMoveAssign const& lhs, BadMoveAssign const& rhs) { |
| return lhs.value == rhs.value; |
| } |
| friend bool operator!=(BadMoveAssign const& lhs, BadMoveAssign const& rhs) { |
| return lhs.value != rhs.value; |
| } |
| }; |
| |
| enum class WhichCompIsBad { eq, ne, lt, le, ge, gt }; |
| |
| template <WhichCompIsBad Which> |
| struct BadCompare { |
| int value; |
| |
| friend bool operator==(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::eq ? lhs.value != rhs.value |
| : lhs.value == rhs.value; |
| } |
| |
| friend bool operator!=(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::ne ? lhs.value == rhs.value |
| : lhs.value != rhs.value; |
| } |
| |
| friend bool operator<(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::lt ? lhs.value >= rhs.value |
| : lhs.value < rhs.value; |
| } |
| |
| friend bool operator<=(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::le ? lhs.value > rhs.value |
| : lhs.value <= rhs.value; |
| } |
| |
| friend bool operator>=(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::ge ? lhs.value < rhs.value |
| : lhs.value >= rhs.value; |
| } |
| |
| friend bool operator>(BadCompare const& lhs, BadCompare const& rhs) { |
| return Which == WhichCompIsBad::gt ? lhs.value <= rhs.value |
| : lhs.value > rhs.value; |
| } |
| }; |
| |
| TEST(ConformanceTestingDeathTest, Failures) { |
| { |
| using profile = ti::CombineProfiles<ti::TriviallyCompleteProfile, |
| ti::NothrowComparableProfile>; |
| |
| // Note: The initializers are intentionally in the wrong order. |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(float) |
| .INITIALIZER(1.f) |
| .INITIALIZER(0.f) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using profile = |
| ti::CombineProfiles<ti::NothrowMovableProfile, ti::EquatableProfile>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadMoveConstruct) |
| .DUE_TO("Move construction") |
| .INITIALIZER(BadMoveConstruct()) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using profile = |
| ti::CombineProfiles<ti::NothrowMovableProfile, ti::EquatableProfile>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadMoveAssign) |
| .DUE_TO("Move assignment") |
| .INITIALIZER(BadMoveAssign()) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| TEST(ConformanceTestingDeathTest, CompFailures) { |
| using profile = ti::ComparableProfile; |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::eq>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::ne>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::lt>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::le>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::ge>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| |
| { |
| using BadComp = BadCompare<WhichCompIsBad::gt>; |
| |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp) |
| .DUE_TO("Comparison") |
| .INITIALIZER(BadComp{0}) |
| .INITIALIZER(BadComp{1}) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| struct BadSelfMove { |
| BadSelfMove() = default; |
| BadSelfMove(BadSelfMove&&) = default; |
| BadSelfMove& operator=(BadSelfMove&& other) noexcept { |
| if (this == &other) { |
| broken_state = true; |
| } |
| return *this; |
| } |
| |
| friend bool operator==(const BadSelfMove& lhs, const BadSelfMove& rhs) { |
| return !(lhs.broken_state || rhs.broken_state); |
| } |
| |
| friend bool operator!=(const BadSelfMove& lhs, const BadSelfMove& rhs) { |
| return lhs.broken_state || rhs.broken_state; |
| } |
| |
| bool broken_state = false; |
| }; |
| |
| TEST(ConformanceTestingDeathTest, SelfMoveFailure) { |
| using profile = ti::EquatableNothrowMovableProfile; |
| |
| { |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfMove) |
| .DUE_TO("Move assignment") |
| .INITIALIZER(BadSelfMove()) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| struct BadSelfCopy { |
| BadSelfCopy() = default; |
| BadSelfCopy(BadSelfCopy&&) = default; |
| BadSelfCopy(const BadSelfCopy&) = default; |
| BadSelfCopy& operator=(BadSelfCopy&&) = default; |
| BadSelfCopy& operator=(BadSelfCopy const& other) { |
| if (this == &other) { |
| broken_state = true; |
| } |
| return *this; |
| } |
| |
| friend bool operator==(const BadSelfCopy& lhs, const BadSelfCopy& rhs) { |
| return !(lhs.broken_state || rhs.broken_state); |
| } |
| |
| friend bool operator!=(const BadSelfCopy& lhs, const BadSelfCopy& rhs) { |
| return lhs.broken_state || rhs.broken_state; |
| } |
| |
| bool broken_state = false; |
| }; |
| |
| TEST(ConformanceTestingDeathTest, SelfCopyFailure) { |
| using profile = ti::EquatableValueProfile; |
| |
| { |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfCopy) |
| .DUE_TO("Copy assignment") |
| .INITIALIZER(BadSelfCopy()) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| struct BadSelfSwap { |
| friend void swap(BadSelfSwap& lhs, BadSelfSwap& rhs) noexcept { |
| if (&lhs == &rhs) lhs.broken_state = true; |
| } |
| |
| friend bool operator==(const BadSelfSwap& lhs, const BadSelfSwap& rhs) { |
| return !(lhs.broken_state || rhs.broken_state); |
| } |
| |
| friend bool operator!=(const BadSelfSwap& lhs, const BadSelfSwap& rhs) { |
| return lhs.broken_state || rhs.broken_state; |
| } |
| |
| bool broken_state = false; |
| }; |
| |
| TEST(ConformanceTestingDeathTest, SelfSwapFailure) { |
| using profile = ti::EquatableNothrowMovableProfile; |
| |
| { |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfSwap) |
| .DUE_TO("Swap") |
| .INITIALIZER(BadSelfSwap()) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| struct BadDefaultInitializedMoveAssign { |
| BadDefaultInitializedMoveAssign() : default_initialized(true) {} |
| explicit BadDefaultInitializedMoveAssign(int v) : value(v) {} |
| BadDefaultInitializedMoveAssign( |
| BadDefaultInitializedMoveAssign&& other) noexcept |
| : value(other.value) {} |
| BadDefaultInitializedMoveAssign& operator=( |
| BadDefaultInitializedMoveAssign&& other) noexcept { |
| value = other.value; |
| if (default_initialized) ++value; // Bad move if lhs is default initialized |
| return *this; |
| } |
| |
| friend bool operator==(const BadDefaultInitializedMoveAssign& lhs, |
| const BadDefaultInitializedMoveAssign& rhs) { |
| return lhs.value == rhs.value; |
| } |
| |
| friend bool operator!=(const BadDefaultInitializedMoveAssign& lhs, |
| const BadDefaultInitializedMoveAssign& rhs) { |
| return lhs.value != rhs.value; |
| } |
| |
| bool default_initialized = false; |
| int value = 0; |
| }; |
| |
| TEST(ConformanceTestingDeathTest, DefaultInitializedMoveAssignFailure) { |
| using profile = |
| ti::CombineProfiles<ti::DefaultConstructibleNothrowMovableProfile, |
| ti::EquatableProfile>; |
| |
| { |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadDefaultInitializedMoveAssign) |
| .DUE_TO("move assignment") |
| .INITIALIZER(BadDefaultInitializedMoveAssign(0)) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| struct BadDefaultInitializedCopyAssign { |
| BadDefaultInitializedCopyAssign() : default_initialized(true) {} |
| explicit BadDefaultInitializedCopyAssign(int v) : value(v) {} |
| BadDefaultInitializedCopyAssign( |
| BadDefaultInitializedCopyAssign&& other) noexcept |
| : value(other.value) {} |
| BadDefaultInitializedCopyAssign(const BadDefaultInitializedCopyAssign& other) |
| : value(other.value) {} |
| |
| BadDefaultInitializedCopyAssign& operator=( |
| BadDefaultInitializedCopyAssign&& other) noexcept { |
| value = other.value; |
| return *this; |
| } |
| |
| BadDefaultInitializedCopyAssign& operator=( |
| const BadDefaultInitializedCopyAssign& other) { |
| value = other.value; |
| if (default_initialized) ++value; // Bad move if lhs is default initialized |
| return *this; |
| } |
| |
| friend bool operator==(const BadDefaultInitializedCopyAssign& lhs, |
| const BadDefaultInitializedCopyAssign& rhs) { |
| return lhs.value == rhs.value; |
| } |
| |
| friend bool operator!=(const BadDefaultInitializedCopyAssign& lhs, |
| const BadDefaultInitializedCopyAssign& rhs) { |
| return lhs.value != rhs.value; |
| } |
| |
| bool default_initialized = false; |
| int value = 0; |
| }; |
| |
| TEST(ConformanceTestingDeathTest, DefaultInitializedAssignFailure) { |
| using profile = ti::CombineProfiles<ti::DefaultConstructibleValueProfile, |
| ti::EquatableProfile>; |
| |
| { |
| ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadDefaultInitializedCopyAssign) |
| .DUE_TO("copy assignment") |
| .INITIALIZER(BadDefaultInitializedCopyAssign(0)) |
| .WITH_LOOSE_PROFILE(profile); |
| } |
| } |
| |
| } // namespace |
