Move test into test/std subdirectory.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
47
test/std/utilities/meta/meta.hel/integral_constant.pass.cpp
Normal file
47
test/std/utilities/meta/meta.hel/integral_constant.pass.cpp
Normal file
@@ -0,0 +1,47 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// integral_constant
|
||||
|
||||
#include <type_traits>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
typedef std::integral_constant<int, 5> _5;
|
||||
static_assert(_5::value == 5, "");
|
||||
static_assert((std::is_same<_5::value_type, int>::value), "");
|
||||
static_assert((std::is_same<_5::type, _5>::value), "");
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
static_assert((_5() == 5), "");
|
||||
#else
|
||||
assert(_5() == 5);
|
||||
#endif
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert ( _5{}() == 5, "" );
|
||||
static_assert ( std::true_type{}(), "" );
|
||||
#endif
|
||||
|
||||
static_assert(std::false_type::value == false, "");
|
||||
static_assert((std::is_same<std::false_type::value_type, bool>::value), "");
|
||||
static_assert((std::is_same<std::false_type::type, std::false_type>::value), "");
|
||||
|
||||
static_assert(std::true_type::value == true, "");
|
||||
static_assert((std::is_same<std::true_type::value_type, bool>::value), "");
|
||||
static_assert((std::is_same<std::true_type::type, std::true_type>::value), "");
|
||||
|
||||
std::false_type f1;
|
||||
std::false_type f2 = f1;
|
||||
|
||||
std::true_type t1;
|
||||
std::true_type t2 = t1;
|
||||
}
|
49
test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
Normal file
49
test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
Normal file
@@ -0,0 +1,49 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_base_of
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_base_of()
|
||||
{
|
||||
static_assert((std::is_base_of<T, U>::value), "");
|
||||
static_assert((std::is_base_of<const T, U>::value), "");
|
||||
static_assert((std::is_base_of<T, const U>::value), "");
|
||||
static_assert((std::is_base_of<const T, const U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_base_of()
|
||||
{
|
||||
static_assert((!std::is_base_of<T, U>::value), "");
|
||||
}
|
||||
|
||||
struct B {};
|
||||
struct B1 : B {};
|
||||
struct B2 : B {};
|
||||
struct D : private B1, private B2 {};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_base_of<B, D>();
|
||||
test_is_base_of<B1, D>();
|
||||
test_is_base_of<B2, D>();
|
||||
test_is_base_of<B, B1>();
|
||||
test_is_base_of<B, B2>();
|
||||
test_is_base_of<B, B>();
|
||||
|
||||
test_is_not_base_of<D, B>();
|
||||
test_is_not_base_of<B&, D&>();
|
||||
test_is_not_base_of<B[3], D[3]>();
|
||||
test_is_not_base_of<int, int>();
|
||||
}
|
189
test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
Normal file
189
test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
Normal file
@@ -0,0 +1,189 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_convertible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_convertible()
|
||||
{
|
||||
static_assert((std::is_convertible<T, U>::value), "");
|
||||
static_assert((std::is_convertible<const T, U>::value), "");
|
||||
static_assert((std::is_convertible<T, const U>::value), "");
|
||||
static_assert((std::is_convertible<const T, const U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_convertible()
|
||||
{
|
||||
static_assert((!std::is_convertible<T, U>::value), "");
|
||||
static_assert((!std::is_convertible<const T, U>::value), "");
|
||||
static_assert((!std::is_convertible<T, const U>::value), "");
|
||||
static_assert((!std::is_convertible<const T, const U>::value), "");
|
||||
}
|
||||
|
||||
typedef void Function();
|
||||
typedef char Array[1];
|
||||
|
||||
class NonCopyable {
|
||||
NonCopyable(NonCopyable&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
// void
|
||||
test_is_convertible<void,void> ();
|
||||
test_is_not_convertible<void,Function> ();
|
||||
test_is_not_convertible<void,Function&> ();
|
||||
test_is_not_convertible<void,Function*> ();
|
||||
test_is_not_convertible<void,Array> ();
|
||||
test_is_not_convertible<void,Array&> ();
|
||||
test_is_not_convertible<void,char> ();
|
||||
test_is_not_convertible<void,char&> ();
|
||||
test_is_not_convertible<void,char*> ();
|
||||
|
||||
// Function
|
||||
test_is_not_convertible<Function, void> ();
|
||||
test_is_not_convertible<Function, Function> ();
|
||||
test_is_convertible<Function, Function&> ();
|
||||
test_is_convertible<Function, Function*> ();
|
||||
test_is_not_convertible<Function, Array> ();
|
||||
test_is_not_convertible<Function, Array&> ();
|
||||
test_is_not_convertible<Function, char> ();
|
||||
test_is_not_convertible<Function, char&> ();
|
||||
test_is_not_convertible<Function, char*> ();
|
||||
|
||||
// Function&
|
||||
test_is_not_convertible<Function&, void> ();
|
||||
test_is_not_convertible<Function&, Function> ();
|
||||
test_is_convertible<Function&, Function&> ();
|
||||
|
||||
test_is_convertible<Function&, Function*> ();
|
||||
test_is_not_convertible<Function&, Array> ();
|
||||
test_is_not_convertible<Function&, Array&> ();
|
||||
test_is_not_convertible<Function&, char> ();
|
||||
test_is_not_convertible<Function&, char&> ();
|
||||
test_is_not_convertible<Function&, char*> ();
|
||||
|
||||
// Function*
|
||||
test_is_not_convertible<Function*, void> ();
|
||||
test_is_not_convertible<Function*, Function> ();
|
||||
test_is_not_convertible<Function*, Function&> ();
|
||||
test_is_convertible<Function*, Function*> ();
|
||||
|
||||
test_is_not_convertible<Function*, Array> ();
|
||||
test_is_not_convertible<Function*, Array&> ();
|
||||
test_is_not_convertible<Function*, char> ();
|
||||
test_is_not_convertible<Function*, char&> ();
|
||||
test_is_not_convertible<Function*, char*> ();
|
||||
|
||||
// Array
|
||||
test_is_not_convertible<Array, void> ();
|
||||
test_is_not_convertible<Array, Function> ();
|
||||
test_is_not_convertible<Array, Function&> ();
|
||||
test_is_not_convertible<Array, Function*> ();
|
||||
test_is_not_convertible<Array, Array> ();
|
||||
|
||||
static_assert((!std::is_convertible<Array, Array&>::value), "");
|
||||
static_assert(( std::is_convertible<Array, const Array&>::value), "");
|
||||
static_assert((!std::is_convertible<const Array, Array&>::value), "");
|
||||
static_assert(( std::is_convertible<const Array, const Array&>::value), "");
|
||||
|
||||
test_is_not_convertible<Array, char> ();
|
||||
test_is_not_convertible<Array, char&> ();
|
||||
|
||||
static_assert(( std::is_convertible<Array, char*>::value), "");
|
||||
static_assert(( std::is_convertible<Array, const char*>::value), "");
|
||||
static_assert((!std::is_convertible<const Array, char*>::value), "");
|
||||
static_assert(( std::is_convertible<const Array, const char*>::value), "");
|
||||
|
||||
// Array&
|
||||
test_is_not_convertible<Array&, void> ();
|
||||
test_is_not_convertible<Array&, Function> ();
|
||||
test_is_not_convertible<Array&, Function&> ();
|
||||
test_is_not_convertible<Array&, Function*> ();
|
||||
test_is_not_convertible<Array&, Array> ();
|
||||
|
||||
static_assert(( std::is_convertible<Array&, Array&>::value), "");
|
||||
static_assert(( std::is_convertible<Array&, const Array&>::value), "");
|
||||
static_assert((!std::is_convertible<const Array&, Array&>::value), "");
|
||||
static_assert(( std::is_convertible<const Array&, const Array&>::value), "");
|
||||
|
||||
test_is_not_convertible<Array&, char> ();
|
||||
test_is_not_convertible<Array&, char&> ();
|
||||
|
||||
static_assert(( std::is_convertible<Array&, char*>::value), "");
|
||||
static_assert(( std::is_convertible<Array&, const char*>::value), "");
|
||||
static_assert((!std::is_convertible<const Array&, char*>::value), "");
|
||||
static_assert(( std::is_convertible<const Array&, const char*>::value), "");
|
||||
|
||||
// char
|
||||
test_is_not_convertible<char, void> ();
|
||||
test_is_not_convertible<char, Function> ();
|
||||
test_is_not_convertible<char, Function&> ();
|
||||
test_is_not_convertible<char, Function*> ();
|
||||
test_is_not_convertible<char, Array> ();
|
||||
test_is_not_convertible<char, Array&> ();
|
||||
|
||||
test_is_convertible<char, char> ();
|
||||
|
||||
static_assert((!std::is_convertible<char, char&>::value), "");
|
||||
static_assert(( std::is_convertible<char, const char&>::value), "");
|
||||
static_assert((!std::is_convertible<const char, char&>::value), "");
|
||||
static_assert(( std::is_convertible<const char, const char&>::value), "");
|
||||
|
||||
test_is_not_convertible<char, char*> ();
|
||||
|
||||
// char&
|
||||
test_is_not_convertible<char&, void> ();
|
||||
test_is_not_convertible<char&, Function> ();
|
||||
test_is_not_convertible<char&, Function&> ();
|
||||
test_is_not_convertible<char&, Function*> ();
|
||||
test_is_not_convertible<char&, Array> ();
|
||||
test_is_not_convertible<char&, Array&> ();
|
||||
|
||||
test_is_convertible<char&, char> ();
|
||||
|
||||
static_assert(( std::is_convertible<char&, char&>::value), "");
|
||||
static_assert(( std::is_convertible<char&, const char&>::value), "");
|
||||
static_assert((!std::is_convertible<const char&, char&>::value), "");
|
||||
static_assert(( std::is_convertible<const char&, const char&>::value), "");
|
||||
|
||||
test_is_not_convertible<char&, char*> ();
|
||||
|
||||
// char*
|
||||
test_is_not_convertible<char*, void> ();
|
||||
test_is_not_convertible<char*, Function> ();
|
||||
test_is_not_convertible<char*, Function&> ();
|
||||
test_is_not_convertible<char*, Function*> ();
|
||||
test_is_not_convertible<char*, Array> ();
|
||||
test_is_not_convertible<char*, Array&> ();
|
||||
|
||||
test_is_not_convertible<char*, char> ();
|
||||
test_is_not_convertible<char*, char&> ();
|
||||
|
||||
static_assert(( std::is_convertible<char*, char*>::value), "");
|
||||
static_assert(( std::is_convertible<char*, const char*>::value), "");
|
||||
static_assert((!std::is_convertible<const char*, char*>::value), "");
|
||||
static_assert(( std::is_convertible<const char*, const char*>::value), "");
|
||||
|
||||
// NonCopyable
|
||||
static_assert((std::is_convertible<NonCopyable&, NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<NonCopyable&, const NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<NonCopyable&, const volatile NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<NonCopyable&, volatile NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<const NonCopyable&, const NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<const NonCopyable&, const volatile NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value), "");
|
||||
static_assert((std::is_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value), "");
|
||||
static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), "");
|
||||
}
|
59
test/std/utilities/meta/meta.rel/is_same.pass.cpp
Normal file
59
test/std/utilities/meta/meta.rel/is_same.pass.cpp
Normal file
@@ -0,0 +1,59 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_same
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_same()
|
||||
{
|
||||
static_assert((std::is_same<T, U>::value), "");
|
||||
static_assert((!std::is_same<const T, U>::value), "");
|
||||
static_assert((!std::is_same<T, const U>::value), "");
|
||||
static_assert((std::is_same<const T, const U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_same_ref()
|
||||
{
|
||||
static_assert((std::is_same<T, U>::value), "");
|
||||
static_assert((std::is_same<const T, U>::value), "");
|
||||
static_assert((std::is_same<T, const U>::value), "");
|
||||
static_assert((std::is_same<const T, const U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_same()
|
||||
{
|
||||
static_assert((!std::is_same<T, U>::value), "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_same<int, int>();
|
||||
test_is_same<void, void>();
|
||||
test_is_same<Class, Class>();
|
||||
test_is_same<int*, int*>();
|
||||
test_is_same_ref<int&, int&>();
|
||||
|
||||
test_is_not_same<int, void>();
|
||||
test_is_not_same<void, Class>();
|
||||
test_is_not_same<Class, int*>();
|
||||
test_is_not_same<int*, int&>();
|
||||
test_is_not_same<int&, int>();
|
||||
}
|
12
test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
Normal file
12
test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
Normal file
@@ -0,0 +1,12 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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()
|
||||
{
|
||||
}
|
@@ -0,0 +1,41 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_all_extents
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
enum Enum {zero, one_};
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_all_extents()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_all_extents<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_all_extents_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_all_extents<int, int> ();
|
||||
test_remove_all_extents<const Enum, const Enum> ();
|
||||
test_remove_all_extents<int[], int> ();
|
||||
test_remove_all_extents<const int[], const int> ();
|
||||
test_remove_all_extents<int[3], int> ();
|
||||
test_remove_all_extents<const int[3], const int> ();
|
||||
test_remove_all_extents<int[][3], int> ();
|
||||
test_remove_all_extents<const int[][3], const int> ();
|
||||
test_remove_all_extents<int[2][3], int> ();
|
||||
test_remove_all_extents<const int[2][3], const int> ();
|
||||
test_remove_all_extents<int[1][2][3], int> ();
|
||||
test_remove_all_extents<const int[1][2][3], const int> ();
|
||||
}
|
@@ -0,0 +1,42 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_extent
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
enum Enum {zero, one_};
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_extent()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_extent<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_extent_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_extent<int, int> ();
|
||||
test_remove_extent<const Enum, const Enum> ();
|
||||
test_remove_extent<int[], int> ();
|
||||
test_remove_extent<const int[], const int> ();
|
||||
test_remove_extent<int[3], int> ();
|
||||
test_remove_extent<const int[3], const int> ();
|
||||
test_remove_extent<int[][3], int[3]> ();
|
||||
test_remove_extent<const int[][3], const int[3]> ();
|
||||
test_remove_extent<int[2][3], int[3]> ();
|
||||
test_remove_extent<const int[2][3], const int[3]> ();
|
||||
test_remove_extent<int[1][2][3], int[2][3]> ();
|
||||
test_remove_extent<const int[1][2][3], const int[2][3]> ();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_const
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_const_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_const<T>::type, const U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_const_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_add_const()
|
||||
{
|
||||
test_add_const_imp<T, const T>();
|
||||
test_add_const_imp<const T, const T>();
|
||||
test_add_const_imp<volatile T, volatile const T>();
|
||||
test_add_const_imp<const volatile T, const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_add_const<void>();
|
||||
test_add_const<int>();
|
||||
test_add_const<int[3]>();
|
||||
test_add_const<int&>();
|
||||
test_add_const<const int&>();
|
||||
test_add_const<int*>();
|
||||
test_add_const<const int*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_cv
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_cv_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_cv<T>::type, const volatile U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_cv_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_add_cv()
|
||||
{
|
||||
test_add_cv_imp<T, const volatile T>();
|
||||
test_add_cv_imp<const T, const volatile T>();
|
||||
test_add_cv_imp<volatile T, volatile const T>();
|
||||
test_add_cv_imp<const volatile T, const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_add_cv<void>();
|
||||
test_add_cv<int>();
|
||||
test_add_cv<int[3]>();
|
||||
test_add_cv<int&>();
|
||||
test_add_cv<const int&>();
|
||||
test_add_cv<int*>();
|
||||
test_add_cv<const int*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_volatile
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_volatile_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_volatile<T>::type, volatile U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_volatile_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_add_volatile()
|
||||
{
|
||||
test_add_volatile_imp<T, volatile T>();
|
||||
test_add_volatile_imp<const T, const volatile T>();
|
||||
test_add_volatile_imp<volatile T, volatile T>();
|
||||
test_add_volatile_imp<const volatile T, const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_add_volatile<void>();
|
||||
test_add_volatile<int>();
|
||||
test_add_volatile<int[3]>();
|
||||
test_add_volatile<int&>();
|
||||
test_add_volatile<const int&>();
|
||||
test_add_volatile<int*>();
|
||||
test_add_volatile<const int*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_const
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_const_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_const<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_const_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_remove_const()
|
||||
{
|
||||
test_remove_const_imp<T, T>();
|
||||
test_remove_const_imp<const T, T>();
|
||||
test_remove_const_imp<volatile T, volatile T>();
|
||||
test_remove_const_imp<const volatile T, volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_const<void>();
|
||||
test_remove_const<int>();
|
||||
test_remove_const<int[3]>();
|
||||
test_remove_const<int&>();
|
||||
test_remove_const<const int&>();
|
||||
test_remove_const<int*>();
|
||||
test_remove_const<const int*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_cv
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_cv_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_cv<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_cv_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_remove_cv()
|
||||
{
|
||||
test_remove_cv_imp<T, T>();
|
||||
test_remove_cv_imp<const T, T>();
|
||||
test_remove_cv_imp<volatile T, T>();
|
||||
test_remove_cv_imp<const volatile T, T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_cv<void>();
|
||||
test_remove_cv<int>();
|
||||
test_remove_cv<int[3]>();
|
||||
test_remove_cv<int&>();
|
||||
test_remove_cv<const int&>();
|
||||
test_remove_cv<int*>();
|
||||
test_remove_cv<const int*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_volatile
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_volatile_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_volatile<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_volatile_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_remove_volatile()
|
||||
{
|
||||
test_remove_volatile_imp<T, T>();
|
||||
test_remove_volatile_imp<const T, const T>();
|
||||
test_remove_volatile_imp<volatile T, T>();
|
||||
test_remove_volatile_imp<const volatile T, const T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_volatile<void>();
|
||||
test_remove_volatile<int>();
|
||||
test_remove_volatile<int[3]>();
|
||||
test_remove_volatile<int&>();
|
||||
test_remove_volatile<const int&>();
|
||||
test_remove_volatile<int*>();
|
||||
test_remove_volatile<volatile int*>();
|
||||
}
|
@@ -0,0 +1,194 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// aligned_storage
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
typedef std::aligned_storage<10, 1 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 1, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10, 2 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10, 4 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 4>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 12, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10, 8 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 8>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10, 16 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 16>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 16, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10, 32 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10, 32>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 32, "");
|
||||
static_assert(sizeof(T1) == 32, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<20, 32 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<20, 32>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 32, "");
|
||||
static_assert(sizeof(T1) == 32, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<40, 32 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<40, 32>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 32, "");
|
||||
static_assert(sizeof(T1) == 64, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<12, 16 >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<12, 16>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 16, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<1>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<1>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 1, "");
|
||||
static_assert(sizeof(T1) == 1, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<2>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<2>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 2, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<3>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<3>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 4, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<4>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<4>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 4, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<5>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<5>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 8, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<7>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<7>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 8, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<8>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<8>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 8, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<9>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<9>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<15>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<15>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
// Use alignof(std::max_align_t) below to find the max alignment instead of
|
||||
// hardcoding it, because it's different on different platforms.
|
||||
// (For example 8 on arm and 16 on x86.)
|
||||
#if __cplusplus < 201103L
|
||||
#define alignof __alignof__
|
||||
#endif
|
||||
{
|
||||
typedef std::aligned_storage<16>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
|
||||
"");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<17>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
|
||||
"");
|
||||
static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_storage<10>::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
}
|
@@ -0,0 +1,92 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// aligned_union<size_t Len, class ...Types>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
{
|
||||
typedef std::aligned_union<10, char >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, char>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 1, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<10, short >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, short>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<10, int >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, int>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 12, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<10, double >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, double>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 8, "");
|
||||
static_assert(sizeof(T1) == 16, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<10, short, char >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, short, char>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<10, char, short >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<10, char, short>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 2, "");
|
||||
static_assert(sizeof(T1) == 10, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<2, int, char, short >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<2, int, char, short>, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 4, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<2, char, int, short >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<2, char, int, short >, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 4, "");
|
||||
}
|
||||
{
|
||||
typedef std::aligned_union<2, char, short, int >::type T1;
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(std::is_same<std::aligned_union_t<2, char, short, int >, T1>::value, "" );
|
||||
#endif
|
||||
static_assert(std::alignment_of<T1>::value == 4, "");
|
||||
static_assert(sizeof(T1) == 4, "");
|
||||
}
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,52 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// common_type
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type<char>::type, char>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::common_type_t<int>, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type_t<char>, char>::value), "");
|
||||
#endif
|
||||
|
||||
static_assert((std::is_same<std::common_type< int>::type, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type<const int>::type, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type< volatile int>::type, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type<const volatile int>::type, int>::value), "");
|
||||
|
||||
static_assert((std::is_same<std::common_type<int, int>::type, int>::value), "");
|
||||
static_assert((std::is_same<std::common_type<int, const int>::type, int>::value), "");
|
||||
|
||||
static_assert((std::is_same<std::common_type<long, const int>::type, long>::value), "");
|
||||
static_assert((std::is_same<std::common_type<const long, int>::type, long>::value), "");
|
||||
static_assert((std::is_same<std::common_type<long, volatile int>::type, long>::value), "");
|
||||
static_assert((std::is_same<std::common_type<volatile long, int>::type, long>::value), "");
|
||||
static_assert((std::is_same<std::common_type<const long, const int>::type, long>::value), "");
|
||||
|
||||
static_assert((std::is_same<std::common_type<double, char>::type, double>::value), "");
|
||||
static_assert((std::is_same<std::common_type<short, char>::type, int>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::common_type_t<double, char>, double>::value), "");
|
||||
static_assert((std::is_same<std::common_type_t<short, char>, int>::value), "");
|
||||
#endif
|
||||
|
||||
static_assert((std::is_same<std::common_type<double, char, long long>::type, double>::value), "");
|
||||
static_assert((std::is_same<std::common_type<unsigned, char, long long>::type, long long>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::common_type_t<double, char, long long>, double>::value), "");
|
||||
static_assert((std::is_same<std::common_type_t<unsigned, char, long long>, long long>::value), "");
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,24 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// conditional
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
|
||||
static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
|
||||
static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,34 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// decay
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_decay()
|
||||
{
|
||||
static_assert((std::is_same<typename std::decay<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::decay_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_decay<void, void>();
|
||||
test_decay<int, int>();
|
||||
test_decay<const volatile int, int>();
|
||||
test_decay<int*, int*>();
|
||||
test_decay<int[3], int*>();
|
||||
test_decay<const int[3], const int*>();
|
||||
test_decay<void(), void (*)()>();
|
||||
}
|
@@ -0,0 +1,19 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// enable_if
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
typedef std::enable_if<false>::type A;
|
||||
}
|
@@ -0,0 +1,24 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// enable_if
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
|
||||
static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
|
||||
static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,23 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// enable_if
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
int main()
|
||||
{
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
typedef std::enable_if_t<false> A;
|
||||
#else
|
||||
static_assert ( false, "" );
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,98 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// <functional>
|
||||
|
||||
// result_of<Fn(ArgTypes...)>
|
||||
|
||||
#include <type_traits>
|
||||
#include <memory>
|
||||
|
||||
typedef bool (&PF1)();
|
||||
typedef short (*PF2)(long);
|
||||
|
||||
struct S
|
||||
{
|
||||
operator PF2() const;
|
||||
double operator()(char, int&);
|
||||
void calc(long) const;
|
||||
char data_;
|
||||
};
|
||||
|
||||
typedef void (S::*PMS)(long) const;
|
||||
typedef char S::*PMD;
|
||||
|
||||
struct wat
|
||||
{
|
||||
wat& operator*() { return *this; }
|
||||
void foo();
|
||||
};
|
||||
|
||||
struct F {};
|
||||
|
||||
template <class T, class U>
|
||||
void test_result_of_imp()
|
||||
{
|
||||
static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::result_of_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_result_of_imp<S(int), short> ();
|
||||
test_result_of_imp<S&(unsigned char, int&), double> ();
|
||||
test_result_of_imp<PF1(), bool> ();
|
||||
test_result_of_imp<PMS(std::unique_ptr<S>, int), void> ();
|
||||
test_result_of_imp<PMS(S, int), void> ();
|
||||
test_result_of_imp<PMS(const S&, int), void> ();
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_result_of_imp<PMD(S), char&&> ();
|
||||
#endif
|
||||
test_result_of_imp<PMD(const S*), const char&> ();
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_result_of_imp<int (F::* (F &)) () &, int> ();
|
||||
test_result_of_imp<int (F::* (F &)) () const &, int> ();
|
||||
test_result_of_imp<int (F::* (F const &)) () const &, int> ();
|
||||
test_result_of_imp<int (F::* (F &&)) () &&, int> ();
|
||||
test_result_of_imp<int (F::* (F &&)) () const&&, int> ();
|
||||
test_result_of_imp<int (F::* (F const&&)) () const&&, int> ();
|
||||
#endif
|
||||
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
||||
using type1 = std::result_of<decltype(&wat::foo)(wat)>::type;
|
||||
#endif
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
using type2 = std::result_of_t<decltype(&wat::foo)(wat)>;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
static_assert((std::is_same<std::result_of<S(int)>::type, short>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<S&(unsigned char, int&)>::type, double>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<PF1()>::type, bool>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<PMS(std::unique_ptr<S>, int)>::type, void>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<PMS(S, int)>::type, void>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<PMS(const S&, int)>::type, void>::value), "Error!");
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
static_assert((std::is_same<std::result_of<PMD(S)>::type, char&&>::value), "Error!");
|
||||
#endif
|
||||
static_assert((std::is_same<std::result_of<PMD(const S*)>::type, const char&>::value), "Error!");
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F &)) () &>::type, int>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F &)) () const &>::type, int>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F const &)) () const &>::type, int>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F &&)) () &&>::type, int>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F &&)) () const&&>::type, int>::value), "Error!");
|
||||
static_assert((std::is_same<std::result_of<int (F::* (F const&&)) () const&&>::type, int>::value), "Error!");
|
||||
#endif
|
||||
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
||||
using type = std::result_of<decltype(&wat::foo)(wat)>::type;
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,41 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// underlying_type
|
||||
|
||||
#include <type_traits>
|
||||
#include <climits>
|
||||
|
||||
enum E { V = INT_MIN };
|
||||
enum F { W = UINT_MAX };
|
||||
|
||||
int main()
|
||||
{
|
||||
static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
|
||||
"E has the wrong underlying type");
|
||||
static_assert((std::is_same<std::underlying_type<F>::type, unsigned>::value),
|
||||
"F has the wrong underlying type");
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::underlying_type_t<E>, int>::value), "");
|
||||
static_assert((std::is_same<std::underlying_type_t<F>, unsigned>::value), "");
|
||||
#endif
|
||||
|
||||
#if __has_feature(cxx_strong_enums)
|
||||
enum G : char { };
|
||||
|
||||
static_assert((std::is_same<std::underlying_type<G>::type, char>::value),
|
||||
"G has the wrong underlying type");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
|
||||
#endif
|
||||
#endif // __has_feature(cxx_strong_enums)
|
||||
}
|
@@ -0,0 +1,34 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_pointer()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_pointer<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_pointer_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_add_pointer<void, void*>();
|
||||
test_add_pointer<int, int*>();
|
||||
test_add_pointer<int[3], int(*)[3]>();
|
||||
test_add_pointer<int&, int*>();
|
||||
test_add_pointer<const int&, const int*>();
|
||||
test_add_pointer<int*, int**>();
|
||||
test_add_pointer<const int*, const int**>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_pointer()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_pointer<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_pointer_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_pointer<void, void>();
|
||||
test_remove_pointer<int, int>();
|
||||
test_remove_pointer<int[3], int[3]>();
|
||||
test_remove_pointer<int*, int>();
|
||||
test_remove_pointer<const int*, const int>();
|
||||
test_remove_pointer<int**, int*>();
|
||||
test_remove_pointer<int** const, int*>();
|
||||
test_remove_pointer<int*const * , int* const>();
|
||||
test_remove_pointer<const int** , const int*>();
|
||||
|
||||
test_remove_pointer<int&, int&>();
|
||||
test_remove_pointer<const int&, const int&>();
|
||||
test_remove_pointer<int(&)[3], int(&)[3]>();
|
||||
test_remove_pointer<int(*)[3], int[3]>();
|
||||
test_remove_pointer<int*&, int*&>();
|
||||
test_remove_pointer<const int*&, const int*&>();
|
||||
}
|
@@ -0,0 +1,34 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_lvalue_reference
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_lvalue_reference()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_lvalue_reference<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_lvalue_reference_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_add_lvalue_reference<void, void>();
|
||||
test_add_lvalue_reference<int, int&>();
|
||||
test_add_lvalue_reference<int[3], int(&)[3]>();
|
||||
test_add_lvalue_reference<int&, int&>();
|
||||
test_add_lvalue_reference<const int&, const int&>();
|
||||
test_add_lvalue_reference<int*, int*&>();
|
||||
test_add_lvalue_reference<const int*, const int*&>();
|
||||
}
|
@@ -0,0 +1,40 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// add_rvalue_reference
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
template <class T, class U>
|
||||
void test_add_rvalue_reference()
|
||||
{
|
||||
static_assert((std::is_same<typename std::add_rvalue_reference<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::add_rvalue_reference_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_add_rvalue_reference<void, void>();
|
||||
test_add_rvalue_reference<int, int&&>();
|
||||
test_add_rvalue_reference<int[3], int(&&)[3]>();
|
||||
test_add_rvalue_reference<int&, int&>();
|
||||
test_add_rvalue_reference<const int&, const int&>();
|
||||
test_add_rvalue_reference<int*, int*&&>();
|
||||
test_add_rvalue_reference<const int*, const int*&&>();
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// remove_reference
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_remove_reference()
|
||||
{
|
||||
static_assert((std::is_same<typename std::remove_reference<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::remove_reference_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_remove_reference<void, void>();
|
||||
test_remove_reference<int, int>();
|
||||
test_remove_reference<int[3], int[3]>();
|
||||
test_remove_reference<int*, int*>();
|
||||
test_remove_reference<const int*, const int*>();
|
||||
|
||||
test_remove_reference<int&, int>();
|
||||
test_remove_reference<const int&, const int>();
|
||||
test_remove_reference<int(&)[3], int[3]>();
|
||||
test_remove_reference<int*&, int*>();
|
||||
test_remove_reference<const int*&, const int*>();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_remove_reference<int&&, int>();
|
||||
test_remove_reference<const int&&, const int>();
|
||||
test_remove_reference<int(&&)[3], int[3]>();
|
||||
test_remove_reference<int*&&, int*>();
|
||||
test_remove_reference<const int*&&, const int*>();
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
@@ -0,0 +1,64 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// make_signed
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
enum Enum {zero, one_};
|
||||
|
||||
enum BigEnum
|
||||
{
|
||||
bigzero,
|
||||
big = 0xFFFFFFFFFFFFFFFFULL
|
||||
};
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
|
||||
enum HugeEnum : __uint128_t
|
||||
{
|
||||
hugezero
|
||||
};
|
||||
#endif
|
||||
|
||||
template <class T, class U>
|
||||
void test_make_signed()
|
||||
{
|
||||
static_assert((std::is_same<typename std::make_signed<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::make_signed_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_make_signed< signed char, signed char >();
|
||||
test_make_signed< unsigned char, signed char >();
|
||||
test_make_signed< char, signed char >();
|
||||
test_make_signed< short, signed short >();
|
||||
test_make_signed< unsigned short, signed short >();
|
||||
test_make_signed< int, signed int >();
|
||||
test_make_signed< unsigned int, signed int >();
|
||||
test_make_signed< long, signed long >();
|
||||
test_make_signed< unsigned long, long >();
|
||||
test_make_signed< long long, signed long long >();
|
||||
test_make_signed< unsigned long long, signed long long >();
|
||||
test_make_signed< wchar_t, std::conditional<sizeof(wchar_t) == 4, int, short>::type >();
|
||||
test_make_signed< const wchar_t, std::conditional<sizeof(wchar_t) == 4, const int, const short>::type >();
|
||||
test_make_signed< const Enum, std::conditional<sizeof(Enum) == sizeof(int), const int, const signed char>::type >();
|
||||
test_make_signed< BigEnum, std::conditional<sizeof(long) == 4, long long, long>::type >();
|
||||
#ifndef _LIBCPP_HAS_NO_INT128
|
||||
test_make_signed< __int128_t, __int128_t >();
|
||||
test_make_signed< __uint128_t, __int128_t >();
|
||||
# ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
test_make_signed< HugeEnum, __int128_t >();
|
||||
# endif
|
||||
#endif
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// make_unsigned
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
enum Enum {zero, one_};
|
||||
|
||||
enum BigEnum
|
||||
{
|
||||
bigzero,
|
||||
big = 0xFFFFFFFFFFFFFFFFULL
|
||||
};
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
|
||||
enum HugeEnum : __int128_t
|
||||
{
|
||||
hugezero
|
||||
};
|
||||
#endif
|
||||
|
||||
template <class T, class U>
|
||||
void test_make_unsigned()
|
||||
{
|
||||
static_assert((std::is_same<typename std::make_unsigned<T>::type, U>::value), "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert((std::is_same<std::make_unsigned_t<T>, U>::value), "");
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_make_unsigned<signed char, unsigned char> ();
|
||||
test_make_unsigned<unsigned char, unsigned char> ();
|
||||
test_make_unsigned<char, unsigned char> ();
|
||||
test_make_unsigned<short, unsigned short> ();
|
||||
test_make_unsigned<unsigned short, unsigned short> ();
|
||||
test_make_unsigned<int, unsigned int> ();
|
||||
test_make_unsigned<unsigned int, unsigned int> ();
|
||||
test_make_unsigned<long, unsigned long> ();
|
||||
test_make_unsigned<unsigned long, unsigned long> ();
|
||||
test_make_unsigned<long long, unsigned long long> ();
|
||||
test_make_unsigned<unsigned long long, unsigned long long> ();
|
||||
test_make_unsigned<wchar_t, std::conditional<sizeof(wchar_t) == 4, unsigned int, unsigned short>::type> ();
|
||||
test_make_unsigned<const wchar_t, std::conditional<sizeof(wchar_t) == 4, const unsigned int, const unsigned short>::type> ();
|
||||
test_make_unsigned<const Enum, std::conditional<sizeof(Enum) == sizeof(int), const unsigned int, const unsigned char>::type >();
|
||||
test_make_unsigned<BigEnum,
|
||||
std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type> ();
|
||||
#ifndef _LIBCPP_HAS_NO_INT128
|
||||
test_make_unsigned<__int128_t, __uint128_t>();
|
||||
test_make_unsigned<__uint128_t, __uint128_t>();
|
||||
# ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
test_make_unsigned<HugeEnum, __uint128_t>();
|
||||
# endif
|
||||
#endif
|
||||
}
|
12
test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
Normal file
12
test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
Normal file
@@ -0,0 +1,12 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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()
|
||||
{
|
||||
}
|
@@ -0,0 +1,12 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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()
|
||||
{
|
||||
}
|
@@ -0,0 +1,47 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// alignment_of
|
||||
|
||||
#include <type_traits>
|
||||
#include <cstdint>
|
||||
|
||||
template <class T, unsigned A>
|
||||
void test_alignment_of()
|
||||
{
|
||||
static_assert( std::alignment_of<T>::value == A, "");
|
||||
static_assert( std::alignment_of<const T>::value == A, "");
|
||||
static_assert( std::alignment_of<volatile T>::value == A, "");
|
||||
static_assert( std::alignment_of<const volatile T>::value == A, "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_alignment_of<int&, 4>();
|
||||
test_alignment_of<Class, 1>();
|
||||
test_alignment_of<int*, sizeof(intptr_t)>();
|
||||
test_alignment_of<const int*, sizeof(intptr_t)>();
|
||||
test_alignment_of<char[3], 1>();
|
||||
test_alignment_of<int, 4>();
|
||||
test_alignment_of<double, 8>();
|
||||
#if (defined(__ppc__) && !defined(__ppc64__))
|
||||
test_alignment_of<bool, 4>(); // 32-bit PPC has four byte bool
|
||||
#else
|
||||
test_alignment_of<bool, 1>();
|
||||
#endif
|
||||
test_alignment_of<unsigned, 4>();
|
||||
}
|
@@ -0,0 +1,60 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// extent
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, unsigned A>
|
||||
void test_extent()
|
||||
{
|
||||
static_assert((std::extent<T>::value == A), "");
|
||||
static_assert((std::extent<const T>::value == A), "");
|
||||
static_assert((std::extent<volatile T>::value == A), "");
|
||||
static_assert((std::extent<const volatile T>::value == A), "");
|
||||
}
|
||||
|
||||
template <class T, unsigned A>
|
||||
void test_extent1()
|
||||
{
|
||||
static_assert((std::extent<T, 1>::value == A), "");
|
||||
static_assert((std::extent<const T, 1>::value == A), "");
|
||||
static_assert((std::extent<volatile T, 1>::value == A), "");
|
||||
static_assert((std::extent<const volatile T, 1>::value == A), "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_extent<void, 0>();
|
||||
test_extent<int&, 0>();
|
||||
test_extent<Class, 0>();
|
||||
test_extent<int*, 0>();
|
||||
test_extent<const int*, 0>();
|
||||
test_extent<int, 0>();
|
||||
test_extent<double, 0>();
|
||||
test_extent<bool, 0>();
|
||||
test_extent<unsigned, 0>();
|
||||
|
||||
test_extent<int[2], 2>();
|
||||
test_extent<int[2][4], 2>();
|
||||
test_extent<int[][4], 0>();
|
||||
|
||||
test_extent1<int, 0>();
|
||||
test_extent1<int[2], 0>();
|
||||
test_extent1<int[2][4], 4>();
|
||||
test_extent1<int[][4], 4>();
|
||||
}
|
46
test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
Normal file
46
test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
Normal file
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// rank
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, unsigned A>
|
||||
void test_rank()
|
||||
{
|
||||
static_assert( std::rank<T>::value == A, "");
|
||||
static_assert( std::rank<const T>::value == A, "");
|
||||
static_assert( std::rank<volatile T>::value == A, "");
|
||||
static_assert( std::rank<const volatile T>::value == A, "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_rank<void, 0>();
|
||||
test_rank<int&, 0>();
|
||||
test_rank<Class, 0>();
|
||||
test_rank<int*, 0>();
|
||||
test_rank<const int*, 0>();
|
||||
test_rank<int, 0>();
|
||||
test_rank<double, 0>();
|
||||
test_rank<bool, 0>();
|
||||
test_rank<unsigned, 0>();
|
||||
|
||||
test_rank<char[3], 1>();
|
||||
test_rank<char[][3], 2>();
|
||||
test_rank<char[][4][3], 3>();
|
||||
}
|
@@ -0,0 +1,69 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// void_t
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#if _LIBCPP_STD_VER <= 14
|
||||
int main () {}
|
||||
#else
|
||||
|
||||
template <class T>
|
||||
void test1()
|
||||
{
|
||||
static_assert( std::is_same<void, std::void_t<T>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const T>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<volatile T>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const volatile T>>::value, "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test2()
|
||||
{
|
||||
static_assert( std::is_same<void, std::void_t<T, U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const T, U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<volatile T, U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const volatile T, U>>::value, "");
|
||||
|
||||
static_assert( std::is_same<void, std::void_t<T, const U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const T, const U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<volatile T, const U>>::value, "");
|
||||
static_assert( std::is_same<void, std::void_t<const volatile T, const U>>::value, "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
static_assert( std::is_same<void, std::void_t<>>::value, "");
|
||||
|
||||
test1<void>();
|
||||
test1<int>();
|
||||
test1<double>();
|
||||
test1<int&>();
|
||||
test1<Class>();
|
||||
test1<Class[]>();
|
||||
test1<Class[5]>();
|
||||
|
||||
test2<void, int>();
|
||||
test2<double, int>();
|
||||
test2<int&, int>();
|
||||
test2<Class&, bool>();
|
||||
test2<void *, int&>();
|
||||
|
||||
static_assert( std::is_same<void, std::void_t<int, double const &, Class, volatile int[], void>>::value, "");
|
||||
}
|
||||
#endif
|
@@ -0,0 +1,55 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// array
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_array_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert( std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_array()
|
||||
{
|
||||
test_array_imp<T>();
|
||||
test_array_imp<const T>();
|
||||
test_array_imp<volatile T>();
|
||||
test_array_imp<const volatile T>();
|
||||
}
|
||||
|
||||
typedef char array[3];
|
||||
typedef const char const_array[3];
|
||||
typedef char incomplete_array[];
|
||||
|
||||
int main()
|
||||
{
|
||||
test_array<array>();
|
||||
test_array<const_array>();
|
||||
test_array<incomplete_array>();
|
||||
}
|
@@ -0,0 +1,55 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// class
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_class_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert( std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_class()
|
||||
{
|
||||
test_class_imp<T>();
|
||||
test_class_imp<const T>();
|
||||
test_class_imp<volatile T>();
|
||||
test_class_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
int _;
|
||||
double __;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_class<Class>();
|
||||
}
|
@@ -0,0 +1,51 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// enum
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_enum_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert( std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_enum()
|
||||
{
|
||||
test_enum_imp<T>();
|
||||
test_enum_imp<const T>();
|
||||
test_enum_imp<volatile T>();
|
||||
test_enum_imp<const volatile T>();
|
||||
}
|
||||
|
||||
enum Enum {zero, one};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_enum<Enum>();
|
||||
}
|
@@ -0,0 +1,51 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// floating_point
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_floating_point_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert( std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_floating_point()
|
||||
{
|
||||
test_floating_point_imp<T>();
|
||||
test_floating_point_imp<const T>();
|
||||
test_floating_point_imp<volatile T>();
|
||||
test_floating_point_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_floating_point<float>();
|
||||
test_floating_point<double>();
|
||||
test_floating_point<long double>();
|
||||
}
|
@@ -0,0 +1,52 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// function
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_function_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert( std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_function()
|
||||
{
|
||||
test_function_imp<T>();
|
||||
test_function_imp<const T>();
|
||||
test_function_imp<volatile T>();
|
||||
test_function_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_function<void ()>();
|
||||
test_function<void (int)>();
|
||||
test_function<int (double)>();
|
||||
test_function<int (double, char)>();
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// integral
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_integral_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert( std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_integral()
|
||||
{
|
||||
test_integral_imp<T>();
|
||||
test_integral_imp<const T>();
|
||||
test_integral_imp<volatile T>();
|
||||
test_integral_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_integral<bool>();
|
||||
test_integral<char>();
|
||||
test_integral<signed char>();
|
||||
test_integral<unsigned char>();
|
||||
test_integral<wchar_t>();
|
||||
test_integral<short>();
|
||||
test_integral<unsigned short>();
|
||||
test_integral<int>();
|
||||
test_integral<unsigned int>();
|
||||
test_integral<long>();
|
||||
test_integral<unsigned long>();
|
||||
test_integral<long long>();
|
||||
test_integral<unsigned long long>();
|
||||
#ifndef _LIBCPP_HAS_NO_INT128
|
||||
test_integral<__int128_t>();
|
||||
test_integral<__uint128_t>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,41 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// lvalue_ref
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_lvalue_ref()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert( std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_lvalue_ref<int&>();
|
||||
test_lvalue_ref<const int&>();
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// member_function_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert( std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer()
|
||||
{
|
||||
test_member_function_pointer_imp<T>();
|
||||
test_member_function_pointer_imp<const T>();
|
||||
test_member_function_pointer_imp<volatile T>();
|
||||
test_member_function_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_member_function_pointer<void (Class::*)()>();
|
||||
test_member_function_pointer<void (Class::*)(int)>();
|
||||
test_member_function_pointer<void (Class::*)(int, char)>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() const>();
|
||||
test_member_function_pointer<void (Class::*)(int) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) const>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) volatile>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...)>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...)>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...)>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...) const>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...) volatile>();
|
||||
|
||||
#if __cplusplus >= 201103L
|
||||
// reference qualifiers on functions are a C++11 extension
|
||||
test_member_function_pointer<void (Class::*)() &&>();
|
||||
test_member_function_pointer<void (Class::*)(int) &&>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) &&>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() &>();
|
||||
test_member_function_pointer<void (Class::*)(int) &>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) &>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() volatile &&>();
|
||||
test_member_function_pointer<void (Class::*)(int) volatile &&>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) volatile &&>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) &&>();
|
||||
test_member_function_pointer<void (Class::*)(int,...) &&>();
|
||||
test_member_function_pointer<void (Class::*)(int, char,...) &&>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) &>();
|
||||
test_member_function_pointer<void (Class::*)(int,...) &>();
|
||||
test_member_function_pointer<void (Class::*)(int, char,...) &>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) volatile &&>();
|
||||
test_member_function_pointer<void (Class::*)(int,...) volatile &&>();
|
||||
test_member_function_pointer<void (Class::*)(int, char,...) volatile &&>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,76 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// member_function_pointer
|
||||
|
||||
#define _LIBCPP_HAS_NO_VARIADICS
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert( std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer()
|
||||
{
|
||||
test_member_function_pointer_imp<T>();
|
||||
test_member_function_pointer_imp<const T>();
|
||||
test_member_function_pointer_imp<volatile T>();
|
||||
test_member_function_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_member_function_pointer<void (Class::*)()>();
|
||||
test_member_function_pointer<void (Class::*)(int)>();
|
||||
test_member_function_pointer<void (Class::*)(int, char)>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() const>();
|
||||
test_member_function_pointer<void (Class::*)(int) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) const>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)() volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, char) volatile>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...)>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...)>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...)>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...) const>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...) const>();
|
||||
|
||||
test_member_function_pointer<void (Class::*)(...) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, ...) volatile>();
|
||||
test_member_function_pointer<void (Class::*)(int, char, ...) volatile>();
|
||||
}
|
@@ -0,0 +1,53 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// member_object_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_member_object_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert( std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_member_object_pointer()
|
||||
{
|
||||
test_member_object_pointer_imp<T>();
|
||||
test_member_object_pointer_imp<const T>();
|
||||
test_member_object_pointer_imp<volatile T>();
|
||||
test_member_object_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_member_object_pointer<int Class::*>();
|
||||
}
|
@@ -0,0 +1,52 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// nullptr_t
|
||||
// is_null_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class T>
|
||||
void test_nullptr_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
static_assert( std::is_null_pointer<T>::value, "");
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_nullptr()
|
||||
{
|
||||
test_nullptr_imp<T>();
|
||||
test_nullptr_imp<const T>();
|
||||
test_nullptr_imp<volatile T>();
|
||||
test_nullptr_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_nullptr<std::nullptr_t>();
|
||||
}
|
||||
#else
|
||||
int main() {}
|
||||
#endif
|
@@ -0,0 +1,52 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert( std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_pointer()
|
||||
{
|
||||
test_pointer_imp<T>();
|
||||
test_pointer_imp<const T>();
|
||||
test_pointer_imp<volatile T>();
|
||||
test_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_pointer<void*>();
|
||||
test_pointer<int*>();
|
||||
test_pointer<const int*>();
|
||||
test_pointer<void (*)(int)>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// rvalue_ref
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_rvalue_ref()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert( std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_rvalue_ref<int&&>();
|
||||
test_rvalue_ref<const int&&>();
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
@@ -0,0 +1,55 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// union
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_union_imp()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert( std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_union()
|
||||
{
|
||||
test_union_imp<T>();
|
||||
test_union_imp<const T>();
|
||||
test_union_imp<volatile T>();
|
||||
test_union_imp<const volatile T>();
|
||||
}
|
||||
|
||||
union Union
|
||||
{
|
||||
int _;
|
||||
double __;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_union<Union>();
|
||||
}
|
@@ -0,0 +1,49 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// void
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_void_imp()
|
||||
{
|
||||
static_assert( std::is_void<T>::value, "");
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
static_assert(!std::is_null_pointer<T>::value, "");
|
||||
#endif
|
||||
static_assert(!std::is_integral<T>::value, "");
|
||||
static_assert(!std::is_floating_point<T>::value, "");
|
||||
static_assert(!std::is_array<T>::value, "");
|
||||
static_assert(!std::is_pointer<T>::value, "");
|
||||
static_assert(!std::is_lvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_rvalue_reference<T>::value, "");
|
||||
static_assert(!std::is_member_object_pointer<T>::value, "");
|
||||
static_assert(!std::is_member_function_pointer<T>::value, "");
|
||||
static_assert(!std::is_enum<T>::value, "");
|
||||
static_assert(!std::is_union<T>::value, "");
|
||||
static_assert(!std::is_class<T>::value, "");
|
||||
static_assert(!std::is_function<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_void()
|
||||
{
|
||||
test_void_imp<T>();
|
||||
test_void_imp<const T>();
|
||||
test_void_imp<volatile T>();
|
||||
test_void_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_void<void>();
|
||||
}
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// array
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_array_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_array()
|
||||
{
|
||||
test_array_imp<T>();
|
||||
test_array_imp<const T>();
|
||||
test_array_imp<volatile T>();
|
||||
test_array_imp<const volatile T>();
|
||||
}
|
||||
|
||||
typedef char array[3];
|
||||
typedef const char const_array[3];
|
||||
typedef char incomplete_array[];
|
||||
|
||||
int main()
|
||||
{
|
||||
test_array<array>();
|
||||
test_array<const_array>();
|
||||
test_array<incomplete_array>();
|
||||
}
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// class
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_class_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_class()
|
||||
{
|
||||
test_class_imp<T>();
|
||||
test_class_imp<const T>();
|
||||
test_class_imp<volatile T>();
|
||||
test_class_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
int _;
|
||||
double __;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_class<Class>();
|
||||
}
|
@@ -0,0 +1,42 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// enum
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_enum_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_enum()
|
||||
{
|
||||
test_enum_imp<T>();
|
||||
test_enum_imp<const T>();
|
||||
test_enum_imp<volatile T>();
|
||||
test_enum_imp<const volatile T>();
|
||||
}
|
||||
|
||||
enum Enum {zero, one};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_enum<Enum>();
|
||||
}
|
@@ -0,0 +1,42 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// floating_point
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_floating_point_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert( std::is_arithmetic<T>::value, "");
|
||||
static_assert( std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert(!std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_floating_point()
|
||||
{
|
||||
test_floating_point_imp<T>();
|
||||
test_floating_point_imp<const T>();
|
||||
test_floating_point_imp<volatile T>();
|
||||
test_floating_point_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_floating_point<float>();
|
||||
test_floating_point<double>();
|
||||
test_floating_point<long double>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// function
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_function_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert(!std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_function()
|
||||
{
|
||||
test_function_imp<T>();
|
||||
test_function_imp<const T>();
|
||||
test_function_imp<volatile T>();
|
||||
test_function_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_function<void ()>();
|
||||
test_function<void (int)>();
|
||||
test_function<int (double)>();
|
||||
test_function<int (double, char)>();
|
||||
}
|
@@ -0,0 +1,56 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// integral
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_integral_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert( std::is_arithmetic<T>::value, "");
|
||||
static_assert( std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert(!std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_integral()
|
||||
{
|
||||
test_integral_imp<T>();
|
||||
test_integral_imp<const T>();
|
||||
test_integral_imp<volatile T>();
|
||||
test_integral_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_integral<bool>();
|
||||
test_integral<char>();
|
||||
test_integral<signed char>();
|
||||
test_integral<unsigned char>();
|
||||
test_integral<wchar_t>();
|
||||
test_integral<short>();
|
||||
test_integral<unsigned short>();
|
||||
test_integral<int>();
|
||||
test_integral<unsigned int>();
|
||||
test_integral<long>();
|
||||
test_integral<unsigned long>();
|
||||
test_integral<long long>();
|
||||
test_integral<unsigned long long>();
|
||||
#ifndef _LIBCPP_HAS_NO_INT128
|
||||
test_integral<__int128_t>();
|
||||
test_integral<__uint128_t>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,32 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// lvalue_ref
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_lvalue_ref()
|
||||
{
|
||||
static_assert( std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert(!std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_lvalue_ref<int&>();
|
||||
test_lvalue_ref<const int&>();
|
||||
}
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// member_function_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert( std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_member_function_pointer()
|
||||
{
|
||||
test_member_function_pointer_imp<T>();
|
||||
test_member_function_pointer_imp<const T>();
|
||||
test_member_function_pointer_imp<volatile T>();
|
||||
test_member_function_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_member_function_pointer<void (Class::*)()>();
|
||||
test_member_function_pointer<void (Class::*)(int)>();
|
||||
test_member_function_pointer<void (Class::*)(int, char)>();
|
||||
}
|
@@ -0,0 +1,44 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// member_object_pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_member_object_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert( std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_member_object_pointer()
|
||||
{
|
||||
test_member_object_pointer_imp<T>();
|
||||
test_member_object_pointer_imp<const T>();
|
||||
test_member_object_pointer_imp<volatile T>();
|
||||
test_member_object_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_member_object_pointer<int Class::*>();
|
||||
}
|
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// pointer
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_pointer_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert( std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_pointer()
|
||||
{
|
||||
test_pointer_imp<T>();
|
||||
test_pointer_imp<const T>();
|
||||
test_pointer_imp<volatile T>();
|
||||
test_pointer_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_pointer<void*>();
|
||||
test_pointer<int*>();
|
||||
test_pointer<const int*>();
|
||||
test_pointer<void (*)(int)>();
|
||||
}
|
@@ -0,0 +1,34 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// rvalue_ref
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_rvalue_ref()
|
||||
{
|
||||
static_assert( std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert(!std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_rvalue_ref<int&&>();
|
||||
test_rvalue_ref<const int&&>();
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// union
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_union_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert(!std::is_fundamental<T>::value, "");
|
||||
static_assert( std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert( std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_union()
|
||||
{
|
||||
test_union_imp<T>();
|
||||
test_union_imp<const T>();
|
||||
test_union_imp<volatile T>();
|
||||
test_union_imp<const volatile T>();
|
||||
}
|
||||
|
||||
union Union
|
||||
{
|
||||
int _;
|
||||
double __;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_union<Union>();
|
||||
}
|
@@ -0,0 +1,40 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// void
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_void_imp()
|
||||
{
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
static_assert(!std::is_arithmetic<T>::value, "");
|
||||
static_assert( std::is_fundamental<T>::value, "");
|
||||
static_assert(!std::is_object<T>::value, "");
|
||||
static_assert(!std::is_scalar<T>::value, "");
|
||||
static_assert(!std::is_compound<T>::value, "");
|
||||
static_assert(!std::is_member_pointer<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_void()
|
||||
{
|
||||
test_void_imp<T>();
|
||||
test_void_imp<const T>();
|
||||
test_void_imp<volatile T>();
|
||||
test_void_imp<const volatile T>();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_void<void>();
|
||||
}
|
@@ -0,0 +1,71 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// extension
|
||||
|
||||
// template <typename _Tp> struct __has_operator_addressof
|
||||
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
constexpr B* operator&() const;
|
||||
};
|
||||
|
||||
struct D;
|
||||
|
||||
struct C
|
||||
{
|
||||
template <class U>
|
||||
D operator,(U&&);
|
||||
};
|
||||
|
||||
struct E
|
||||
{
|
||||
constexpr C operator&() const;
|
||||
};
|
||||
|
||||
struct F {};
|
||||
constexpr F* operator&(F const &) { return nullptr; }
|
||||
|
||||
struct G {};
|
||||
constexpr G* operator&(G &&) { return nullptr; }
|
||||
|
||||
struct H {};
|
||||
constexpr H* operator&(H const &&) { return nullptr; }
|
||||
|
||||
struct J
|
||||
{
|
||||
constexpr J* operator&() const &&;
|
||||
};
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_CONSTEXPR
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
static_assert(std::__has_operator_addressof<int>::value == false, "");
|
||||
static_assert(std::__has_operator_addressof<A>::value == false, "");
|
||||
static_assert(std::__has_operator_addressof<B>::value == true, "");
|
||||
static_assert(std::__has_operator_addressof<E>::value == true, "");
|
||||
static_assert(std::__has_operator_addressof<F>::value == true, "");
|
||||
static_assert(std::__has_operator_addressof<G>::value == true, "");
|
||||
static_assert(std::__has_operator_addressof<H>::value == true, "");
|
||||
static_assert(std::__has_operator_addressof<J>::value == true, "");
|
||||
#endif // _LIBCPP_HAS_NO_CONSTEXPR
|
||||
}
|
@@ -0,0 +1,77 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// has_virtual_destructor
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_has_virtual_destructor()
|
||||
{
|
||||
static_assert( std::has_virtual_destructor<T>::value, "");
|
||||
static_assert( std::has_virtual_destructor<const T>::value, "");
|
||||
static_assert( std::has_virtual_destructor<volatile T>::value, "");
|
||||
static_assert( std::has_virtual_destructor<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_virtual_destructor()
|
||||
{
|
||||
static_assert(!std::has_virtual_destructor<T>::value, "");
|
||||
static_assert(!std::has_virtual_destructor<const T>::value, "");
|
||||
static_assert(!std::has_virtual_destructor<volatile T>::value, "");
|
||||
static_assert(!std::has_virtual_destructor<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
~A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_virtual_destructor<void>();
|
||||
test_has_not_virtual_destructor<A>();
|
||||
test_has_not_virtual_destructor<int&>();
|
||||
test_has_not_virtual_destructor<Union>();
|
||||
test_has_not_virtual_destructor<Empty>();
|
||||
test_has_not_virtual_destructor<int>();
|
||||
test_has_not_virtual_destructor<double>();
|
||||
test_has_not_virtual_destructor<int*>();
|
||||
test_has_not_virtual_destructor<const int*>();
|
||||
test_has_not_virtual_destructor<char[3]>();
|
||||
test_has_not_virtual_destructor<char[]>();
|
||||
test_has_not_virtual_destructor<bit_zero>();
|
||||
|
||||
test_has_virtual_destructor<Abstract>();
|
||||
test_has_virtual_destructor<NotEmpty>();
|
||||
}
|
@@ -0,0 +1,71 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_abstract
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_abstract()
|
||||
{
|
||||
static_assert( std::is_abstract<T>::value, "");
|
||||
static_assert( std::is_abstract<const T>::value, "");
|
||||
static_assert( std::is_abstract<volatile T>::value, "");
|
||||
static_assert( std::is_abstract<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_abstract()
|
||||
{
|
||||
static_assert(!std::is_abstract<T>::value, "");
|
||||
static_assert(!std::is_abstract<const T>::value, "");
|
||||
static_assert(!std::is_abstract<volatile T>::value, "");
|
||||
static_assert(!std::is_abstract<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_abstract<void>();
|
||||
test_is_not_abstract<int&>();
|
||||
test_is_not_abstract<int>();
|
||||
test_is_not_abstract<double>();
|
||||
test_is_not_abstract<int*>();
|
||||
test_is_not_abstract<const int*>();
|
||||
test_is_not_abstract<char[3]>();
|
||||
test_is_not_abstract<char[]>();
|
||||
test_is_not_abstract<Union>();
|
||||
test_is_not_abstract<Empty>();
|
||||
test_is_not_abstract<bit_zero>();
|
||||
test_is_not_abstract<NotEmpty>();
|
||||
|
||||
test_is_abstract<Abstract>();
|
||||
}
|
@@ -0,0 +1,70 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
void operator=(A);
|
||||
};
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_assignable()
|
||||
{
|
||||
static_assert(( std::is_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_assignable()
|
||||
{
|
||||
static_assert((!std::is_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
struct D;
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
struct C
|
||||
{
|
||||
template <class U>
|
||||
D operator,(U&&);
|
||||
};
|
||||
|
||||
struct E
|
||||
{
|
||||
C operator=(int);
|
||||
};
|
||||
#endif
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_assignable<int&, int&> ();
|
||||
test_is_assignable<int&, int> ();
|
||||
test_is_assignable<int&, double> ();
|
||||
test_is_assignable<B, A> ();
|
||||
test_is_assignable<void*&, void*> ();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_is_assignable<E, int> ();
|
||||
|
||||
test_is_not_assignable<int, int&> ();
|
||||
test_is_not_assignable<int, int> ();
|
||||
#endif
|
||||
test_is_not_assignable<A, B> ();
|
||||
test_is_not_assignable<void, const void> ();
|
||||
test_is_not_assignable<const void, const void> ();
|
||||
test_is_not_assignable<int(), int> ();
|
||||
}
|
@@ -0,0 +1,37 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_const
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_const()
|
||||
{
|
||||
static_assert(!std::is_const<T>::value, "");
|
||||
static_assert( std::is_const<const T>::value, "");
|
||||
static_assert(!std::is_const<volatile T>::value, "");
|
||||
static_assert( std::is_const<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_const<void>();
|
||||
test_is_const<int>();
|
||||
test_is_const<double>();
|
||||
test_is_const<int*>();
|
||||
test_is_const<const int*>();
|
||||
test_is_const<char[3]>();
|
||||
test_is_const<char[]>();
|
||||
|
||||
static_assert(!std::is_const<int&>::value, "");
|
||||
static_assert(!std::is_const<const int&>::value, "");
|
||||
}
|
@@ -0,0 +1,86 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// template <class T, class... Args>
|
||||
// struct is_constructible;
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
struct A
|
||||
{
|
||||
explicit A(int);
|
||||
A(int, double);
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
private:
|
||||
#endif
|
||||
A(char);
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
class AbstractDestructor
|
||||
{
|
||||
virtual ~AbstractDestructor() = 0;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
void test_is_constructible()
|
||||
{
|
||||
static_assert( (std::is_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_constructible()
|
||||
{
|
||||
static_assert( (std::is_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0, class A1>
|
||||
void test_is_constructible()
|
||||
{
|
||||
static_assert( (std::is_constructible<T, A0, A1>::value), "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_constructible()
|
||||
{
|
||||
static_assert((!std::is_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_not_constructible()
|
||||
{
|
||||
static_assert((!std::is_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_constructible<int> ();
|
||||
test_is_constructible<int, const int> ();
|
||||
test_is_constructible<A, int> ();
|
||||
test_is_constructible<A, int, double> ();
|
||||
test_is_constructible<int&, int&> ();
|
||||
|
||||
test_is_not_constructible<A> ();
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
test_is_not_constructible<A, char> ();
|
||||
#else
|
||||
test_is_constructible<A, char> ();
|
||||
#endif
|
||||
test_is_not_constructible<A, void> ();
|
||||
test_is_not_constructible<void> ();
|
||||
test_is_not_constructible<int&> ();
|
||||
test_is_not_constructible<Abstract> ();
|
||||
test_is_not_constructible<AbstractDestructor> ();
|
||||
}
|
@@ -0,0 +1,80 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_copy_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_copy_assignable()
|
||||
{
|
||||
static_assert(( std::is_copy_assignable<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_copy_assignable()
|
||||
{
|
||||
static_assert((!std::is_copy_assignable<T>::value), "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A();
|
||||
};
|
||||
|
||||
class B
|
||||
{
|
||||
B& operator=(const B&);
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
void operator=(C&); // not const
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_copy_assignable<int> ();
|
||||
test_is_copy_assignable<int&> ();
|
||||
test_is_copy_assignable<A> ();
|
||||
test_is_copy_assignable<bit_zero> ();
|
||||
test_is_copy_assignable<Union> ();
|
||||
test_is_copy_assignable<NotEmpty> ();
|
||||
test_is_copy_assignable<Empty> ();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_is_not_copy_assignable<const int> ();
|
||||
test_is_not_copy_assignable<int[]> ();
|
||||
test_is_not_copy_assignable<int[3]> ();
|
||||
#endif
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
test_is_not_copy_assignable<B> ();
|
||||
#endif
|
||||
test_is_not_copy_assignable<void> ();
|
||||
test_is_not_copy_assignable<C> ();
|
||||
}
|
@@ -0,0 +1,88 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_copy_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_copy_constructible()
|
||||
{
|
||||
static_assert( std::is_copy_constructible<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_copy_constructible()
|
||||
{
|
||||
static_assert(!std::is_copy_constructible<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
public:
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
class B
|
||||
{
|
||||
B(const B&);
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
C(C&); // not const
|
||||
void operator=(C&); // not const
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_copy_constructible<A>();
|
||||
test_is_copy_constructible<int&>();
|
||||
test_is_copy_constructible<Union>();
|
||||
test_is_copy_constructible<Empty>();
|
||||
test_is_copy_constructible<int>();
|
||||
test_is_copy_constructible<double>();
|
||||
test_is_copy_constructible<int*>();
|
||||
test_is_copy_constructible<const int*>();
|
||||
test_is_copy_constructible<NotEmpty>();
|
||||
test_is_copy_constructible<bit_zero>();
|
||||
|
||||
test_is_not_copy_constructible<char[3]>();
|
||||
test_is_not_copy_constructible<char[]>();
|
||||
test_is_not_copy_constructible<void>();
|
||||
test_is_not_copy_constructible<Abstract>();
|
||||
test_is_not_copy_constructible<C>();
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
test_is_not_copy_constructible<B>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,93 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_default_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_default_constructible()
|
||||
{
|
||||
static_assert( std::is_default_constructible<T>::value, "");
|
||||
static_assert( std::is_default_constructible<const T>::value, "");
|
||||
static_assert( std::is_default_constructible<volatile T>::value, "");
|
||||
static_assert( std::is_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_default_constructible()
|
||||
{
|
||||
static_assert(!std::is_default_constructible<T>::value, "");
|
||||
static_assert(!std::is_default_constructible<const T>::value, "");
|
||||
static_assert(!std::is_default_constructible<volatile T>::value, "");
|
||||
static_assert(!std::is_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NoDefaultConstructor
|
||||
{
|
||||
NoDefaultConstructor(int) {}
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
public:
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A();
|
||||
};
|
||||
|
||||
class B
|
||||
{
|
||||
B();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_default_constructible<A>();
|
||||
test_is_default_constructible<Union>();
|
||||
test_is_default_constructible<Empty>();
|
||||
test_is_default_constructible<int>();
|
||||
test_is_default_constructible<double>();
|
||||
test_is_default_constructible<int*>();
|
||||
test_is_default_constructible<const int*>();
|
||||
test_is_default_constructible<char[3]>();
|
||||
test_is_default_constructible<NotEmpty>();
|
||||
test_is_default_constructible<bit_zero>();
|
||||
|
||||
test_is_not_default_constructible<void>();
|
||||
test_is_not_default_constructible<int&>();
|
||||
test_is_not_default_constructible<char[]>();
|
||||
test_is_not_default_constructible<Abstract>();
|
||||
test_is_not_default_constructible<NoDefaultConstructor>();
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
test_is_not_default_constructible<B>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,121 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_destructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_destructible()
|
||||
{
|
||||
static_assert( std::is_destructible<T>::value, "");
|
||||
static_assert( std::is_destructible<const T>::value, "");
|
||||
static_assert( std::is_destructible<volatile T>::value, "");
|
||||
static_assert( std::is_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_destructible()
|
||||
{
|
||||
static_assert(!std::is_destructible<T>::value, "");
|
||||
static_assert(!std::is_destructible<const T>::value, "");
|
||||
static_assert(!std::is_destructible<volatile T>::value, "");
|
||||
static_assert(!std::is_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty {};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
~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>();
|
||||
test_is_destructible<int&>();
|
||||
test_is_destructible<Union>();
|
||||
test_is_destructible<Empty>();
|
||||
test_is_destructible<int>();
|
||||
test_is_destructible<double>();
|
||||
test_is_destructible<int*>();
|
||||
test_is_destructible<const int*>();
|
||||
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<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
|
||||
test_is_not_destructible<Function>();
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_empty
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_empty()
|
||||
{
|
||||
static_assert( std::is_empty<T>::value, "");
|
||||
static_assert( std::is_empty<const T>::value, "");
|
||||
static_assert( std::is_empty<volatile T>::value, "");
|
||||
static_assert( std::is_empty<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_empty()
|
||||
{
|
||||
static_assert(!std::is_empty<T>::value, "");
|
||||
static_assert(!std::is_empty<const T>::value, "");
|
||||
static_assert(!std::is_empty<volatile T>::value, "");
|
||||
static_assert(!std::is_empty<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_empty<void>();
|
||||
test_is_not_empty<int&>();
|
||||
test_is_not_empty<int>();
|
||||
test_is_not_empty<double>();
|
||||
test_is_not_empty<int*>();
|
||||
test_is_not_empty<const int*>();
|
||||
test_is_not_empty<char[3]>();
|
||||
test_is_not_empty<char[]>();
|
||||
test_is_not_empty<Union>();
|
||||
test_is_not_empty<NotEmpty>();
|
||||
|
||||
test_is_empty<Empty>();
|
||||
test_is_empty<bit_zero>();
|
||||
}
|
@@ -0,0 +1,53 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_final
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
||||
struct P final { };
|
||||
union U1 { };
|
||||
union U2 final { };
|
||||
|
||||
template <class T>
|
||||
void test_is_final()
|
||||
{
|
||||
static_assert( std::is_final<T>::value, "");
|
||||
static_assert( std::is_final<const T>::value, "");
|
||||
static_assert( std::is_final<volatile T>::value, "");
|
||||
static_assert( std::is_final<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_final()
|
||||
{
|
||||
static_assert(!std::is_final<T>::value, "");
|
||||
static_assert(!std::is_final<const T>::value, "");
|
||||
static_assert(!std::is_final<volatile T>::value, "");
|
||||
static_assert(!std::is_final<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
int main ()
|
||||
{
|
||||
test_is_not_final<int>();
|
||||
test_is_not_final<int*>();
|
||||
test_is_final <P>();
|
||||
test_is_not_final<P*>();
|
||||
test_is_not_final<U1>();
|
||||
test_is_not_final<U1*>();
|
||||
test_is_final <U2>();
|
||||
test_is_not_final<U2*>();
|
||||
}
|
||||
#else
|
||||
int main () {}
|
||||
#endif
|
@@ -0,0 +1,46 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_literal_type
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_literal_type()
|
||||
{
|
||||
static_assert( std::is_literal_type<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_literal_type()
|
||||
{
|
||||
static_assert(!std::is_literal_type<T>::value, "");
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
B();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_literal_type<int> ();
|
||||
test_is_literal_type<const int> ();
|
||||
test_is_literal_type<int&> ();
|
||||
test_is_literal_type<volatile int&> ();
|
||||
test_is_literal_type<A> ();
|
||||
|
||||
test_is_not_literal_type<B> ();
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_move_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_move_assignable()
|
||||
{
|
||||
static_assert( std::is_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_move_assignable()
|
||||
{
|
||||
static_assert(!std::is_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_move_assignable<int> ();
|
||||
test_is_move_assignable<A> ();
|
||||
test_is_move_assignable<bit_zero> ();
|
||||
test_is_move_assignable<Union> ();
|
||||
test_is_move_assignable<NotEmpty> ();
|
||||
test_is_move_assignable<Empty> ();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_is_not_move_assignable<const int> ();
|
||||
test_is_not_move_assignable<int[]> ();
|
||||
test_is_not_move_assignable<int[3]> ();
|
||||
#endif
|
||||
test_is_not_move_assignable<void> ();
|
||||
}
|
@@ -0,0 +1,81 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_move_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_move_constructible()
|
||||
{
|
||||
static_assert( std::is_move_constructible<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_move_constructible()
|
||||
{
|
||||
static_assert(!std::is_move_constructible<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
public:
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
B(B&&);
|
||||
#endif
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_move_constructible<char[3]>();
|
||||
test_is_not_move_constructible<char[]>();
|
||||
test_is_not_move_constructible<void>();
|
||||
test_is_not_move_constructible<Abstract>();
|
||||
|
||||
test_is_move_constructible<A>();
|
||||
test_is_move_constructible<int&>();
|
||||
test_is_move_constructible<Union>();
|
||||
test_is_move_constructible<Empty>();
|
||||
test_is_move_constructible<int>();
|
||||
test_is_move_constructible<double>();
|
||||
test_is_move_constructible<int*>();
|
||||
test_is_move_constructible<const int*>();
|
||||
test_is_move_constructible<NotEmpty>();
|
||||
test_is_move_constructible<bit_zero>();
|
||||
test_is_move_constructible<B>();
|
||||
}
|
@@ -0,0 +1,55 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_nothrow_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_nothrow_assignable()
|
||||
{
|
||||
static_assert(( std::is_nothrow_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_nothrow_assignable()
|
||||
{
|
||||
static_assert((!std::is_nothrow_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
void operator=(A);
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
void operator=(C&); // not const
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_nothrow_assignable<int&, int&> ();
|
||||
test_is_nothrow_assignable<int&, int> ();
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_is_nothrow_assignable<int&, double> ();
|
||||
#endif
|
||||
|
||||
test_is_not_nothrow_assignable<int, int&> ();
|
||||
test_is_not_nothrow_assignable<int, int> ();
|
||||
test_is_not_nothrow_assignable<B, A> ();
|
||||
test_is_not_nothrow_assignable<A, B> ();
|
||||
test_is_not_nothrow_assignable<C, C&> ();
|
||||
}
|
@@ -0,0 +1,103 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// template <class T, class... Args>
|
||||
// struct is_nothrow_constructible;
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_nothrow_constructible()
|
||||
{
|
||||
static_assert(( std::is_nothrow_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_nothrow_constructible()
|
||||
{
|
||||
static_assert(( std::is_nothrow_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_nothrow_constructible()
|
||||
{
|
||||
static_assert((!std::is_nothrow_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_not_nothrow_constructible()
|
||||
{
|
||||
static_assert((!std::is_nothrow_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0, class A1>
|
||||
void test_is_not_nothrow_constructible()
|
||||
{
|
||||
static_assert((!std::is_nothrow_constructible<T, A0, A1>::value), "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
C(C&); // not const
|
||||
void operator=(C&); // not const
|
||||
};
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
struct Tuple {
|
||||
Tuple(Empty&&) noexcept {}
|
||||
};
|
||||
#endif
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_nothrow_constructible<int> ();
|
||||
test_is_nothrow_constructible<int, const int&> ();
|
||||
test_is_nothrow_constructible<Empty> ();
|
||||
test_is_nothrow_constructible<Empty, const Empty&> ();
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
test_is_nothrow_constructible<Tuple &&, Empty> (); // See bug #19616.
|
||||
#endif
|
||||
|
||||
test_is_not_nothrow_constructible<A, int> ();
|
||||
test_is_not_nothrow_constructible<A, int, double> ();
|
||||
test_is_not_nothrow_constructible<A> ();
|
||||
test_is_not_nothrow_constructible<C> ();
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
static_assert(!std::is_constructible<Tuple&, Empty>::value, "");
|
||||
test_is_not_nothrow_constructible<Tuple &, Empty> (); // See bug #19616.
|
||||
#endif
|
||||
}
|
@@ -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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_nothrow_copy_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_has_nothrow_assign()
|
||||
{
|
||||
static_assert( std::is_nothrow_copy_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_nothrow_assign()
|
||||
{
|
||||
static_assert(!std::is_nothrow_copy_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
struct NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A& operator=(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_nothrow_assign<int&>();
|
||||
test_has_nothrow_assign<Union>();
|
||||
test_has_nothrow_assign<Empty>();
|
||||
test_has_nothrow_assign<int>();
|
||||
test_has_nothrow_assign<double>();
|
||||
test_has_nothrow_assign<int*>();
|
||||
test_has_nothrow_assign<const int*>();
|
||||
test_has_nothrow_assign<NotEmpty>();
|
||||
test_has_nothrow_assign<bit_zero>();
|
||||
|
||||
test_has_not_nothrow_assign<const int>();
|
||||
test_has_not_nothrow_assign<void>();
|
||||
test_has_not_nothrow_assign<A>();
|
||||
|
||||
}
|
@@ -0,0 +1,61 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_nothrow_copy_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_nothrow_copy_constructible()
|
||||
{
|
||||
static_assert( std::is_nothrow_copy_constructible<T>::value, "");
|
||||
static_assert( std::is_nothrow_copy_constructible<const T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_nothrow_copy_constructor()
|
||||
{
|
||||
static_assert(!std::is_nothrow_copy_constructible<T>::value, "");
|
||||
static_assert(!std::is_nothrow_copy_constructible<const T>::value, "");
|
||||
static_assert(!std::is_nothrow_copy_constructible<volatile T>::value, "");
|
||||
static_assert(!std::is_nothrow_copy_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_nothrow_copy_constructor<void>();
|
||||
test_has_not_nothrow_copy_constructor<A>();
|
||||
|
||||
test_is_nothrow_copy_constructible<int&>();
|
||||
test_is_nothrow_copy_constructible<Union>();
|
||||
test_is_nothrow_copy_constructible<Empty>();
|
||||
test_is_nothrow_copy_constructible<int>();
|
||||
test_is_nothrow_copy_constructible<double>();
|
||||
test_is_nothrow_copy_constructible<int*>();
|
||||
test_is_nothrow_copy_constructible<const int*>();
|
||||
test_is_nothrow_copy_constructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,64 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_nothrow_default_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_nothrow_default_constructible()
|
||||
{
|
||||
static_assert( std::is_nothrow_default_constructible<T>::value, "");
|
||||
static_assert( std::is_nothrow_default_constructible<const T>::value, "");
|
||||
static_assert( std::is_nothrow_default_constructible<volatile T>::value, "");
|
||||
static_assert( std::is_nothrow_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_nothrow_default_constructor()
|
||||
{
|
||||
static_assert(!std::is_nothrow_default_constructible<T>::value, "");
|
||||
static_assert(!std::is_nothrow_default_constructible<const T>::value, "");
|
||||
static_assert(!std::is_nothrow_default_constructible<volatile T>::value, "");
|
||||
static_assert(!std::is_nothrow_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_nothrow_default_constructor<void>();
|
||||
test_has_not_nothrow_default_constructor<int&>();
|
||||
test_has_not_nothrow_default_constructor<A>();
|
||||
|
||||
test_is_nothrow_default_constructible<Union>();
|
||||
test_is_nothrow_default_constructible<Empty>();
|
||||
test_is_nothrow_default_constructible<int>();
|
||||
test_is_nothrow_default_constructible<double>();
|
||||
test_is_nothrow_default_constructible<int*>();
|
||||
test_is_nothrow_default_constructible<const int*>();
|
||||
test_is_nothrow_default_constructible<char[3]>();
|
||||
test_is_nothrow_default_constructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,91 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_nothrow_destructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_nothrow_destructible()
|
||||
{
|
||||
static_assert( std::is_nothrow_destructible<T>::value, "");
|
||||
static_assert( std::is_nothrow_destructible<const T>::value, "");
|
||||
static_assert( std::is_nothrow_destructible<volatile T>::value, "");
|
||||
static_assert( std::is_nothrow_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_nothrow_destructible()
|
||||
{
|
||||
static_assert(!std::is_nothrow_destructible<T>::value, "");
|
||||
static_assert(!std::is_nothrow_destructible<const T>::value, "");
|
||||
static_assert(!std::is_nothrow_destructible<volatile T>::value, "");
|
||||
static_assert(!std::is_nothrow_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
class AbstractDestructor
|
||||
{
|
||||
virtual ~AbstractDestructor() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
~A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_nothrow_destructible<void>();
|
||||
test_is_not_nothrow_destructible<AbstractDestructor>();
|
||||
test_is_not_nothrow_destructible<NotEmpty>();
|
||||
test_is_not_nothrow_destructible<char[]>();
|
||||
|
||||
#if __has_feature(cxx_noexcept)
|
||||
test_is_nothrow_destructible<A>();
|
||||
#endif
|
||||
test_is_nothrow_destructible<int&>();
|
||||
#if __has_feature(cxx_unrestricted_unions)
|
||||
test_is_nothrow_destructible<Union>();
|
||||
#endif
|
||||
#if __has_feature(cxx_access_control_sfinae)
|
||||
test_is_nothrow_destructible<Empty>();
|
||||
#endif
|
||||
test_is_nothrow_destructible<int>();
|
||||
test_is_nothrow_destructible<double>();
|
||||
test_is_nothrow_destructible<int*>();
|
||||
test_is_nothrow_destructible<const int*>();
|
||||
test_is_nothrow_destructible<char[3]>();
|
||||
test_is_nothrow_destructible<Abstract>();
|
||||
#if __has_feature(cxx_noexcept)
|
||||
test_is_nothrow_destructible<bit_zero>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,63 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// has_nothrow_move_assign
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_has_nothrow_assign()
|
||||
{
|
||||
static_assert( std::is_nothrow_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_nothrow_assign()
|
||||
{
|
||||
static_assert(!std::is_nothrow_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
struct NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A& operator=(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_nothrow_assign<int&>();
|
||||
test_has_nothrow_assign<Union>();
|
||||
test_has_nothrow_assign<Empty>();
|
||||
test_has_nothrow_assign<int>();
|
||||
test_has_nothrow_assign<double>();
|
||||
test_has_nothrow_assign<int*>();
|
||||
test_has_nothrow_assign<const int*>();
|
||||
test_has_nothrow_assign<NotEmpty>();
|
||||
test_has_nothrow_assign<bit_zero>();
|
||||
|
||||
test_has_not_nothrow_assign<void>();
|
||||
test_has_not_nothrow_assign<A>();
|
||||
}
|
@@ -0,0 +1,61 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// has_nothrow_move_constructor
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_nothrow_move_constructible()
|
||||
{
|
||||
static_assert( std::is_nothrow_move_constructible<T>::value, "");
|
||||
static_assert( std::is_nothrow_move_constructible<const T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_nothrow_move_constructor()
|
||||
{
|
||||
static_assert(!std::is_nothrow_move_constructible<T>::value, "");
|
||||
static_assert(!std::is_nothrow_move_constructible<const T>::value, "");
|
||||
static_assert(!std::is_nothrow_move_constructible<volatile T>::value, "");
|
||||
static_assert(!std::is_nothrow_move_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_nothrow_move_constructor<void>();
|
||||
test_has_not_nothrow_move_constructor<A>();
|
||||
|
||||
test_is_nothrow_move_constructible<int&>();
|
||||
test_is_nothrow_move_constructible<Union>();
|
||||
test_is_nothrow_move_constructible<Empty>();
|
||||
test_is_nothrow_move_constructible<int>();
|
||||
test_is_nothrow_move_constructible<double>();
|
||||
test_is_nothrow_move_constructible<int*>();
|
||||
test_is_nothrow_move_constructible<const int*>();
|
||||
test_is_nothrow_move_constructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,52 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_pod
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_pod()
|
||||
{
|
||||
static_assert( std::is_pod<T>::value, "");
|
||||
static_assert( std::is_pod<const T>::value, "");
|
||||
static_assert( std::is_pod<volatile T>::value, "");
|
||||
static_assert( std::is_pod<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_pod()
|
||||
{
|
||||
static_assert(!std::is_pod<T>::value, "");
|
||||
static_assert(!std::is_pod<const T>::value, "");
|
||||
static_assert(!std::is_pod<volatile T>::value, "");
|
||||
static_assert(!std::is_pod<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_pod<void>();
|
||||
test_is_not_pod<int&>();
|
||||
test_is_not_pod<Class>();
|
||||
|
||||
test_is_pod<int>();
|
||||
test_is_pod<double>();
|
||||
test_is_pod<int*>();
|
||||
test_is_pod<const int*>();
|
||||
test_is_pod<char[3]>();
|
||||
test_is_pod<char[]>();
|
||||
}
|
@@ -0,0 +1,82 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_polymorphic
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_polymorphic()
|
||||
{
|
||||
static_assert( std::is_polymorphic<T>::value, "");
|
||||
static_assert( std::is_polymorphic<const T>::value, "");
|
||||
static_assert( std::is_polymorphic<volatile T>::value, "");
|
||||
static_assert( std::is_polymorphic<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_polymorphic()
|
||||
{
|
||||
static_assert(!std::is_polymorphic<T>::value, "");
|
||||
static_assert(!std::is_polymorphic<const T>::value, "");
|
||||
static_assert(!std::is_polymorphic<volatile T>::value, "");
|
||||
static_assert(!std::is_polymorphic<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
#if __has_feature(cxx_attributes)
|
||||
class Final final {
|
||||
};
|
||||
#else
|
||||
class Final {
|
||||
};
|
||||
#endif
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_polymorphic<void>();
|
||||
test_is_not_polymorphic<int&>();
|
||||
test_is_not_polymorphic<int>();
|
||||
test_is_not_polymorphic<double>();
|
||||
test_is_not_polymorphic<int*>();
|
||||
test_is_not_polymorphic<const int*>();
|
||||
test_is_not_polymorphic<char[3]>();
|
||||
test_is_not_polymorphic<char[]>();
|
||||
test_is_not_polymorphic<Union>();
|
||||
test_is_not_polymorphic<Empty>();
|
||||
test_is_not_polymorphic<bit_zero>();
|
||||
test_is_not_polymorphic<Final>();
|
||||
test_is_not_polymorphic<NotEmpty&>();
|
||||
test_is_not_polymorphic<Abstract&>();
|
||||
|
||||
test_is_polymorphic<NotEmpty>();
|
||||
test_is_polymorphic<Abstract>();
|
||||
}
|
@@ -0,0 +1,59 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_signed
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_signed()
|
||||
{
|
||||
static_assert( std::is_signed<T>::value, "");
|
||||
static_assert( std::is_signed<const T>::value, "");
|
||||
static_assert( std::is_signed<volatile T>::value, "");
|
||||
static_assert( std::is_signed<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_signed()
|
||||
{
|
||||
static_assert(!std::is_signed<T>::value, "");
|
||||
static_assert(!std::is_signed<const T>::value, "");
|
||||
static_assert(!std::is_signed<volatile T>::value, "");
|
||||
static_assert(!std::is_signed<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Class
|
||||
{
|
||||
public:
|
||||
~Class();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_signed<void>();
|
||||
test_is_not_signed<int&>();
|
||||
test_is_not_signed<Class>();
|
||||
test_is_not_signed<int*>();
|
||||
test_is_not_signed<const int*>();
|
||||
test_is_not_signed<char[3]>();
|
||||
test_is_not_signed<char[]>();
|
||||
test_is_not_signed<bool>();
|
||||
test_is_not_signed<unsigned>();
|
||||
|
||||
test_is_signed<int>();
|
||||
test_is_signed<double>();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_INT128
|
||||
test_is_signed<__int128_t>();
|
||||
test_is_not_signed<__uint128_t>();
|
||||
#endif
|
||||
}
|
@@ -0,0 +1,48 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_standard_layout
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_standard_layout()
|
||||
{
|
||||
static_assert( std::is_standard_layout<T>::value, "");
|
||||
static_assert( std::is_standard_layout<const T>::value, "");
|
||||
static_assert( std::is_standard_layout<volatile T>::value, "");
|
||||
static_assert( std::is_standard_layout<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_standard_layout()
|
||||
{
|
||||
static_assert(!std::is_standard_layout<T>::value, "");
|
||||
static_assert(!std::is_standard_layout<const T>::value, "");
|
||||
static_assert(!std::is_standard_layout<volatile T>::value, "");
|
||||
static_assert(!std::is_standard_layout<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T1, class T2>
|
||||
struct pair
|
||||
{
|
||||
T1 first;
|
||||
T2 second;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_standard_layout<int> ();
|
||||
test_is_standard_layout<int[3]> ();
|
||||
test_is_standard_layout<pair<int, double> > ();
|
||||
|
||||
test_is_not_standard_layout<int&> ();
|
||||
}
|
@@ -0,0 +1,50 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivial
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivial()
|
||||
{
|
||||
static_assert( std::is_trivial<T>::value, "");
|
||||
static_assert( std::is_trivial<const T>::value, "");
|
||||
static_assert( std::is_trivial<volatile T>::value, "");
|
||||
static_assert( std::is_trivial<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_trivial()
|
||||
{
|
||||
static_assert(!std::is_trivial<T>::value, "");
|
||||
static_assert(!std::is_trivial<const T>::value, "");
|
||||
static_assert(!std::is_trivial<volatile T>::value, "");
|
||||
static_assert(!std::is_trivial<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
struct A {};
|
||||
|
||||
class B
|
||||
{
|
||||
public:
|
||||
B();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_trivial<int> ();
|
||||
test_is_trivial<A> ();
|
||||
|
||||
test_is_not_trivial<int&> ();
|
||||
test_is_not_trivial<volatile int&> ();
|
||||
test_is_not_trivial<B> ();
|
||||
}
|
@@ -0,0 +1,53 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_trivially_assignable()
|
||||
{
|
||||
static_assert(( std::is_trivially_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
void test_is_not_trivially_assignable()
|
||||
{
|
||||
static_assert((!std::is_trivially_assignable<T, U>::value), "");
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
void operator=(A);
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
void operator=(C&); // not const
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_trivially_assignable<int&, int&> ();
|
||||
test_is_trivially_assignable<int&, int> ();
|
||||
test_is_trivially_assignable<int&, double> ();
|
||||
|
||||
test_is_not_trivially_assignable<int, int&> ();
|
||||
test_is_not_trivially_assignable<int, int> ();
|
||||
test_is_not_trivially_assignable<B, A> ();
|
||||
test_is_not_trivially_assignable<A, B> ();
|
||||
test_is_not_trivially_assignable<C&, C&> ();
|
||||
}
|
@@ -0,0 +1,61 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// template <class T, class... Args>
|
||||
// struct is_trivially_constructible;
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivially_constructible()
|
||||
{
|
||||
static_assert(( std::is_trivially_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_trivially_constructible()
|
||||
{
|
||||
static_assert(( std::is_trivially_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_trivially_constructible()
|
||||
{
|
||||
static_assert((!std::is_trivially_constructible<T>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0>
|
||||
void test_is_not_trivially_constructible()
|
||||
{
|
||||
static_assert((!std::is_trivially_constructible<T, A0>::value), "");
|
||||
}
|
||||
|
||||
template <class T, class A0, class A1>
|
||||
void test_is_not_trivially_constructible()
|
||||
{
|
||||
static_assert((!std::is_trivially_constructible<T, A0, A1>::value), "");
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
explicit A(int);
|
||||
A(int, double);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_trivially_constructible<int> ();
|
||||
test_is_trivially_constructible<int, const int&> ();
|
||||
|
||||
test_is_not_trivially_constructible<A, int> ();
|
||||
test_is_not_trivially_constructible<A, int, double> ();
|
||||
test_is_not_trivially_constructible<A> ();
|
||||
}
|
@@ -0,0 +1,71 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_copy_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_has_trivially_copy_assignable()
|
||||
{
|
||||
static_assert( std::is_trivially_copy_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_trivially_copy_assignable()
|
||||
{
|
||||
static_assert(!std::is_trivially_copy_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A& operator=(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_trivially_copy_assignable<int&>();
|
||||
test_has_trivially_copy_assignable<Union>();
|
||||
test_has_trivially_copy_assignable<Empty>();
|
||||
test_has_trivially_copy_assignable<int>();
|
||||
test_has_trivially_copy_assignable<double>();
|
||||
test_has_trivially_copy_assignable<int*>();
|
||||
test_has_trivially_copy_assignable<const int*>();
|
||||
test_has_trivially_copy_assignable<bit_zero>();
|
||||
|
||||
test_has_not_trivially_copy_assignable<void>();
|
||||
test_has_not_trivially_copy_assignable<A>();
|
||||
test_has_not_trivially_copy_assignable<NotEmpty>();
|
||||
test_has_not_trivially_copy_assignable<Abstract>();
|
||||
test_has_not_trivially_copy_assignable<const Empty>();
|
||||
|
||||
}
|
@@ -0,0 +1,73 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_copy_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivially_copy_constructible()
|
||||
{
|
||||
static_assert( std::is_trivially_copy_constructible<T>::value, "");
|
||||
static_assert( std::is_trivially_copy_constructible<const T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_trivial_copy_constructor()
|
||||
{
|
||||
static_assert(!std::is_trivially_copy_constructible<T>::value, "");
|
||||
static_assert(!std::is_trivially_copy_constructible<const T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
public:
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
public:
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_trivial_copy_constructor<void>();
|
||||
test_has_not_trivial_copy_constructor<A>();
|
||||
test_has_not_trivial_copy_constructor<Abstract>();
|
||||
test_has_not_trivial_copy_constructor<NotEmpty>();
|
||||
|
||||
test_is_trivially_copy_constructible<int&>();
|
||||
test_is_trivially_copy_constructible<Union>();
|
||||
test_is_trivially_copy_constructible<Empty>();
|
||||
test_is_trivially_copy_constructible<int>();
|
||||
test_is_trivially_copy_constructible<double>();
|
||||
test_is_trivially_copy_constructible<int*>();
|
||||
test_is_trivially_copy_constructible<const int*>();
|
||||
test_is_trivially_copy_constructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,63 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_copyable
|
||||
|
||||
#include <type_traits>
|
||||
#include <cassert>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivially_copyable()
|
||||
{
|
||||
static_assert( std::is_trivially_copyable<T>::value, "");
|
||||
static_assert( std::is_trivially_copyable<const T>::value, "");
|
||||
static_assert(!std::is_trivially_copyable<volatile T>::value, "");
|
||||
static_assert(!std::is_trivially_copyable<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_trivially_copyable()
|
||||
{
|
||||
static_assert(!std::is_trivially_copyable<T>::value, "");
|
||||
static_assert(!std::is_trivially_copyable<const T>::value, "");
|
||||
static_assert(!std::is_trivially_copyable<volatile T>::value, "");
|
||||
static_assert(!std::is_trivially_copyable<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
int i_;
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
int i_;
|
||||
~B() {assert(i_ == 0);}
|
||||
};
|
||||
|
||||
class C
|
||||
{
|
||||
public:
|
||||
C();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_trivially_copyable<int> ();
|
||||
test_is_trivially_copyable<const int> ();
|
||||
test_is_trivially_copyable<A> ();
|
||||
test_is_trivially_copyable<const A> ();
|
||||
test_is_trivially_copyable<C> ();
|
||||
|
||||
test_is_not_trivially_copyable<int&> ();
|
||||
test_is_not_trivially_copyable<const A&> ();
|
||||
test_is_not_trivially_copyable<B> ();
|
||||
}
|
@@ -0,0 +1,76 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_default_constructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivially_default_constructible()
|
||||
{
|
||||
static_assert( std::is_trivially_default_constructible<T>::value, "");
|
||||
static_assert( std::is_trivially_default_constructible<const T>::value, "");
|
||||
static_assert( std::is_trivially_default_constructible<volatile T>::value, "");
|
||||
static_assert( std::is_trivially_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_trivial_default_constructor()
|
||||
{
|
||||
static_assert(!std::is_trivially_default_constructible<T>::value, "");
|
||||
static_assert(!std::is_trivially_default_constructible<const T>::value, "");
|
||||
static_assert(!std::is_trivially_default_constructible<volatile T>::value, "");
|
||||
static_assert(!std::is_trivially_default_constructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_not_trivial_default_constructor<void>();
|
||||
test_has_not_trivial_default_constructor<int&>();
|
||||
test_has_not_trivial_default_constructor<A>();
|
||||
test_has_not_trivial_default_constructor<Abstract>();
|
||||
test_has_not_trivial_default_constructor<NotEmpty>();
|
||||
|
||||
test_is_trivially_default_constructible<Union>();
|
||||
test_is_trivially_default_constructible<Empty>();
|
||||
test_is_trivially_default_constructible<int>();
|
||||
test_is_trivially_default_constructible<double>();
|
||||
test_is_trivially_default_constructible<int*>();
|
||||
test_is_trivially_default_constructible<const int*>();
|
||||
test_is_trivially_default_constructible<char[3]>();
|
||||
test_is_trivially_default_constructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,83 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_destructible
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_is_trivially_destructible()
|
||||
{
|
||||
static_assert( std::is_trivially_destructible<T>::value, "");
|
||||
static_assert( std::is_trivially_destructible<const T>::value, "");
|
||||
static_assert( std::is_trivially_destructible<volatile T>::value, "");
|
||||
static_assert( std::is_trivially_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_is_not_trivially_destructible()
|
||||
{
|
||||
static_assert(!std::is_trivially_destructible<T>::value, "");
|
||||
static_assert(!std::is_trivially_destructible<const T>::value, "");
|
||||
static_assert(!std::is_trivially_destructible<volatile T>::value, "");
|
||||
static_assert(!std::is_trivially_destructible<const volatile T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
class AbstractDestructor
|
||||
{
|
||||
virtual ~AbstractDestructor() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
~A();
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_is_not_trivially_destructible<void>();
|
||||
test_is_not_trivially_destructible<A>();
|
||||
test_is_not_trivially_destructible<AbstractDestructor>();
|
||||
test_is_not_trivially_destructible<NotEmpty>();
|
||||
test_is_not_trivially_destructible<char[]>();
|
||||
|
||||
test_is_trivially_destructible<Abstract>();
|
||||
test_is_trivially_destructible<int&>();
|
||||
test_is_trivially_destructible<Union>();
|
||||
test_is_trivially_destructible<Empty>();
|
||||
test_is_trivially_destructible<int>();
|
||||
test_is_trivially_destructible<double>();
|
||||
test_is_trivially_destructible<int*>();
|
||||
test_is_trivially_destructible<const int*>();
|
||||
test_is_trivially_destructible<char[3]>();
|
||||
test_is_trivially_destructible<bit_zero>();
|
||||
}
|
@@ -0,0 +1,71 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// type_traits
|
||||
|
||||
// is_trivially_move_assignable
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
void test_has_trivial_assign()
|
||||
{
|
||||
static_assert( std::is_trivially_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_has_not_trivial_assign()
|
||||
{
|
||||
static_assert(!std::is_trivially_move_assignable<T>::value, "");
|
||||
}
|
||||
|
||||
class Empty
|
||||
{
|
||||
};
|
||||
|
||||
class NotEmpty
|
||||
{
|
||||
virtual ~NotEmpty();
|
||||
};
|
||||
|
||||
union Union {};
|
||||
|
||||
struct bit_zero
|
||||
{
|
||||
int : 0;
|
||||
};
|
||||
|
||||
class Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct A
|
||||
{
|
||||
A& operator=(const A&);
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test_has_trivial_assign<int&>();
|
||||
test_has_trivial_assign<Union>();
|
||||
test_has_trivial_assign<Empty>();
|
||||
test_has_trivial_assign<int>();
|
||||
test_has_trivial_assign<double>();
|
||||
test_has_trivial_assign<int*>();
|
||||
test_has_trivial_assign<const int*>();
|
||||
test_has_trivial_assign<bit_zero>();
|
||||
|
||||
test_has_not_trivial_assign<void>();
|
||||
test_has_not_trivial_assign<A>();
|
||||
test_has_not_trivial_assign<NotEmpty>();
|
||||
test_has_not_trivial_assign<Abstract>();
|
||||
test_has_not_trivial_assign<const Empty>();
|
||||
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user