From 5a83710e371fe68a06e6e3876c6a2c8b820a8976 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 20 Dec 2014 01:40:03 +0000
Subject: Move test into test/std subdirectory.

llvm-svn: 224658
---
 .../meta/meta.type.synop/includes.pass.cpp         |  22 +
 .../meta/meta.type.synop/meta.rel.pass.cpp         |  65 +++
 .../meta/meta.type.synop/meta.unary.cat.pass.cpp   | 181 ++++++++
 .../meta/meta.type.synop/meta.unary.comp.pass.cpp  | 102 +++++
 .../meta/meta.type.synop/meta.unary.prop.pass.cpp  | 489 +++++++++++++++++++++
 .../meta.type.synop/meta.unary.prop.query.pass.cpp |  66 +++
 .../experimental/utilities/meta/version.pass.cpp   |  20 +
 .../experimental/utilities/nothing_to_do.pass.cpp  |  13 +
 .../utility.erased.type/erased_type.pass.cpp       |  17 +
 .../utility/utility.synop/includes.pass.cpp        |  20 +
 .../utilities/utility/version.pass.cpp             |  20 +
 11 files changed, 1015 insertions(+)
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/meta/version.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/nothing_to_do.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
 create mode 100644 libcxx/test/std/experimental/utilities/utility/version.pass.cpp

(limited to 'libcxx/test/std/experimental/utilities')

diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
new file mode 100644
index 00000000000..2c90dd64181
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+# ifndef _LIBCPP_TYPE_TRAITS
+#   error "<experimental/type_traits> must include <type_traits>"
+# endif
+#endif
+
+int main()
+{
+}
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
new file mode 100644
index 00000000000..96af4b67618
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+
+namespace ex = std::experimental;
+
+struct base_type {};
+struct derived_type : base_type {};
+
+int main()
+{
+    {
+        typedef int T;
+        typedef int U;
+        static_assert(ex::is_same_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_same_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        typedef long U;
+        static_assert(!ex::is_same_v<T, U>, "");
+        static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
+    }
+    {
+        typedef base_type T;
+        typedef derived_type U;
+        static_assert(ex::is_base_of_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_base_of_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        typedef int U;
+        static_assert(!ex::is_base_of_v<T, U>, "");
+        static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        typedef long U;
+        static_assert(ex::is_convertible_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_convertible_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
+    }
+    {
+        typedef void T;
+        typedef int U;
+        static_assert(!ex::is_convertible_v<T, U>, "");
+        static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
+    }
+}
+#else /* _LIBCPP_STD_VER <= 11 */
+int main() {}
+#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
new file mode 100644
index 00000000000..2d1e706f67d
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
@@ -0,0 +1,181 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+
+namespace ex = std::experimental;
+
+struct class_type {};
+enum enum_type {};
+union union_type {};
+
+int main()
+{
+    {
+        typedef void T;
+        static_assert(ex::is_void_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_void_v<T>), const bool>::value, "");
+        static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_void_v<T>, "");
+        static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
+    }
+    {
+        typedef decltype(nullptr) T;
+        static_assert(ex::is_null_pointer_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_null_pointer_v<T>), const bool>::value, "");
+        static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_null_pointer_v<T>, "");
+        static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_integral_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_integral_v<T>), const bool>::value, "");
+        static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_integral_v<T>, "");
+        static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
+    }
+    {
+        typedef float T;
+        static_assert(ex::is_floating_point_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_floating_point_v<T>), const bool>::value, "");
+        static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_floating_point_v<T>, "");
+        static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
+    }
+    {
+        typedef int(T)[42];
+        static_assert(ex::is_array_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_array_v<T>), const bool>::value, "");
+        static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_array_v<T>, "");
+        static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
+    }
+    {
+        typedef void* T;
+        static_assert(ex::is_pointer_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_pointer_v<T>), const bool>::value, "");
+        static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_pointer_v<T>, "");
+        static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(ex::is_lvalue_reference_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_lvalue_reference_v<T>), const bool>::value, "");
+        static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_lvalue_reference_v<T>, "");
+        static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
+    }
+    {
+        typedef int && T;
+        static_assert(ex::is_rvalue_reference_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_rvalue_reference_v<T>), const bool>::value, "");
+        static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_rvalue_reference_v<T>, "");
+        static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
+    }
+    {
+        typedef int class_type::*T;
+        static_assert(ex::is_member_object_pointer_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_member_object_pointer_v<T>), const bool>::value, "");
+        static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_member_object_pointer_v<T>, "");
+        static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
+    }
+    {
+        typedef void(class_type::*T)();
+        static_assert(ex::is_member_function_pointer_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_member_function_pointer_v<T>), const bool>::value, "");
+        static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_member_function_pointer_v<T>, "");
+        static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
+    }
+    {
+        typedef enum_type T;
+        static_assert(ex::is_enum_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_enum_v<T>), const bool>::value, "");
+        static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_enum_v<T>, "");
+        static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
+    }
+    {
+        typedef union_type T;
+        static_assert(ex::is_union_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_union_v<T>), const bool>::value, "");
+        static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_union_v<T>, "");
+        static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
+    }
+    {
+        typedef class_type T;
+        static_assert(ex::is_class_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_class_v<T>), const bool>::value, "");
+        static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_class_v<T>, "");
+        static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
+    }
+    {
+        typedef void(T)();
+        static_assert(ex::is_function_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_function_v<T>), const bool>::value, "");
+        static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_function_v<T>, "");
+        static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
+    }
+}
+#else /* _LIBCPP_STD_VER <= 11 */
+int main() {}
+#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
new file mode 100644
index 00000000000..814f450f4e0
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+
+namespace ex = std::experimental;
+
+struct class_type {};
+
+int main()
+{
+    {
+        typedef int & T;
+        static_assert(ex::is_reference_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_reference_v<T>), const bool>::value, "");
+        static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_reference_v<T>, "");
+        static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_arithmetic_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_arithmetic_v<T>), const bool>::value, "");
+        static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
+    }
+    {
+        typedef void* T;
+        static_assert(!ex::is_arithmetic_v<T>, "");
+        static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_fundamental_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_fundamental_v<T>), const bool>::value, "");
+        static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
+    }
+    {
+        typedef class_type T;
+        static_assert(!ex::is_fundamental_v<T>, "");
+        static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
+    }
+    {
+        typedef class_type T;
+        static_assert(ex::is_object_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_object_v<T>), const bool>::value, "");
+        static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_object_v<T>, "");
+        static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_scalar_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_scalar_v<T>), const bool>::value, "");
+        static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_scalar_v<T>, "");
+        static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
+    }
+    {
+        typedef void* T;
+        static_assert(ex::is_compound_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_compound_v<T>), const bool>::value, "");
+        static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_compound_v<T>, "");
+        static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
+    }
+    {
+        typedef int class_type::*T;
+        static_assert(ex::is_member_pointer_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_member_pointer_v<T>), const bool>::value, "");
+        static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_member_pointer_v<T>, "");
+        static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
+    }
+}
+#else /* _LIBCPP_STD_VER <= 11 */
+int main() {}
+#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
new file mode 100644
index 00000000000..41cb27fced3
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
@@ -0,0 +1,489 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+
+namespace ex = std::experimental;
+
+struct non_literal_type { non_literal_type() {} };
+struct empty_type {};
+
+struct polymorphic_type
+{
+    virtual void foo() {}
+};
+
+struct abstract_type
+{
+    virtual void foo() = 0;
+};
+
+struct final_type final {};
+
+struct virtual_dtor_type
+{
+    virtual ~virtual_dtor_type() {}
+};
+
+void type_properties_test()
+{
+    {
+        typedef const int T;
+        static_assert(ex::is_const_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_const_v<T>), const bool>::value, "");
+        static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_const_v<T>, "");
+        static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
+    }
+    {
+        typedef volatile int T;
+        static_assert(ex::is_volatile_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_volatile_v<T>), const bool>::value, "");
+        static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_volatile_v<T>, "");
+        static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivial_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivial_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_trivial_v<T>, "");
+        static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_copyable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_copyable_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_trivially_copyable_v<T>, "");
+        static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_standard_layout_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_standard_layout_v<T>), const bool>::value, "");
+        static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_standard_layout_v<T>, "");
+        static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_pod_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_pod_v<T>), const bool>::value, "");
+        static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_pod_v<T>, "");
+        static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_literal_type_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_literal_type_v<T>), const bool>::value, "");
+        static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
+    }
+    {
+        typedef non_literal_type T;
+        static_assert(!ex::is_literal_type_v<T>, "");
+        static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
+    }
+    {
+        typedef empty_type T;
+        static_assert(ex::is_empty_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_empty_v<T>), const bool>::value, "");
+        static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_empty_v<T>, "");
+        static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
+    }
+    {
+        typedef polymorphic_type T;
+        static_assert(ex::is_polymorphic_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_polymorphic_v<T>), const bool>::value, "");
+        static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_polymorphic_v<T>, "");
+        static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
+    }
+    {
+        typedef abstract_type T;
+        static_assert(ex::is_abstract_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_abstract_v<T>), const bool>::value, "");
+        static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_abstract_v<T>, "");
+        static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
+    }
+    {
+        typedef final_type T;
+        static_assert(ex::is_final_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_final_v<T>), const bool>::value, "");
+        static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_final_v<T>, "");
+        static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_signed_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_signed_v<T>), const bool>::value, "");
+        static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
+    }
+    {
+        typedef unsigned T;
+        static_assert(!ex::is_signed_v<T>, "");
+        static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
+    }
+    {
+        typedef unsigned T;
+        static_assert(ex::is_unsigned_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_unsigned_v<T>), const bool>::value, "");
+        static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::is_unsigned_v<T>, "");
+        static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
+    }
+}
+
+void is_constructible_and_assignable_test()
+{
+    {
+        typedef int T;
+        static_assert(ex::is_constructible_v<T, int>, "");
+        static_assert(std::is_same<decltype(ex::is_constructible_v<T, int>), const bool>::value, "");
+        static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_constructible_v<T, int>, "");
+        static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_default_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_default_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_default_constructible_v<T>, "");
+        static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_copy_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_copy_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_copy_constructible_v<T>, "");
+        static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_move_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_move_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_move_constructible_v<T>, "");
+        static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef int U;
+        static_assert(ex::is_assignable_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_assignable_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef void U;
+        static_assert(!ex::is_assignable_v<T, U>, "");
+        static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_copy_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_copy_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_copy_assignable_v<T>, "");
+        static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_move_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_move_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_move_assignable_v<T>, "");
+        static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_destructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_destructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_destructible_v<T>, "");
+        static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+}
+
+void is_trivially_constructible_and_assignable_test()
+{
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_constructible_v<T, int>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_constructible_v<T, int>), const bool>::value, "");
+        static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_constructible_v<T, int>, "");
+        static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_default_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_default_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_trivially_default_constructible_v<T>, "");
+        static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_copy_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_copy_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_copy_constructible_v<T>, "");
+        static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_move_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_move_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_move_constructible_v<T>, "");
+        static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef int U;
+        static_assert(ex::is_trivially_assignable_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_assignable_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef void U;
+        static_assert(!ex::is_trivially_assignable_v<T, U>, "");
+        static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_copy_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_copy_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_copy_assignable_v<T>, "");
+        static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_move_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_move_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_move_assignable_v<T>, "");
+        static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_trivially_destructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_trivially_destructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_trivially_destructible_v<T>, "");
+        static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+}
+
+
+
+void is_nothrow_constructible_and_assignable_test()
+{
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_constructible_v<T, int>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_constructible_v<T, int>), const bool>::value, "");
+        static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_constructible_v<T, int>, "");
+        static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_default_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_default_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        static_assert(!ex::is_nothrow_default_constructible_v<T>, "");
+        static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_copy_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_copy_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_copy_constructible_v<T>, "");
+        static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_move_constructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_move_constructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_move_constructible_v<T>, "");
+        static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef int U;
+        static_assert(ex::is_nothrow_assignable_v<T, U>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_assignable_v<T, U>), const bool>::value, "");
+        static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int & T;
+        typedef void U;
+        static_assert(!ex::is_nothrow_assignable_v<T, U>, "");
+        static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_copy_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_copy_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_copy_assignable_v<T>, "");
+        static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_move_assignable_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_move_assignable_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_move_assignable_v<T>, "");
+        static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(ex::is_nothrow_destructible_v<T>, "");
+        static_assert(std::is_same<decltype(ex::is_nothrow_destructible_v<T>), const bool>::value, "");
+        static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(!ex::is_nothrow_destructible_v<T>, "");
+        static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
+    }
+}
+
+int main()
+{
+    type_properties_test();
+    is_constructible_and_assignable_test();
+    is_trivially_constructible_and_assignable_test();
+    is_nothrow_constructible_and_assignable_test();
+    {
+        typedef virtual_dtor_type T;
+        static_assert(ex::has_virtual_destructor_v<T>, "");
+        static_assert(std::is_same<decltype(ex::has_virtual_destructor_v<T>), const bool>::value, "");
+        static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
+    }
+    {
+        typedef int T;
+        static_assert(!ex::has_virtual_destructor_v<T>, "");
+        static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
+    }
+}
+#else /* _LIBCPP_STD_VER <= 11 */
+int main() {}
+#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
new file mode 100644
index 00000000000..aedd369e5ac
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#if _LIBCPP_STD_VER > 11
+
+namespace ex = std::experimental;
+
+int main()
+{
+    {
+        typedef char T;
+        static_assert(ex::alignment_of_v<T> == 1, "");
+        static_assert(std::is_same<decltype(ex::alignment_of_v<T>), const std::size_t>::value, "");
+        static_assert(ex::alignment_of_v<T> == std::alignment_of<T>::value, "");
+    }
+    {
+        typedef char(T)[1][1][1];
+        static_assert(ex::rank_v<T> == 3, "");
+        static_assert(std::is_same<decltype(ex::rank_v<T>), const std::size_t>::value, "");
+        static_assert(ex::rank_v<T> == std::rank<T>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(ex::rank_v<T> == 0, "");
+        static_assert(ex::rank_v<T> == std::rank<T>::value, "");
+    }
+    {
+        typedef char(T)[2][3][4];
+        static_assert(ex::extent_v<T> == 2, "");
+        static_assert(std::is_same<decltype(ex::extent_v<T>), const std::size_t>::value, "");
+        static_assert(ex::extent_v<T> == std::extent<T>::value, "");
+    }
+    {
+        typedef char(T)[2][3][4];
+        static_assert(ex::extent_v<T, 0> == 2, "");
+        static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
+    }
+    {
+        typedef char(T)[2][3][4];
+        static_assert(ex::extent_v<T, 1> == 3, "");
+        static_assert(ex::extent_v<T, 1> == std::extent<T, 1>::value, "");
+    }
+    {
+        typedef char(T)[2][3][4];
+        static_assert(ex::extent_v<T, 5> == 0, "");
+        static_assert(ex::extent_v<T, 5> == std::extent<T, 5>::value, "");
+    }
+    {
+        typedef void T;
+        static_assert(ex::extent_v<T, 0> == 0, "");
+        static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
+    }
+}
+#else /* _LIBCPP_STD_VER <= 11 */
+int main() {}
+#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/libcxx/test/std/experimental/utilities/meta/version.pass.cpp b/libcxx/test/std/experimental/utilities/meta/version.pass.cpp
new file mode 100644
index 00000000000..593fb52a4c3
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/meta/version.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/type_traits>
+
+#include <experimental/type_traits>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
diff --git a/libcxx/test/std/experimental/utilities/nothing_to_do.pass.cpp b/libcxx/test/std/experimental/utilities/nothing_to_do.pass.cpp
new file mode 100644
index 00000000000..9a59227abdd
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/nothing_to_do.pass.cpp
@@ -0,0 +1,13 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/libcxx/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp b/libcxx/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
new file mode 100644
index 00000000000..3e38d5ec503
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/utility>
+
+#include <experimental/utility>
+
+int main()
+{
+    std::experimental::erased_type e();
+}
diff --git a/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
new file mode 100644
index 00000000000..2583d434540
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/utility>
+
+#include <experimental/utility>
+
+#ifndef _LIBCPP_UTILITY
+#   error "<experimental/utility> must include <utility>"
+#endif
+
+int main()
+{
+}
diff --git a/libcxx/test/std/experimental/utilities/utility/version.pass.cpp b/libcxx/test/std/experimental/utilities/utility/version.pass.cpp
new file mode 100644
index 00000000000..437712454ae
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/utility/version.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/utility>
+
+#include <experimental/utility>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
-- 
cgit v1.2.3