From 6455d85714ff6ade0424c5ce1de4d1503fa45331 Mon Sep 17 00:00:00 2001 From: Marshall Clow Date: Sat, 7 Nov 2015 17:44:36 +0000 Subject: [PATCH] More of P0006R0: type traits variable aliases for C++17. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@252406 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/type_traits | 120 ++++++++++++++++++ .../has_virtual_destructor.pass.cpp | 12 ++ .../meta.unary.prop/is_assignable.pass.cpp | 6 + .../meta.unary.prop/is_constructible.pass.cpp | 19 ++- .../is_copy_assignable.pass.cpp | 6 + .../is_copy_constructible.pass.cpp | 6 + .../is_default_constructible.pass.cpp | 12 ++ .../meta.unary.prop/is_destructible.pass.cpp | 12 ++ .../meta.unary.prop/is_literal_type.pass.cpp | 2 +- .../is_move_assignable.pass.cpp | 10 +- .../is_move_constructible.pass.cpp | 6 + .../is_nothrow_assignable.pass.cpp | 6 + .../is_nothrow_constructible.pass.cpp | 15 +++ .../is_nothrow_copy_assignable.pass.cpp | 6 + .../is_nothrow_copy_constructible.pass.cpp | 10 ++ .../is_nothrow_default_constructible.pass.cpp | 12 ++ .../is_nothrow_destructible.pass.cpp | 12 ++ .../is_nothrow_move_assignable.pass.cpp | 6 + .../is_nothrow_move_constructible.pass.cpp | 10 ++ .../is_trivially_assignable.pass.cpp | 6 + .../is_trivially_constructible.pass.cpp | 15 +++ .../is_trivially_copy_assignable.pass.cpp | 6 + .../is_trivially_copy_constructible.pass.cpp | 8 ++ ...s_trivially_default_constructible.pass.cpp | 12 ++ .../is_trivially_destructible.pass.cpp | 12 ++ .../is_trivially_move_assignable.pass.cpp | 6 + .../is_trivially_move_constructible.pass.cpp | 6 + 27 files changed, 354 insertions(+), 5 deletions(-) diff --git a/include/type_traits b/include/type_traits index 8f1dd68d..c5a24a47 100644 --- a/include/type_traits +++ b/include/type_traits @@ -1378,6 +1378,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor #endif +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool has_virtual_destructor_v + = has_virtual_destructor<_Tp>::value; +#endif + // alignment_of template struct _LIBCPP_TYPE_VIS_ONLY alignment_of @@ -1905,12 +1910,22 @@ template struct is_assignable : public __is_assignable_imp<_Tp, _Arg> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_assignable_v + = is_assignable<_Tp, _Arg>::value; +#endif + // is_copy_assignable template struct _LIBCPP_TYPE_VIS_ONLY is_copy_assignable : public is_assignable::type, typename add_lvalue_reference::type>::type> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_copy_assignable_v + = is_copy_assignable<_Tp>::value; +#endif + // is_move_assignable template struct _LIBCPP_TYPE_VIS_ONLY is_move_assignable @@ -1921,6 +1936,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_move_assignable : public is_copy_assignable<_Tp> {}; #endif +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_move_assignable_v + = is_move_assignable<_Tp>::value; +#endif + // is_destructible // if it's a reference, return true @@ -1979,6 +1999,11 @@ template <> struct is_destructible : public _VSTD::false_type {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_destructible_v + = is_destructible<_Tp>::value; +#endif + // move #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -3013,6 +3038,11 @@ struct __is_constructible2_imp #endif // _LIBCPP_HAS_NO_VARIADICS #endif // __has_feature(is_constructible) +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS) +template _LIBCPP_CONSTEXPR bool is_constructible_v + = is_constructible<_Tp, _Args...>::value; +#endif + // is_default_constructible template @@ -3020,6 +3050,11 @@ struct _LIBCPP_TYPE_VIS_ONLY is_default_constructible : public is_constructible<_Tp> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_default_constructible_v + = is_default_constructible<_Tp>::value; +#endif + // is_copy_constructible template @@ -3027,6 +3062,11 @@ struct _LIBCPP_TYPE_VIS_ONLY is_copy_constructible : public is_constructible<_Tp, typename add_lvalue_reference::type>::type> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_copy_constructible_v + = is_copy_constructible<_Tp>::value; +#endif + // is_move_constructible template @@ -3038,6 +3078,11 @@ struct _LIBCPP_TYPE_VIS_ONLY is_move_constructible #endif {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_move_constructible_v + = is_move_constructible<_Tp>::value; +#endif + // is_trivially_constructible #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -3165,18 +3210,33 @@ struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&, #endif // _LIBCPP_HAS_NO_VARIADICS +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS) +template _LIBCPP_CONSTEXPR bool is_trivially_constructible_v + = is_trivially_constructible<_Tp>::value; +#endif + // is_trivially_default_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_default_constructible : public is_trivially_constructible<_Tp> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_default_constructible_v + = is_trivially_default_constructible<_Tp>::value; +#endif + // is_trivially_copy_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_constructible : public is_trivially_constructible<_Tp, typename add_lvalue_reference::type> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_copy_constructible_v + = is_trivially_copy_constructible<_Tp>::value; +#endif + // is_trivially_move_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructible @@ -3187,6 +3247,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructibl #endif {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_move_constructible_v + = is_trivially_move_constructible<_Tp>::value; +#endif + // is_trivially_assignable #if __has_feature(is_trivially_assignable) || _GNUC_VER >= 501 @@ -3225,12 +3290,22 @@ struct is_trivially_assignable<_Tp&, _Tp&&> #endif // !__has_feature(is_trivially_assignable) +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_assignable_v + = is_trivially_assignable<_Tp, _Arg>::value; +#endif + // is_trivially_copy_assignable template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_assignable : public is_trivially_assignable::type, typename add_lvalue_reference::type>::type> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_copy_assignable_v + = is_trivially_copy_assignable<_Tp>::value; +#endif + // is_trivially_move_assignable template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_assignable @@ -3242,6 +3317,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_assignable #endif {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_move_assignable_v + = is_trivially_move_assignable<_Tp>::value; +#endif + // is_trivially_destructible #if __has_feature(has_trivial_destructor) || (_GNUC_VER >= 403) @@ -3263,6 +3343,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible<_Tp[ #endif +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_trivially_destructible_v + = is_trivially_destructible<_Tp>::value; +#endif + // is_nothrow_constructible #if 0 @@ -3423,18 +3508,33 @@ struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&, #endif // _LIBCPP_HAS_NO_VARIADICS #endif // __has_feature(is_nothrow_constructible) +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS) +template _LIBCPP_CONSTEXPR bool is_nothrow_constructible_v + = is_nothrow_constructible<_Tp, _Args...>::value; +#endif + // is_nothrow_default_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_default_constructible : public is_nothrow_constructible<_Tp> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_default_constructible_v + = is_nothrow_default_constructible<_Tp>::value; +#endif + // is_nothrow_copy_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_constructible : public is_nothrow_constructible<_Tp, typename add_lvalue_reference::type>::type> {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_copy_constructible_v + = is_nothrow_copy_constructible<_Tp>::value; +#endif + // is_nothrow_move_constructible template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_constructible @@ -3445,6 +3545,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_constructible #endif {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_move_constructible_v + = is_nothrow_move_constructible<_Tp>::value; +#endif + // is_nothrow_assignable #if __has_feature(cxx_noexcept) || (_GNUC_VER >= 407 && __cplusplus >= 201103L) @@ -3513,6 +3618,11 @@ struct is_nothrow_assignable<_Tp&, _Tp&&> #endif // __has_feature(cxx_noexcept) +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_assignable_v + = is_nothrow_assignable<_Tp, _Arg>::value; +#endif + // is_nothrow_copy_assignable template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_assignable @@ -3530,6 +3640,11 @@ template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_assignable #endif {}; +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_copy_assignable_v + = is_nothrow_copy_assignable<_Tp>::value; +#endif + // is_nothrow_destructible #if __has_feature(cxx_noexcept) || (_GNUC_VER >= 407 && __cplusplus >= 201103L) @@ -3591,6 +3706,11 @@ struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[]> #endif +#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template _LIBCPP_CONSTEXPR bool is_nothrow_destructible_v + = is_nothrow_destructible<_Tp>::value; +#endif + // is_pod #if __has_feature(is_pod) || (_GNUC_VER >= 403) diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp index 685d30de..36020139 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp @@ -20,6 +20,12 @@ void test_has_virtual_destructor() static_assert( std::has_virtual_destructor::value, ""); static_assert( std::has_virtual_destructor::value, ""); static_assert( std::has_virtual_destructor::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::has_virtual_destructor_v, ""); + static_assert( std::has_virtual_destructor_v, ""); + static_assert( std::has_virtual_destructor_v, ""); + static_assert( std::has_virtual_destructor_v, ""); +#endif } template @@ -29,6 +35,12 @@ void test_has_not_virtual_destructor() static_assert(!std::has_virtual_destructor::value, ""); static_assert(!std::has_virtual_destructor::value, ""); static_assert(!std::has_virtual_destructor::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::has_virtual_destructor_v, ""); + static_assert(!std::has_virtual_destructor_v, ""); + static_assert(!std::has_virtual_destructor_v, ""); + static_assert(!std::has_virtual_destructor_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp index d33019bc..fbe36618 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp @@ -26,12 +26,18 @@ template void test_is_assignable() { static_assert(( std::is_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert( std::is_assignable_v, ""); +#endif } template void test_is_not_assignable() { static_assert((!std::is_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert( !std::is_assignable_v, ""); +#endif } struct D; diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp index 2b8f7efe..606cd974 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp @@ -38,30 +38,45 @@ template void test_is_constructible() { static_assert( (std::is_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert( std::is_constructible_v, ""); +#endif } template void test_is_constructible() { - static_assert( (std::is_constructible::value), ""); + static_assert(( std::is_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_constructible_v), ""); +#endif } template void test_is_constructible() { - static_assert( (std::is_constructible::value), ""); + static_assert(( std::is_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_constructible_v), ""); +#endif } template void test_is_not_constructible() { static_assert((!std::is_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_constructible_v), ""); +#endif } template void test_is_not_constructible() { static_assert((!std::is_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_constructible_v), ""); +#endif } int main() diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp index c43d5947..904e8513 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_is_copy_assignable() { static_assert(( std::is_copy_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_copy_assignable_v), ""); +#endif } template void test_is_not_copy_assignable() { static_assert((!std::is_copy_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_copy_assignable_v), ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp index f878a50c..5d684961 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp @@ -17,12 +17,18 @@ template void test_is_copy_constructible() { static_assert( std::is_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_copy_constructible_v, ""); +#endif } template void test_is_not_copy_constructible() { static_assert(!std::is_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_copy_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp index c8d5c42f..b0d6b037 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp @@ -20,6 +20,12 @@ void test_is_default_constructible() static_assert( std::is_default_constructible::value, ""); static_assert( std::is_default_constructible::value, ""); static_assert( std::is_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_default_constructible_v, ""); + static_assert( std::is_default_constructible_v, ""); + static_assert( std::is_default_constructible_v, ""); + static_assert( std::is_default_constructible_v, ""); +#endif } template @@ -29,6 +35,12 @@ void test_is_not_default_constructible() static_assert(!std::is_default_constructible::value, ""); static_assert(!std::is_default_constructible::value, ""); static_assert(!std::is_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_default_constructible_v, ""); + static_assert(!std::is_default_constructible_v, ""); + static_assert(!std::is_default_constructible_v, ""); + static_assert(!std::is_default_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp index fae9557d..772d3eab 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp @@ -22,6 +22,12 @@ void test_is_destructible() static_assert( std::is_destructible::value, ""); static_assert( std::is_destructible::value, ""); static_assert( std::is_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_destructible_v, ""); + static_assert( std::is_destructible_v, ""); + static_assert( std::is_destructible_v, ""); + static_assert( std::is_destructible_v, ""); +#endif } template @@ -31,6 +37,12 @@ void test_is_not_destructible() static_assert(!std::is_destructible::value, ""); static_assert(!std::is_destructible::value, ""); static_assert(!std::is_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_destructible_v, ""); + static_assert(!std::is_destructible_v, ""); + static_assert(!std::is_destructible_v, ""); + static_assert(!std::is_destructible_v, ""); +#endif } class Empty {}; diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp index 3b55c059..d7b7f16c 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp @@ -79,7 +79,7 @@ int main() // In C++14, cv-void is is a literal type #if TEST_STD_VER < 14 test_is_not_literal_type(); -#else TEST_STD_VER > 14 +#elif TEST_STD_VER > 14 test_is_literal_type(); #endif diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp index a89ee7d4..78e27368 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp @@ -16,13 +16,19 @@ template void test_is_move_assignable() { - static_assert( std::is_move_assignable::value, ""); + static_assert(( std::is_move_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_move_assignable_v), ""); +#endif } template void test_is_not_move_assignable() { - static_assert(!std::is_move_assignable::value, ""); + static_assert((!std::is_move_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_move_assignable_v), ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp index 7409ebaa..0609db7e 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp @@ -17,12 +17,18 @@ template void test_is_move_constructible() { static_assert( std::is_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_move_constructible_v, ""); +#endif } template void test_is_not_move_constructible() { static_assert(!std::is_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_move_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp index 8fff5f8b..9bd1b09f 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_is_nothrow_assignable() { static_assert(( std::is_nothrow_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_nothrow_assignable_v), ""); +#endif } template void test_is_not_nothrow_assignable() { static_assert((!std::is_nothrow_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_nothrow_assignable_v), ""); +#endif } struct A diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp index fe0b5673..f2c1d662 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp @@ -18,30 +18,45 @@ template void test_is_nothrow_constructible() { static_assert(( std::is_nothrow_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_nothrow_constructible_v), ""); +#endif } template void test_is_nothrow_constructible() { static_assert(( std::is_nothrow_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_nothrow_constructible_v), ""); +#endif } template void test_is_not_nothrow_constructible() { static_assert((!std::is_nothrow_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_nothrow_constructible_v), ""); +#endif } template void test_is_not_nothrow_constructible() { static_assert((!std::is_nothrow_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_nothrow_constructible_v), ""); +#endif } template void test_is_not_nothrow_constructible() { static_assert((!std::is_nothrow_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_nothrow_constructible_v), ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp index d843803c..85e5e4f1 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_has_nothrow_assign() { static_assert( std::is_nothrow_copy_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_copy_assignable_v, ""); +#endif } template void test_has_not_nothrow_assign() { static_assert(!std::is_nothrow_copy_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_nothrow_copy_assignable_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp index 99fce65d..7070c59e 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp @@ -18,6 +18,10 @@ void test_is_nothrow_copy_constructible() { static_assert( std::is_nothrow_copy_constructible::value, ""); static_assert( std::is_nothrow_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_copy_constructible_v, ""); + static_assert( std::is_nothrow_copy_constructible_v, ""); +#endif } template @@ -27,6 +31,12 @@ void test_has_not_nothrow_copy_constructor() static_assert(!std::is_nothrow_copy_constructible::value, ""); static_assert(!std::is_nothrow_copy_constructible::value, ""); static_assert(!std::is_nothrow_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_nothrow_copy_constructible_v, ""); + static_assert(!std::is_nothrow_copy_constructible_v, ""); + static_assert(!std::is_nothrow_copy_constructible_v, ""); + static_assert(!std::is_nothrow_copy_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp index 1550dff0..e6612753 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp @@ -20,6 +20,12 @@ void test_is_nothrow_default_constructible() static_assert( std::is_nothrow_default_constructible::value, ""); static_assert( std::is_nothrow_default_constructible::value, ""); static_assert( std::is_nothrow_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_default_constructible_v, ""); + static_assert( std::is_nothrow_default_constructible_v, ""); + static_assert( std::is_nothrow_default_constructible_v, ""); + static_assert( std::is_nothrow_default_constructible_v, ""); +#endif } template @@ -29,6 +35,12 @@ void test_has_not_nothrow_default_constructor() static_assert(!std::is_nothrow_default_constructible::value, ""); static_assert(!std::is_nothrow_default_constructible::value, ""); static_assert(!std::is_nothrow_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_nothrow_default_constructible_v, ""); + static_assert(!std::is_nothrow_default_constructible_v, ""); + static_assert(!std::is_nothrow_default_constructible_v, ""); + static_assert(!std::is_nothrow_default_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp index 5827c927..6f96d732 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp @@ -22,6 +22,12 @@ void test_is_nothrow_destructible() static_assert( std::is_nothrow_destructible::value, ""); static_assert( std::is_nothrow_destructible::value, ""); static_assert( std::is_nothrow_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_destructible_v, ""); + static_assert( std::is_nothrow_destructible_v, ""); + static_assert( std::is_nothrow_destructible_v, ""); + static_assert( std::is_nothrow_destructible_v, ""); +#endif } template @@ -31,6 +37,12 @@ void test_is_not_nothrow_destructible() static_assert(!std::is_nothrow_destructible::value, ""); static_assert(!std::is_nothrow_destructible::value, ""); static_assert(!std::is_nothrow_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_nothrow_destructible_v, ""); + static_assert(!std::is_nothrow_destructible_v, ""); + static_assert(!std::is_nothrow_destructible_v, ""); + static_assert(!std::is_nothrow_destructible_v, ""); +#endif } diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp index fe51e438..ee0ba7d5 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_has_nothrow_assign() { static_assert( std::is_nothrow_move_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_move_assignable_v, ""); +#endif } template void test_has_not_nothrow_assign() { static_assert(!std::is_nothrow_move_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_move_assignable_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp index f5a42afe..3686af72 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp @@ -18,6 +18,10 @@ void test_is_nothrow_move_constructible() { static_assert( std::is_nothrow_move_constructible::value, ""); static_assert( std::is_nothrow_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_nothrow_move_constructible_v, ""); + static_assert( std::is_nothrow_move_constructible_v, ""); +#endif } template @@ -27,6 +31,12 @@ void test_has_not_nothrow_move_constructor() static_assert(!std::is_nothrow_move_constructible::value, ""); static_assert(!std::is_nothrow_move_constructible::value, ""); static_assert(!std::is_nothrow_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_nothrow_move_constructible_v, ""); + static_assert(!std::is_nothrow_move_constructible_v, ""); + static_assert(!std::is_nothrow_move_constructible_v, ""); + static_assert(!std::is_nothrow_move_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp index 735d05fa..3b89cf89 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_is_trivially_assignable() { static_assert(( std::is_trivially_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_trivially_assignable_v), ""); +#endif } template void test_is_not_trivially_assignable() { static_assert((!std::is_trivially_assignable::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_trivially_assignable_v), ""); +#endif } struct A diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp index 4171d4d3..b15ae744 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp @@ -18,30 +18,45 @@ template void test_is_trivially_constructible() { static_assert(( std::is_trivially_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_trivially_constructible_v), ""); +#endif } template void test_is_trivially_constructible() { static_assert(( std::is_trivially_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert(( std::is_trivially_constructible_v), ""); +#endif } template void test_is_not_trivially_constructible() { static_assert((!std::is_trivially_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_trivially_constructible_v), ""); +#endif } template void test_is_not_trivially_constructible() { static_assert((!std::is_trivially_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_trivially_constructible_v), ""); +#endif } template void test_is_not_trivially_constructible() { static_assert((!std::is_trivially_constructible::value), ""); +#if TEST_STD_VER > 14 + static_assert((!std::is_trivially_constructible_v), ""); +#endif } struct A diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp index 7d72565e..a7487b23 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_has_trivially_copy_assignable() { static_assert( std::is_trivially_copy_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_copy_assignable_v, ""); +#endif } template void test_has_not_trivially_copy_assignable() { static_assert(!std::is_trivially_copy_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_copy_assignable_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp index 6bd78ec9..53259f82 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp @@ -18,6 +18,10 @@ void test_is_trivially_copy_constructible() { static_assert( std::is_trivially_copy_constructible::value, ""); static_assert( std::is_trivially_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_copy_constructible_v, ""); + static_assert( std::is_trivially_copy_constructible_v, ""); +#endif } template @@ -25,6 +29,10 @@ void test_has_not_trivial_copy_constructor() { static_assert(!std::is_trivially_copy_constructible::value, ""); static_assert(!std::is_trivially_copy_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_copy_constructible_v, ""); + static_assert(!std::is_trivially_copy_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp index 1f63401d..5d379e47 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp @@ -20,6 +20,12 @@ void test_is_trivially_default_constructible() static_assert( std::is_trivially_default_constructible::value, ""); static_assert( std::is_trivially_default_constructible::value, ""); static_assert( std::is_trivially_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_default_constructible_v, ""); + static_assert( std::is_trivially_default_constructible_v, ""); + static_assert( std::is_trivially_default_constructible_v, ""); + static_assert( std::is_trivially_default_constructible_v, ""); +#endif } template @@ -29,6 +35,12 @@ void test_has_not_trivial_default_constructor() static_assert(!std::is_trivially_default_constructible::value, ""); static_assert(!std::is_trivially_default_constructible::value, ""); static_assert(!std::is_trivially_default_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_default_constructible_v, ""); + static_assert(!std::is_trivially_default_constructible_v, ""); + static_assert(!std::is_trivially_default_constructible_v, ""); + static_assert(!std::is_trivially_default_constructible_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp index 0908f8b2..a0c09d22 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp @@ -22,6 +22,12 @@ void test_is_trivially_destructible() static_assert( std::is_trivially_destructible::value, ""); static_assert( std::is_trivially_destructible::value, ""); static_assert( std::is_trivially_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_destructible_v, ""); + static_assert( std::is_trivially_destructible_v, ""); + static_assert( std::is_trivially_destructible_v, ""); + static_assert( std::is_trivially_destructible_v, ""); +#endif } template @@ -31,6 +37,12 @@ void test_is_not_trivially_destructible() static_assert(!std::is_trivially_destructible::value, ""); static_assert(!std::is_trivially_destructible::value, ""); static_assert(!std::is_trivially_destructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_destructible_v, ""); + static_assert(!std::is_trivially_destructible_v, ""); + static_assert(!std::is_trivially_destructible_v, ""); + static_assert(!std::is_trivially_destructible_v, ""); +#endif } struct PublicDestructor { public: ~PublicDestructor() {}}; diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp index c3fc7ac0..8f00da99 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp @@ -17,12 +17,18 @@ template void test_has_trivial_assign() { static_assert( std::is_trivially_move_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_move_assignable_v, ""); +#endif } template void test_has_not_trivial_assign() { static_assert(!std::is_trivially_move_assignable::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_move_assignable_v, ""); +#endif } class Empty diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp index 54cb5e85..477085dc 100644 --- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp +++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp @@ -17,12 +17,18 @@ template void test_is_trivially_move_constructible() { static_assert( std::is_trivially_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert( std::is_trivially_move_constructible_v, ""); +#endif } template void test_has_not_trivial_move_constructor() { static_assert(!std::is_trivially_move_constructible::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_trivially_move_constructible_v, ""); +#endif } class Empty