From 12c6d9cd9354ec1e3aa92aa07d76416bda96f8fd Mon Sep 17 00:00:00 2001 From: Eric Fiselier Date: Sat, 18 Jul 2015 16:43:58 +0000 Subject: [PATCH] [libcxx] Get is_*_destructible tests passing in C++03. Summary: This patch adds proper guards to the is_destructible tests depending on the standard version so that they pass in c++03. Reviewers: mclow.lists, EricWF Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10047 git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@242612 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/type_traits | 7 +++ .../meta.unary.prop/is_destructible.pass.cpp | 16 +++-- .../is_nothrow_destructible.pass.cpp | 59 +++++++++++-------- .../is_trivially_destructible.pass.cpp | 36 ++++++++--- 4 files changed, 80 insertions(+), 38 deletions(-) diff --git a/include/type_traits b/include/type_traits index 3c773ba7..6b5e03f6 100644 --- a/include/type_traits +++ b/include/type_traits @@ -2917,6 +2917,9 @@ template struct __libcpp_trivial_destructor template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible : public __libcpp_trivial_destructor::type> {}; +template struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible<_Tp[]> + : public false_type {}; + #endif // is_nothrow_constructible @@ -3241,6 +3244,10 @@ template struct __libcpp_nothrow_destructor template struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible : public __libcpp_nothrow_destructor::type> {}; +template +struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[]> + : public false_type {}; + #endif // is_pod 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 807745ef..fae9557d 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 @@ -13,6 +13,8 @@ #include +#include "test_macros.h" + template void test_is_destructible() { @@ -68,6 +70,7 @@ struct PurePublicDestructor { public: virtual ~PurePublicDestruc struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; +#if TEST_STD_VER >= 11 struct DeletedPublicDestructor { public: ~DeletedPublicDestructor() = delete; }; struct DeletedProtectedDestructor { protected: ~DeletedProtectedDestructor() = delete; }; struct DeletedPrivateDestructor { private: ~DeletedPrivateDestructor() = delete; }; @@ -75,6 +78,7 @@ struct DeletedPrivateDestructor { private: ~DeletedPrivateDestructor( struct DeletedVirtualPublicDestructor { public: virtual ~DeletedVirtualPublicDestructor() = delete; }; struct DeletedVirtualProtectedDestructor { protected: virtual ~DeletedVirtualProtectedDestructor() = delete; }; struct DeletedVirtualPrivateDestructor { private: virtual ~DeletedVirtualPrivateDestructor() = delete; }; +#endif int main() @@ -99,23 +103,27 @@ int main() test_is_not_destructible(); test_is_not_destructible(); + test_is_not_destructible(); +#if TEST_STD_VER >= 11 + // Test access controlled destructors test_is_not_destructible(); test_is_not_destructible(); test_is_not_destructible(); test_is_not_destructible(); test_is_not_destructible(); test_is_not_destructible(); + + // Test deleted constructors test_is_not_destructible(); test_is_not_destructible(); test_is_not_destructible(); - -// test_is_not_destructible(); // currently fails due to clang bug #20268 + //test_is_not_destructible(); // previously failed due to clang bug #20268 test_is_not_destructible(); test_is_not_destructible(); -#if __has_feature(cxx_access_control_sfinae) + // Test private destructors test_is_not_destructible(); #endif - test_is_not_destructible(); + } 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 8fd5bab5..5827c927 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 @@ -13,6 +13,8 @@ #include +#include "test_macros.h" + template void test_is_nothrow_destructible() { @@ -31,14 +33,23 @@ void test_is_not_nothrow_destructible() static_assert(!std::is_nothrow_destructible::value, ""); } + +struct PublicDestructor { public: ~PublicDestructor() {}}; +struct ProtectedDestructor { protected: ~ProtectedDestructor() {}}; +struct PrivateDestructor { private: ~PrivateDestructor() {}}; + +struct VirtualPublicDestructor { public: virtual ~VirtualPublicDestructor() {}}; +struct VirtualProtectedDestructor { protected: virtual ~VirtualProtectedDestructor() {}}; +struct VirtualPrivateDestructor { private: virtual ~VirtualPrivateDestructor() {}}; + +struct PurePublicDestructor { public: virtual ~PurePublicDestructor() = 0; }; +struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; +struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; + class Empty { }; -class NotEmpty -{ - virtual ~NotEmpty(); -}; union Union {}; @@ -52,40 +63,36 @@ class Abstract virtual void foo() = 0; }; -class AbstractDestructor -{ - virtual ~AbstractDestructor() = 0; -}; - -struct A -{ - ~A(); -}; int main() { test_is_not_nothrow_destructible(); - test_is_not_nothrow_destructible(); - test_is_not_nothrow_destructible(); test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); -#if __has_feature(cxx_noexcept) - test_is_nothrow_destructible(); -#endif test_is_nothrow_destructible(); -#if __has_feature(cxx_unrestricted_unions) - test_is_nothrow_destructible(); -#endif -#if __has_feature(cxx_access_control_sfinae) - test_is_nothrow_destructible(); -#endif test_is_nothrow_destructible(); test_is_nothrow_destructible(); test_is_nothrow_destructible(); test_is_nothrow_destructible(); test_is_nothrow_destructible(); - test_is_nothrow_destructible(); -#if __has_feature(cxx_noexcept) + +#if TEST_STD_VER >= 11 + // requires noexcept. These are all destructible. + test_is_nothrow_destructible(); + test_is_nothrow_destructible(); + test_is_nothrow_destructible(); test_is_nothrow_destructible(); + test_is_nothrow_destructible(); + test_is_nothrow_destructible(); + test_is_nothrow_destructible(); + + // requires access control + test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); + test_is_not_nothrow_destructible(); #endif } 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 b18ace44..0908f8b2 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 @@ -13,6 +13,8 @@ #include +#include "test_macros.h" + template void test_is_trivially_destructible() { @@ -31,15 +33,23 @@ void test_is_not_trivially_destructible() static_assert(!std::is_trivially_destructible::value, ""); } +struct PublicDestructor { public: ~PublicDestructor() {}}; +struct ProtectedDestructor { protected: ~ProtectedDestructor() {}}; +struct PrivateDestructor { private: ~PrivateDestructor() {}}; + +struct VirtualPublicDestructor { public: virtual ~VirtualPublicDestructor() {}}; +struct VirtualProtectedDestructor { protected: virtual ~VirtualProtectedDestructor() {}}; +struct VirtualPrivateDestructor { private: virtual ~VirtualPrivateDestructor() {}}; + +struct PurePublicDestructor { public: virtual ~PurePublicDestructor() = 0; }; +struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; +struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; + + class Empty { }; -class NotEmpty -{ - virtual ~NotEmpty(); -}; - union Union {}; struct bit_zero @@ -66,18 +76,28 @@ int main() { test_is_not_trivially_destructible(); test_is_not_trivially_destructible(); - test_is_not_trivially_destructible(); - test_is_not_trivially_destructible(); test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); test_is_trivially_destructible(); - test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); + test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); test_is_trivially_destructible(); + +#if TEST_STD_VER >= 11 + // requires access control sfinae + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); + test_is_not_trivially_destructible(); +#endif }