generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move test into test/std subdirectory.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2014-12-20 01:40:03 +00:00
parent 669a8a5a19
commit a90c6dd460
4817 changed files with 13 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp Normal file
View File

@@ -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()
{
}

65
test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp Normal file
View File

@@ -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 */

181
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp Normal file
View File

@@ -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 */

102
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp Normal file
View File

@@ -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 */

489
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp Normal file
View File

@@ -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 */

66
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp Normal file
View File

@@ -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 */

20
test/std/experimental/utilities/meta/version.pass.cpp Normal file
View File

@@ -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()
{
}