Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / third_party / libc++ / trunk / test / utilities / meta / meta.unary / meta.unary.prop / is_destructible.pass.cpp

diff --git a/src/third_party/libc++/trunk/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/src/third_party/libc++/trunk/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 5cabb38..807745e 100644 (file)
--- a/src/third_party/libc++/trunk/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/src/third_party/libc++/trunk/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -31,9 +31,7 @@ void test_is_not_destructible()
     static_assert(!std::is_destructible<const volatile T>::value, "");
 }
 
-class Empty
-{
-};
+class Empty {};
 
 class NotEmpty
 {
@@ -47,11 +45,6 @@ struct bit_zero
     int :  0;
 };
 
-class Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
 struct A
 {
     ~A();
@@ -59,6 +52,31 @@ struct A
 
 typedef void (Function) ();
 
+struct PublicAbstract                    { public:    virtual void foo() = 0; };
+struct ProtectedAbstract                 { protected: virtual void foo() = 0; };
+struct PrivateAbstract                   { private:   virtual void foo() = 0; };
+
+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; };
+
+struct DeletedPublicDestructor           { public:    ~DeletedPublicDestructor() = delete; };
+struct DeletedProtectedDestructor        { protected: ~DeletedProtectedDestructor() = delete; };
+struct DeletedPrivateDestructor          { private:   ~DeletedPrivateDestructor() = delete; };
+
+struct DeletedVirtualPublicDestructor    { public:    virtual ~DeletedVirtualPublicDestructor() = delete; };
+struct DeletedVirtualProtectedDestructor { protected: virtual ~DeletedVirtualProtectedDestructor() = delete; };
+struct DeletedVirtualPrivateDestructor   { private:   virtual ~DeletedVirtualPrivateDestructor() = delete; };
+
+
 int main()
 {
     test_is_destructible<A>();
@@ -72,10 +90,30 @@ int main()
     test_is_destructible<char[3]>();
     test_is_destructible<bit_zero>();
     test_is_destructible<int[3]>();
+    test_is_destructible<ProtectedAbstract>();
+    test_is_destructible<PublicAbstract>();
+    test_is_destructible<PrivateAbstract>();
+    test_is_destructible<PublicDestructor>();
+    test_is_destructible<VirtualPublicDestructor>();
+    test_is_destructible<PurePublicDestructor>();
 
     test_is_not_destructible<int[]>();
     test_is_not_destructible<void>();
-    test_is_not_destructible<Abstract>();
+
+    test_is_not_destructible<ProtectedDestructor>();
+    test_is_not_destructible<PrivateDestructor>();
+    test_is_not_destructible<VirtualProtectedDestructor>();
+    test_is_not_destructible<VirtualPrivateDestructor>();
+    test_is_not_destructible<PureProtectedDestructor>();
+    test_is_not_destructible<PurePrivateDestructor>();
+    test_is_not_destructible<DeletedPublicDestructor>();
+    test_is_not_destructible<DeletedProtectedDestructor>();
+    test_is_not_destructible<DeletedPrivateDestructor>();
+
+//     test_is_not_destructible<DeletedVirtualPublicDestructor>(); // currently fails due to clang bug #20268
+    test_is_not_destructible<DeletedVirtualProtectedDestructor>();
+    test_is_not_destructible<DeletedVirtualPrivateDestructor>();
+
 #if __has_feature(cxx_access_control_sfinae) 
     test_is_not_destructible<NotEmpty>();
 #endif