darlinghq/darling-libcxx
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-libcxx.git synced 2024-11-27 05:40:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove more of the std::experimental bits that are now in std::. All the _v type aliases, conjunction/disjunction, apply, etc. See https://libcxx.llvm.org/TS_deprecation.html

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@324423 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Marshall Clow 2018-02-06 23:13:48 +00:00
parent c387931db5
commit 31810d9c0b
50 changed files with 4 additions and 3997 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
include/experimental/chrono
View File

@ -8,52 +8,4 @@
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_EXPERIMENTAL_CHRONO
#define _LIBCPP_EXPERIMENTAL_CHRONO
/**
experimental/chrono synopsis
// C++1y
#include <chrono>
namespace std {
namespace chrono {
namespace experimental {
inline namespace fundamentals_v1 {
// See C++14 20.12.4, customization traits
template <class Rep> constexpr bool treat_as_floating_point_v
= treat_as_floating_point<Rep>::value;
} // namespace fundamentals_v1
} // namespace experimental
} // namespace chrono
} // namespace std
*/
#include <experimental/__config>
#include <chrono>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 11
_LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS
#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
= treat_as_floating_point<_Rep>::value;
#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
_LIBCPP_END_NAMESPACE_CHRONO_LFTS
#endif /* _LIBCPP_STD_VER > 11 */
#endif /* _LIBCPP_EXPERIMENTAL_CHRONO */
#error "<experimental/chrono> has been removed. Use <chrono> instead."

68
include/experimental/ratio
View File

@ -8,70 +8,4 @@
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_EXPERIMENTAL_RATIO
#define _LIBCPP_EXPERIMENTAL_RATIO
/**
experimental/ratio synopsis
C++1y
#include <ratio>
namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
// See C++14 20.11.5, ratio comparison
template <class R1, class R2> constexpr bool ratio_equal_v
= ratio_equal<R1, R2>::value;
template <class R1, class R2> constexpr bool ratio_not_equal_v
= ratio_not_equal<R1, R2>::value;
template <class R1, class R2> constexpr bool ratio_less_v
= ratio_less<R1, R2>::value;
template <class R1, class R2> constexpr bool ratio_less_equal_v
= ratio_less_equal<R1, R2>::value;
template <class R1, class R2> constexpr bool ratio_greater_v
= ratio_greater<R1, R2>::value;
template <class R1, class R2> constexpr bool ratio_greater_equal_v
= ratio_greater_equal<R1, R2>::value;
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std
*/
#include <experimental/__config>
#if _LIBCPP_STD_VER > 11
#include <ratio>
_LIBCPP_BEGIN_NAMESPACE_LFTS
#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_equal_v
= ratio_equal<_R1, _R2>::value;
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_not_equal_v
= ratio_not_equal<_R1, _R2>::value;
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_v
= ratio_less<_R1, _R2>::value;
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_equal_v
= ratio_less_equal<_R1, _R2>::value;
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_v
= ratio_greater<_R1, _R2>::value;
template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v
= ratio_greater_equal<_R1, _R2>::value;
#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
_LIBCPP_END_NAMESPACE_LFTS
#endif /* _LIBCPP_STD_VER > 11 */
#endif // _LIBCPP_EXPERIMENTAL_RATIO
#error "<experimental/ratio> has been removed. Use <ratio> instead."

54
include/experimental/system_error
View File

@ -8,56 +8,4 @@
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
#define _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
/**
experimental/system_error synopsis
// C++1y
#include <system_error>
namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
// See C++14 19.5, System error support
template <class T> constexpr bool is_error_code_enum_v
= is_error_code_enum<T>::value;
template <class T> constexpr bool is_error_condition_enum_v
= is_error_condition_enum<T>::value;
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std
*/
#include <experimental/__config>
#if _LIBCPP_STD_VER > 11
#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_LFTS
#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_code_enum_v
= is_error_code_enum<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_condition_enum_v
= is_error_condition_enum<_Tp>::value;
#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
_LIBCPP_END_NAMESPACE_LFTS
#endif /* _LIBCPP_STD_VER > 11 */
#endif /* _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR */
#error "<experimental/system_error> has been removed. Use <system_error> instead."

73
include/experimental/tuple
View File

@ -8,75 +8,4 @@
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_EXPERIMENTAL_TUPLE
#define _LIBCPP_EXPERIMENTAL_TUPLE
/*
experimental/tuple synopsis
// C++1y
#include <tuple>
namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
// See C++14 20.4.2.5, tuple helper classes
template <class T> constexpr size_t tuple_size_v
= tuple_size<T>::value;
// 3.2.2, Calling a function with a tuple of arguments
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t);
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std
*/
# include <experimental/__config>
#if _LIBCPP_STD_VER > 11
# include <tuple>
# include <utility>
# include <__functional_base>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_LFTS
#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
template <class _Tp>
_LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value;
#endif
template <class _Fn, class _Tuple, size_t ..._Id>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11
decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
integer_sequence<size_t, _Id...>) {
return _VSTD::__invoke_constexpr(
_VSTD::forward<_Fn>(__f),
_VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...
);
}
template <class _Fn, class _Tuple>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
decltype(auto) apply(_Fn && __f, _Tuple && __t) {
return _VSTD_LFTS::__apply_tuple_impl(
_VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
make_index_sequence<tuple_size<typename decay<_Tuple>::type>::value>()
);
}
_LIBCPP_END_NAMESPACE_LFTS
#endif /* _LIBCPP_STD_VER > 11 */
#endif /* _LIBCPP_EXPERIMENTAL_TUPLE */
#error "<experimental/tuple> has been removed. Use <tuple> instead."

375
include/experimental/type_traits
View File

@ -21,146 +21,6 @@ namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
// See C++14 20.10.4.1, primary type categories
template <class T> constexpr bool is_void_v
= is_void<T>::value;
template <class T> constexpr bool is_null_pointer_v
= is_null_pointer<T>::value;
template <class T> constexpr bool is_integral_v
= is_integral<T>::value;
template <class T> constexpr bool is_floating_point_v
= is_floating_point<T>::value;
template <class T> constexpr bool is_array_v
= is_array<T>::value;
template <class T> constexpr bool is_pointer_v
= is_pointer<T>::value;
template <class T> constexpr bool is_lvalue_reference_v
= is_lvalue_reference<T>::value;
template <class T> constexpr bool is_rvalue_reference_v
= is_rvalue_reference<T>::value;
template <class T> constexpr bool is_member_object_pointer_v
= is_member_object_pointer<T>::value;
template <class T> constexpr bool is_member_function_pointer_v
= is_member_function_pointer<T>::value;
template <class T> constexpr bool is_enum_v
= is_enum<T>::value;
template <class T> constexpr bool is_union_v
= is_union<T>::value;
template <class T> constexpr bool is_class_v
= is_class<T>::value;
template <class T> constexpr bool is_function_v
= is_function<T>::value;
// See C++14 20.10.4.2, composite type categories
template <class T> constexpr bool is_reference_v
= is_reference<T>::value;
template <class T> constexpr bool is_arithmetic_v
= is_arithmetic<T>::value;
template <class T> constexpr bool is_fundamental_v
= is_fundamental<T>::value;
template <class T> constexpr bool is_object_v
= is_object<T>::value;
template <class T> constexpr bool is_scalar_v
= is_scalar<T>::value;
template <class T> constexpr bool is_compound_v
= is_compound<T>::value;
template <class T> constexpr bool is_member_pointer_v
= is_member_pointer<T>::value;
// See C++14 20.10.4.3, type properties
template <class T> constexpr bool is_const_v
= is_const<T>::value;
template <class T> constexpr bool is_volatile_v
= is_volatile<T>::value;
template <class T> constexpr bool is_trivial_v
= is_trivial<T>::value;
template <class T> constexpr bool is_trivially_copyable_v
= is_trivially_copyable<T>::value;
template <class T> constexpr bool is_standard_layout_v
= is_standard_layout<T>::value;
template <class T> constexpr bool is_pod_v
= is_pod<T>::value;
template <class T> constexpr bool is_literal_type_v
= is_literal_type<T>::value;
template <class T> constexpr bool is_empty_v
= is_empty<T>::value;
template <class T> constexpr bool is_polymorphic_v
= is_polymorphic<T>::value;
template <class T> constexpr bool is_abstract_v
= is_abstract<T>::value;
template <class T> constexpr bool is_final_v
= is_final<T>::value;
template <class T> constexpr bool is_signed_v
= is_signed<T>::value;
template <class T> constexpr bool is_unsigned_v
= is_unsigned<T>::value;
template <class T, class... Args> constexpr bool is_constructible_v
= is_constructible<T, Args...>::value;
template <class T> constexpr bool is_default_constructible_v
= is_default_constructible<T>::value;
template <class T> constexpr bool is_copy_constructible_v
= is_copy_constructible<T>::value;
template <class T> constexpr bool is_move_constructible_v
= is_move_constructible<T>::value;
template <class T, class U> constexpr bool is_assignable_v
= is_assignable<T, U>::value;
template <class T> constexpr bool is_copy_assignable_v
= is_copy_assignable<T>::value;
template <class T> constexpr bool is_move_assignable_v
= is_move_assignable<T>::value;
template <class T> constexpr bool is_destructible_v
= is_destructible<T>::value;
template <class T, class... Args> constexpr bool is_trivially_constructible_v
= is_trivially_constructible<T, Args...>::value;
template <class T> constexpr bool is_trivially_default_constructible_v
= is_trivially_default_constructible<T>::value;
template <class T> constexpr bool is_trivially_copy_constructible_v
= is_trivially_copy_constructible<T>::value;
template <class T> constexpr bool is_trivially_move_constructible_v
= is_trivially_move_constructible<T>::value;
template <class T, class U> constexpr bool is_trivially_assignable_v
= is_trivially_assignable<T, U>::value;
template <class T> constexpr bool is_trivially_copy_assignable_v
= is_trivially_copy_assignable<T>::value;
template <class T> constexpr bool is_trivially_move_assignable_v
= is_trivially_move_assignable<T>::value;
template <class T> constexpr bool is_trivially_destructible_v
= is_trivially_destructible<T>::value;
template <class T, class... Args> constexpr bool is_nothrow_constructible_v
= is_nothrow_constructible<T, Args...>::value;
template <class T> constexpr bool is_nothrow_default_constructible_v
= is_nothrow_default_constructible<T>::value;
template <class T> constexpr bool is_nothrow_copy_constructible_v
= is_nothrow_copy_constructible<T>::value;
template <class T> constexpr bool is_nothrow_move_constructible_v
= is_nothrow_move_constructible<T>::value;
template <class T, class U> constexpr bool is_nothrow_assignable_v
= is_nothrow_assignable<T, U>::value;
template <class T> constexpr bool is_nothrow_copy_assignable_v
= is_nothrow_copy_assignable<T>::value;
template <class T> constexpr bool is_nothrow_move_assignable_v
= is_nothrow_move_assignable<T>::value;
template <class T> constexpr bool is_nothrow_destructible_v
= is_nothrow_destructible<T>::value;
template <class T> constexpr bool has_virtual_destructor_v
= has_virtual_destructor<T>::value;
// See C++14 20.10.5, type property queries
template <class T> constexpr size_t alignment_of_v
= alignment_of<T>::value;
template <class T> constexpr size_t rank_v
= rank<T>::value;
template <class T, unsigned I = 0> constexpr size_t extent_v
= extent<T, I>::value;
// See C++14 20.10.6, type relations
template <class T, class U> constexpr bool is_same_v
= is_same<T, U>::value;
template <class Base, class Derived> constexpr bool is_base_of_v
= is_base_of<Base, Derived>::value;
template <class From, class To> constexpr bool is_convertible_v
= is_convertible<From, To>::value;
// 3.3.2, Other type transformations
template <class> class invocation_type; // not defined
template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>;
@ -172,14 +32,6 @@ inline namespace fundamentals_v1 {
template <class T>
using raw_invocation_type_t = typename raw_invocation_type<T>::type;
// 3.3.3, Logical operator traits
template<class... B> struct conjunction;
template<class... B> constexpr bool conjunction_v = conjunction<B...>::value;
template<class... B> struct disjunction;
template<class... B> constexpr bool disjunction_v = disjunction<B...>::value;
template<class B> struct negation;
template<class B> constexpr bool negation_v = negation<B>::value;
// 3.3.4, Detection idiom
template <class...> using void_t = void;
@ -229,215 +81,6 @@ inline namespace fundamentals_v1 {
_LIBCPP_BEGIN_NAMESPACE_LFTS
#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
// C++14 20.10.4.1, primary type categories
template <class _Tp> _LIBCPP_CONSTEXPR bool is_void_v
= is_void<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_null_pointer_v
= is_null_pointer<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_integral_v
= is_integral<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_floating_point_v
= is_floating_point<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_array_v
= is_array<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_pointer_v
= is_pointer<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
= is_lvalue_reference<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
= is_rvalue_reference<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
= is_member_object_pointer<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
= is_member_function_pointer<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_enum_v
= is_enum<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_union_v
= is_union<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_class_v
= is_class<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_function_v
= is_function<_Tp>::value;
// C++14 20.10.4.2, composite type categories
template <class _Tp> _LIBCPP_CONSTEXPR bool is_reference_v
= is_reference<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_arithmetic_v
= is_arithmetic<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_fundamental_v
= is_fundamental<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_object_v
= is_object<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_scalar_v
= is_scalar<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_compound_v
= is_compound<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_pointer_v
= is_member_pointer<_Tp>::value;
// C++14 20.10.4.3, type properties
template <class _Tp> _LIBCPP_CONSTEXPR bool is_const_v
= is_const<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_volatile_v
= is_volatile<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivial_v
= is_trivial<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copyable_v
= is_trivially_copyable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_standard_layout_v
= is_standard_layout<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_pod_v
= is_pod<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_literal_type_v
= is_literal_type<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_empty_v
= is_empty<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_polymorphic_v
= is_polymorphic<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_abstract_v
= is_abstract<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_final_v
= is_final<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_signed_v
= is_signed<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_unsigned_v
= is_unsigned<_Tp>::value;
template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_constructible_v
= is_constructible<_Tp, _Ts...>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_default_constructible_v
= is_default_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_constructible_v
= is_copy_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_constructible_v
= is_move_constructible<_Tp>::value;
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_assignable_v
= is_assignable<_Tp, _Up>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_assignable_v
= is_copy_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_assignable_v
= is_move_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_destructible_v
= is_destructible<_Tp>::value;
template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_trivially_constructible_v
= is_trivially_constructible<_Tp, _Ts...>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_default_constructible_v
= is_trivially_default_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_constructible_v
= is_trivially_copy_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_constructible_v
= is_trivially_move_constructible<_Tp>::value;
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_trivially_assignable_v
= is_trivially_assignable<_Tp, _Up>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_assignable_v
= is_trivially_copy_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_assignable_v
= is_trivially_move_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_destructible_v
= is_trivially_destructible<_Tp>::value;
template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_nothrow_constructible_v
= is_nothrow_constructible<_Tp, _Ts...>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_default_constructible_v
= is_nothrow_default_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_constructible_v
= is_nothrow_copy_constructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_constructible_v
= is_nothrow_move_constructible<_Tp>::value;
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_nothrow_assignable_v
= is_nothrow_assignable<_Tp, _Up>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_assignable_v
= is_nothrow_copy_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_assignable_v
= is_nothrow_move_assignable<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_destructible_v
= is_nothrow_destructible<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR bool has_virtual_destructor_v
= has_virtual_destructor<_Tp>::value;
// C++14 20.10.5, type properties queries
template <class _Tp> _LIBCPP_CONSTEXPR size_t alignment_of_v
= alignment_of<_Tp>::value;
template <class _Tp> _LIBCPP_CONSTEXPR size_t rank_v
= rank<_Tp>::value;
template <class _Tp, unsigned _Id = 0> _LIBCPP_CONSTEXPR size_t extent_v
= extent<_Tp, _Id>::value;
// C++14 20.10.6, type relations
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_same_v
= is_same<_Tp, _Up>::value;
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_base_of_v
= is_base_of<_Tp, _Up>::value;
template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_convertible_v
= is_convertible<_Tp, _Up>::value;
#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
// 3.3.2, Other type transformations
/*
template <class>
@ -459,24 +102,6 @@ template <class _Tp>
using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
*/
// 3.3.3, Logical operator traits
template <class...> using void_t = void;
template <class... _Args>
struct conjunction : _VSTD::__and_<_Args...> {};
template <class... _Args>
_LIBCPP_CONSTEXPR bool conjunction_v = conjunction<_Args...>::value;
template <class... _Args>
struct disjunction : _VSTD::__or_<_Args...> {};
template <class... _Args>
_LIBCPP_CONSTEXPR bool disjunction_v = disjunction<_Args...>::value;
template <class _Tp>
struct negation : _VSTD::__not_<_Tp> {};
template<class _Tp>
_LIBCPP_CONSTEXPR bool negation_v = negation<_Tp>::value;
// 3.3.4, Detection idiom
template <class...> using void_t = void;

16
include/module.modulemap
View File

@ -492,10 +492,6 @@ module std [system] {
module algorithm {
header "experimental/algorithm"
export *
}
module chrono {
header "experimental/chrono"
export *
}
module coroutine {
requires coroutines
@ -542,10 +538,6 @@ module std [system] {
header "experimental/propagate_const"
export *
}
module ratio {
header "experimental/ratio"
export *
}
module regex {
header "experimental/regex"
export *
@ -558,14 +550,6 @@ module std [system] {
header "experimental/string"
export *
}
module system_error {
header "experimental/system_error"
export *
}
module tuple {
header "experimental/tuple"
export *
}
module type_traits {
header "experimental/type_traits"
export *

4
test/libcxx/double_include.sh.cpp
View File

@ -135,7 +135,6 @@
// experimental headers
#if __cplusplus >= 201103L
#include <experimental/algorithm>
#include <experimental/chrono>
#if defined(__cpp_coroutines)
#include <experimental/coroutine>
#endif
@ -149,12 +148,9 @@
#include <experimental/map>
#include <experimental/memory_resource>
#include <experimental/propagate_const>
#include <experimental/ratio>
#include <experimental/regex>
#include <experimental/set>
#include <experimental/string>
#include <experimental/system_error>
#include <experimental/tuple>
#include <experimental/type_traits>
#include <experimental/unordered_map>
#include <experimental/unordered_set>

23
test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
View File

@ -1,23 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// Test that <ratio> is included.
#include <experimental/ratio>
#ifndef _LIBCPP_RATIO
# error " <experimental/ratio> must include <ratio>"
#endif
int main()
{
}

20
test/libcxx/experimental/utilities/ratio/version.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <experimental/ratio>
#include <experimental/ratio>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}

21
test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
View File

@ -1,21 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/system_error>
#include <experimental/system_error>
#ifndef _LIBCPP_SYSTEM_ERROR
# error "<experimental/system_error> must include <system_error>"
#endif
int main()
{
}

20
test/libcxx/experimental/utilities/syserror/version.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <experimental/system_error>
#include <experimental/system_error>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}

21
test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
View File

@ -1,21 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/chrono>
#include <experimental/chrono>
#ifndef _LIBCPP_CHRONO
# error "<experimental/chrono> must include <chrono>"
#endif
int main()
{
}

20
test/libcxx/experimental/utilities/time/version.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <experimental/chrono>
#include <experimental/chrono>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}

20
test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
#include <experimental/tuple>
int main()
{
#ifndef _LIBCPP_TUPLE
# error "<experimental/tuple> must include <tuple>"
#endif
}

20
test/libcxx/experimental/utilities/tuple/version.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <experimental/tuple>
#include <experimental/tuple>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}

8
test/libcxx/min_max_macros.sh.cpp
View File

@ -237,8 +237,6 @@ TEST_MACROS();
#if __cplusplus >= 201103L
#include <experimental/algorithm>
TEST_MACROS();
#include <experimental/chrono>
TEST_MACROS();
#include <experimental/deque>
TEST_MACROS();
#include <experimental/dynarray>
@ -259,18 +257,12 @@ TEST_MACROS();
TEST_MACROS();
#include <experimental/propagate_const>
TEST_MACROS();
#include <experimental/ratio>
TEST_MACROS();
#include <experimental/regex>
TEST_MACROS();
#include <experimental/set>
TEST_MACROS();
#include <experimental/string>
TEST_MACROS();
#include <experimental/system_error>
TEST_MACROS();
#include <experimental/tuple>
TEST_MACROS();
#include <experimental/type_traits>
TEST_MACROS();
#include <experimental/unordered_map>

68
test/std/experimental/utilities/meta/meta.logical/conjunction.pass.cpp
View File

@ -1,68 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
// template<class... B> struct conjunction; // C++17
// template<class... B>
// constexpr bool conjunction_v = conjunction<B...>::value; // C++17
#include <experimental/type_traits>
#include <cassert>
namespace ex = std::experimental;
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
int main()
{
static_assert ( ex::conjunction<>::value, "" );
static_assert ( ex::conjunction<std::true_type >::value, "" );
static_assert (!ex::conjunction<std::false_type>::value, "" );
static_assert ( ex::conjunction_v<>, "" );
static_assert ( ex::conjunction_v<std::true_type >, "" );
static_assert (!ex::conjunction_v<std::false_type>, "" );
static_assert ( ex::conjunction<std::true_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::true_type, std::false_type>::value, "" );
static_assert (!ex::conjunction<std::false_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::false_type, std::false_type>::value, "" );
static_assert ( ex::conjunction_v<std::true_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::true_type, std::false_type>, "" );
static_assert (!ex::conjunction_v<std::false_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::false_type, std::false_type>, "" );
static_assert ( ex::conjunction<std::true_type, std::true_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::true_type, std::false_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::false_type, std::true_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::false_type, std::false_type, std::true_type >::value, "" );
static_assert (!ex::conjunction<std::true_type, std::true_type, std::false_type>::value, "" );
static_assert (!ex::conjunction<std::true_type, std::false_type, std::false_type>::value, "" );
static_assert (!ex::conjunction<std::false_type, std::true_type, std::false_type>::value, "" );
static_assert (!ex::conjunction<std::false_type, std::false_type, std::false_type>::value, "" );
static_assert ( ex::conjunction_v<std::true_type, std::true_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::true_type, std::false_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::false_type, std::true_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::false_type, std::false_type, std::true_type >, "" );
static_assert (!ex::conjunction_v<std::true_type, std::true_type, std::false_type>, "" );
static_assert (!ex::conjunction_v<std::true_type, std::false_type, std::false_type>, "" );
static_assert (!ex::conjunction_v<std::false_type, std::true_type, std::false_type>, "" );
static_assert (!ex::conjunction_v<std::false_type, std::false_type, std::false_type>, "" );
static_assert ( ex::conjunction<True >::value, "" );
static_assert (!ex::conjunction<False>::value, "" );
static_assert ( ex::conjunction_v<True >, "" );
static_assert (!ex::conjunction_v<False>, "" );
}

68
test/std/experimental/utilities/meta/meta.logical/disjunction.pass.cpp
View File

@ -1,68 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
// template<class... B> struct disjunction;
// template<class... B>
// constexpr bool disjunction_v = disjunction<B...>::value;
#include <experimental/type_traits>
#include <cassert>
namespace ex = std::experimental;
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
int main()
{
static_assert (!ex::disjunction<>::value, "" );
static_assert ( ex::disjunction<std::true_type >::value, "" );
static_assert (!ex::disjunction<std::false_type>::value, "" );
static_assert (!ex::disjunction_v<>, "" );
static_assert ( ex::disjunction_v<std::true_type >, "" );
static_assert (!ex::disjunction_v<std::false_type>, "" );
static_assert ( ex::disjunction<std::true_type, std::true_type >::value, "" );
static_assert ( ex::disjunction<std::true_type, std::false_type>::value, "" );
static_assert ( ex::disjunction<std::false_type, std::true_type >::value, "" );
static_assert (!ex::disjunction<std::false_type, std::false_type>::value, "" );
static_assert ( ex::disjunction_v<std::true_type, std::true_type >, "" );
static_assert ( ex::disjunction_v<std::true_type, std::false_type>, "" );
static_assert ( ex::disjunction_v<std::false_type, std::true_type >, "" );
static_assert (!ex::disjunction_v<std::false_type, std::false_type>, "" );
static_assert ( ex::disjunction<std::true_type, std::true_type, std::true_type >::value, "" );
static_assert ( ex::disjunction<std::true_type, std::false_type, std::true_type >::value, "" );
static_assert ( ex::disjunction<std::false_type, std::true_type, std::true_type >::value, "" );
static_assert ( ex::disjunction<std::false_type, std::false_type, std::true_type >::value, "" );
static_assert ( ex::disjunction<std::true_type, std::true_type, std::false_type>::value, "" );
static_assert ( ex::disjunction<std::true_type, std::false_type, std::false_type>::value, "" );
static_assert ( ex::disjunction<std::false_type, std::true_type, std::false_type>::value, "" );
static_assert (!ex::disjunction<std::false_type, std::false_type, std::false_type>::value, "" );
static_assert ( ex::disjunction_v<std::true_type, std::true_type, std::true_type >, "" );
static_assert ( ex::disjunction_v<std::true_type, std::false_type, std::true_type >, "" );
static_assert ( ex::disjunction_v<std::false_type, std::true_type, std::true_type >, "" );
static_assert ( ex::disjunction_v<std::false_type, std::false_type, std::true_type >, "" );
static_assert ( ex::disjunction_v<std::true_type, std::true_type, std::false_type>, "" );
static_assert ( ex::disjunction_v<std::true_type, std::false_type, std::false_type>, "" );
static_assert ( ex::disjunction_v<std::false_type, std::true_type, std::false_type>, "" );
static_assert (!ex::disjunction_v<std::false_type, std::false_type, std::false_type>, "" );
static_assert ( ex::disjunction<True >::value, "" );
static_assert (!ex::disjunction<False>::value, "" );
static_assert ( ex::disjunction_v<True >, "" );
static_assert (!ex::disjunction_v<False>, "" );
}

41
test/std/experimental/utilities/meta/meta.logical/negation.pass.cpp
View File

@ -1,41 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
// template<class B> struct negation;
// template<class B>
// constexpr bool negation_v = negation<B>::value;
#include <experimental/type_traits>
#include <cassert>
namespace ex = std::experimental;
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
int main()
{
static_assert (!ex::negation<std::true_type >::value, "" );
static_assert ( ex::negation<std::false_type>::value, "" );
static_assert (!ex::negation_v<std::true_type >, "" );
static_assert ( ex::negation_v<std::false_type>, "" );
static_assert (!ex::negation<True >::value, "" );
static_assert ( ex::negation<False>::value, "" );
static_assert (!ex::negation_v<True >, "" );
static_assert ( ex::negation_v<False>, "" );
static_assert ( ex::negation<ex::negation<std::true_type >>::value, "" );
static_assert (!ex::negation<ex::negation<std::false_type>>::value, "" );
}

21
test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
View File

@ -1,21 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
#include <experimental/type_traits>
#ifndef _LIBCPP_TYPE_TRAITS
# error "<experimental/type_traits> must include <type_traits>"
#endif
int main()
{
}

62
test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
View File

@ -1,62 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
#include <experimental/type_traits>
namespace ex = std::experimental;
struct base_type {};
struct derived_type : base_type {};
int main()
{
{
typedef int T;
typedef int U;
static_assert(ex::is_same_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_same_v<T, U>), const bool>::value, "");
static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
}
{
typedef int T;
typedef long U;
static_assert(!ex::is_same_v<T, U>, "");
static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
}
{
typedef base_type T;
typedef derived_type U;
static_assert(ex::is_base_of_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_base_of_v<T, U>), const bool>::value, "");
static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
}
{
typedef int T;
typedef int U;
static_assert(!ex::is_base_of_v<T, U>, "");
static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
}
{
typedef int T;
typedef long U;
static_assert(ex::is_convertible_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_convertible_v<T, U>), const bool>::value, "");
static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
}
{
typedef void T;
typedef int U;
static_assert(!ex::is_convertible_v<T, U>, "");
static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
}
}

178
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
View File

@ -1,178 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
#include <experimental/type_traits>
namespace ex = std::experimental;
struct class_type {};
enum enum_type {};
union union_type {};
int main()
{
{
typedef void T;
static_assert(ex::is_void_v<T>, "");
static_assert(std::is_same<decltype(ex::is_void_v<T>), const bool>::value, "");
static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_void_v<T>, "");
static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
}
{
typedef decltype(nullptr) T;
static_assert(ex::is_null_pointer_v<T>, "");
static_assert(std::is_same<decltype(ex::is_null_pointer_v<T>), const bool>::value, "");
static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_null_pointer_v<T>, "");
static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_integral_v<T>, "");
static_assert(std::is_same<decltype(ex::is_integral_v<T>), const bool>::value, "");
static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_integral_v<T>, "");
static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
}
{
typedef float T;
static_assert(ex::is_floating_point_v<T>, "");
static_assert(std::is_same<decltype(ex::is_floating_point_v<T>), const bool>::value, "");
static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_floating_point_v<T>, "");
static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
}
{
typedef int(T)[42];
static_assert(ex::is_array_v<T>, "");
static_assert(std::is_same<decltype(ex::is_array_v<T>), const bool>::value, "");
static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_array_v<T>, "");
static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
}
{
typedef void* T;
static_assert(ex::is_pointer_v<T>, "");
static_assert(std::is_same<decltype(ex::is_pointer_v<T>), const bool>::value, "");
static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_pointer_v<T>, "");
static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
}
{
typedef int & T;
static_assert(ex::is_lvalue_reference_v<T>, "");
static_assert(std::is_same<decltype(ex::is_lvalue_reference_v<T>), const bool>::value, "");
static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_lvalue_reference_v<T>, "");
static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
}
{
typedef int && T;
static_assert(ex::is_rvalue_reference_v<T>, "");
static_assert(std::is_same<decltype(ex::is_rvalue_reference_v<T>), const bool>::value, "");
static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_rvalue_reference_v<T>, "");
static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
}
{
typedef int class_type::*T;
static_assert(ex::is_member_object_pointer_v<T>, "");
static_assert(std::is_same<decltype(ex::is_member_object_pointer_v<T>), const bool>::value, "");
static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_member_object_pointer_v<T>, "");
static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
}
{
typedef void(class_type::*T)();
static_assert(ex::is_member_function_pointer_v<T>, "");
static_assert(std::is_same<decltype(ex::is_member_function_pointer_v<T>), const bool>::value, "");
static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_member_function_pointer_v<T>, "");
static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
}
{
typedef enum_type T;
static_assert(ex::is_enum_v<T>, "");
static_assert(std::is_same<decltype(ex::is_enum_v<T>), const bool>::value, "");
static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_enum_v<T>, "");
static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
}
{
typedef union_type T;
static_assert(ex::is_union_v<T>, "");
static_assert(std::is_same<decltype(ex::is_union_v<T>), const bool>::value, "");
static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_union_v<T>, "");
static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
}
{
typedef class_type T;
static_assert(ex::is_class_v<T>, "");
static_assert(std::is_same<decltype(ex::is_class_v<T>), const bool>::value, "");
static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_class_v<T>, "");
static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
}
{
typedef void(T)();
static_assert(ex::is_function_v<T>, "");
static_assert(std::is_same<decltype(ex::is_function_v<T>), const bool>::value, "");
static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_function_v<T>, "");
static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
}
}

99
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
View File

@ -1,99 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
#include <experimental/type_traits>
namespace ex = std::experimental;
struct class_type {};
int main()
{
{
typedef int & T;
static_assert(ex::is_reference_v<T>, "");
static_assert(std::is_same<decltype(ex::is_reference_v<T>), const bool>::value, "");
static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_reference_v<T>, "");
static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_arithmetic_v<T>, "");
static_assert(std::is_same<decltype(ex::is_arithmetic_v<T>), const bool>::value, "");
static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
}
{
typedef void* T;
static_assert(!ex::is_arithmetic_v<T>, "");
static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_fundamental_v<T>, "");
static_assert(std::is_same<decltype(ex::is_fundamental_v<T>), const bool>::value, "");
static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
}
{
typedef class_type T;
static_assert(!ex::is_fundamental_v<T>, "");
static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
}
{
typedef class_type T;
static_assert(ex::is_object_v<T>, "");
static_assert(std::is_same<decltype(ex::is_object_v<T>), const bool>::value, "");
static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_object_v<T>, "");
static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_scalar_v<T>, "");
static_assert(std::is_same<decltype(ex::is_scalar_v<T>), const bool>::value, "");
static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_scalar_v<T>, "");
static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
}
{
typedef void* T;
static_assert(ex::is_compound_v<T>, "");
static_assert(std::is_same<decltype(ex::is_compound_v<T>), const bool>::value, "");
static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_compound_v<T>, "");
static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
}
{
typedef int class_type::*T;
static_assert(ex::is_member_pointer_v<T>, "");
static_assert(std::is_same<decltype(ex::is_member_pointer_v<T>), const bool>::value, "");
static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_member_pointer_v<T>, "");
static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
}
}

492
test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
View File

@ -1,492 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// GCC returns true for __is_trivially_constructible(void, int)
// See gcc.gnu.org/PR80682
// NOTE: This has been fixed in trunk and will be backported soon.
// XFAIL: gcc-7, gcc-6, gcc-5, gcc-4
// <experimental/type_traits>
#include <experimental/type_traits>
namespace ex = std::experimental;
struct non_literal_type { non_literal_type() {} };
struct empty_type {};
struct polymorphic_type
{
virtual void foo() {}
};
struct abstract_type
{
virtual void foo() = 0;
};
struct final_type final {};
struct virtual_dtor_type
{
virtual ~virtual_dtor_type() {}
};
void type_properties_test()
{
{
typedef const int T;
static_assert(ex::is_const_v<T>, "");
static_assert(std::is_same<decltype(ex::is_const_v<T>), const bool>::value, "");
static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_const_v<T>, "");
static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
}
{
typedef volatile int T;
static_assert(ex::is_volatile_v<T>, "");
static_assert(std::is_same<decltype(ex::is_volatile_v<T>), const bool>::value, "");
static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_volatile_v<T>, "");
static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivial_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivial_v<T>), const bool>::value, "");
static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_trivial_v<T>, "");
static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_copyable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_copyable_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_trivially_copyable_v<T>, "");
static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_standard_layout_v<T>, "");
static_assert(std::is_same<decltype(ex::is_standard_layout_v<T>), const bool>::value, "");
static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_standard_layout_v<T>, "");
static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_pod_v<T>, "");
static_assert(std::is_same<decltype(ex::is_pod_v<T>), const bool>::value, "");
static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_pod_v<T>, "");
static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_literal_type_v<T>, "");
static_assert(std::is_same<decltype(ex::is_literal_type_v<T>), const bool>::value, "");
static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
}
{
typedef non_literal_type T;
static_assert(!ex::is_literal_type_v<T>, "");
static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
}
{
typedef empty_type T;
static_assert(ex::is_empty_v<T>, "");
static_assert(std::is_same<decltype(ex::is_empty_v<T>), const bool>::value, "");
static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_empty_v<T>, "");
static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
}
{
typedef polymorphic_type T;
static_assert(ex::is_polymorphic_v<T>, "");
static_assert(std::is_same<decltype(ex::is_polymorphic_v<T>), const bool>::value, "");
static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_polymorphic_v<T>, "");
static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
}
{
typedef abstract_type T;
static_assert(ex::is_abstract_v<T>, "");
static_assert(std::is_same<decltype(ex::is_abstract_v<T>), const bool>::value, "");
static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_abstract_v<T>, "");
static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
}
{
typedef final_type T;
static_assert(ex::is_final_v<T>, "");
static_assert(std::is_same<decltype(ex::is_final_v<T>), const bool>::value, "");
static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_final_v<T>, "");
static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_signed_v<T>, "");
static_assert(std::is_same<decltype(ex::is_signed_v<T>), const bool>::value, "");
static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
}
{
typedef unsigned T;
static_assert(!ex::is_signed_v<T>, "");
static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
}
{
typedef unsigned T;
static_assert(ex::is_unsigned_v<T>, "");
static_assert(std::is_same<decltype(ex::is_unsigned_v<T>), const bool>::value, "");
static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
}
{
typedef int T;
static_assert(!ex::is_unsigned_v<T>, "");
static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
}
}
void is_constructible_and_assignable_test()
{
{
typedef int T;
static_assert(ex::is_constructible_v<T, int>, "");
static_assert(std::is_same<decltype(ex::is_constructible_v<T, int>), const bool>::value, "");
static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef void T;
static_assert(!ex::is_constructible_v<T, int>, "");
static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef int T;
static_assert(ex::is_default_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_default_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_default_constructible_v<T>, "");
static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_copy_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_copy_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_copy_constructible_v<T>, "");
static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_move_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_move_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_move_constructible_v<T>, "");
static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef int & T;
typedef int U;
static_assert(ex::is_assignable_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_assignable_v<T, U>), const bool>::value, "");
static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int & T;
typedef void U;
static_assert(!ex::is_assignable_v<T, U>, "");
static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int T;
static_assert(ex::is_copy_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_copy_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_copy_assignable_v<T>, "");
static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_move_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_move_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_move_assignable_v<T>, "");
static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_destructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_destructible_v<T>), const bool>::value, "");
static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_destructible_v<T>, "");
static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
}
}
void is_trivially_constructible_and_assignable_test()
{
{
typedef int T;
static_assert(ex::is_trivially_constructible_v<T, int>, "");
static_assert(std::is_same<decltype(ex::is_trivially_constructible_v<T, int>), const bool>::value, "");
static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_constructible_v<T, int>, "");
static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_default_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_default_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_trivially_default_constructible_v<T>, "");
static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_copy_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_copy_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_copy_constructible_v<T>, "");
static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_move_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_move_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_move_constructible_v<T>, "");
static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef int & T;
typedef int U;
static_assert(ex::is_trivially_assignable_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_trivially_assignable_v<T, U>), const bool>::value, "");
static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int & T;
typedef void U;
static_assert(!ex::is_trivially_assignable_v<T, U>, "");
static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_copy_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_copy_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_copy_assignable_v<T>, "");
static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_move_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_move_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_move_assignable_v<T>, "");
static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_trivially_destructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_trivially_destructible_v<T>), const bool>::value, "");
static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_trivially_destructible_v<T>, "");
static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
}
}
void is_nothrow_constructible_and_assignable_test()
{
{
typedef int T;
static_assert(ex::is_nothrow_constructible_v<T, int>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_constructible_v<T, int>), const bool>::value, "");
static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_constructible_v<T, int>, "");
static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_default_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_default_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int & T;
static_assert(!ex::is_nothrow_default_constructible_v<T>, "");
static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_copy_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_copy_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_copy_constructible_v<T>, "");
static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_move_constructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_move_constructible_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_move_constructible_v<T>, "");
static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
}
{
typedef int & T;
typedef int U;
static_assert(ex::is_nothrow_assignable_v<T, U>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_assignable_v<T, U>), const bool>::value, "");
static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int & T;
typedef void U;
static_assert(!ex::is_nothrow_assignable_v<T, U>, "");
static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_copy_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_copy_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_copy_assignable_v<T>, "");
static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_move_assignable_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_move_assignable_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_move_assignable_v<T>, "");
static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
}
{
typedef int T;
static_assert(ex::is_nothrow_destructible_v<T>, "");
static_assert(std::is_same<decltype(ex::is_nothrow_destructible_v<T>), const bool>::value, "");
static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
}
{
typedef void T;
static_assert(!ex::is_nothrow_destructible_v<T>, "");
static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
}
}
int main()
{
type_properties_test();
is_constructible_and_assignable_test();
is_trivially_constructible_and_assignable_test();
is_nothrow_constructible_and_assignable_test();
{
typedef virtual_dtor_type T;
static_assert(ex::has_virtual_destructor_v<T>, "");
static_assert(std::is_same<decltype(ex::has_virtual_destructor_v<T>), const bool>::value, "");
static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
}
{
typedef int T;
static_assert(!ex::has_virtual_destructor_v<T>, "");
static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
}
}

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

@ -1,62 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits>
#include <experimental/type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef char T;
static_assert(ex::alignment_of_v<T> == 1, "");
static_assert(std::is_same<decltype(ex::alignment_of_v<T>), const std::size_t>::value, "");
static_assert(ex::alignment_of_v<T> == std::alignment_of<T>::value, "");
}
{
typedef char(T)[1][1][1];
static_assert(ex::rank_v<T> == 3, "");
static_assert(std::is_same<decltype(ex::rank_v<T>), const std::size_t>::value, "");
static_assert(ex::rank_v<T> == std::rank<T>::value, "");
}
{
typedef void T;
static_assert(ex::rank_v<T> == 0, "");
static_assert(ex::rank_v<T> == std::rank<T>::value, "");
}
{
typedef char(T)[2][3][4];
static_assert(ex::extent_v<T> == 2, "");
static_assert(std::is_same<decltype(ex::extent_v<T>), const std::size_t>::value, "");
static_assert(ex::extent_v<T> == std::extent<T>::value, "");
}
{
typedef char(T)[2][3][4];
static_assert(ex::extent_v<T, 0> == 2, "");
static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
}
{
typedef char(T)[2][3][4];
static_assert(ex::extent_v<T, 1> == 3, "");
static_assert(ex::extent_v<T, 1> == std::extent<T, 1>::value, "");
}
{
typedef char(T)[2][3][4];
static_assert(ex::extent_v<T, 5> == 0, "");
static_assert(ex::extent_v<T, 5> == std::extent<T, 5>::value, "");
}
{
typedef void T;
static_assert(ex::extent_v<T, 0> == 0, "");
static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
}
}

22
test/std/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
View File

@ -1,22 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// Test that <ratio> is included.
#include <experimental/ratio>
int main()
{
std::ratio<100> x;
((void)x);
}

47
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_equal_v.pass.cpp
View File

@ -1,47 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_equal_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_equal_v<R1, R2> == std::ratio_equal<R1, R2>::value, ""
);
static_assert(
std::is_same<decltype(ex::ratio_equal_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, -1> R2;
static_assert(
!ex::ratio_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_equal_v<R1, R2> == std::ratio_equal<R1, R2>::value, ""
);
}
}

61
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_equal_v.pass.cpp
View File

@ -1,61 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_greater_equal_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 2> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_greater_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_equal_v<R1, R2>
== std::ratio_greater_equal<R1, R2>::value, ""
);
static_assert(
std::is_same<
decltype(ex::ratio_greater_equal_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_greater_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_equal_v<R1, R2>
== std::ratio_greater_equal<R1, R2>::value, ""
);
}
{
typedef std::ratio<2, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_greater_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_equal_v<R1, R2>
== std::ratio_greater_equal<R1, R2>::value, ""
);
}
}

57
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_v.pass.cpp
View File

@ -1,57 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_greater_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 2> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_greater_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
);
static_assert(
std::is_same<decltype(ex::ratio_greater_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_greater_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
);
}
{
typedef std::ratio<2, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_greater_v<R1, R2>, ""
);
static_assert(
ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
);
}
}

57
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_equal_v.pass.cpp
View File

@ -1,57 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_less_equal_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 2> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_less_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
);
static_assert(
std::is_same<decltype(ex::ratio_less_equal_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_less_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
);
}
{
typedef std::ratio<2, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_less_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
);
}
}

57
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_v.pass.cpp
View File

@ -1,57 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_less_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 2> R1;
typedef std::ratio<1, 1> R2;
static_assert(
ex::ratio_less_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
);
static_assert(
std::is_same<decltype(ex::ratio_less_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_less_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
);
}
{
typedef std::ratio<2, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_less_v<R1, R2>, ""
);
static_assert(
ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
);
}
}

47
test/std/experimental/utilities/ratio/header.ratio.synop/ratio_not_equal_v.pass.cpp
View File

@ -1,47 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio>
// template <class R1, class R2> constexpr bool ratio_not_equal_v;
#include <experimental/ratio>
#include <type_traits>
namespace ex = std::experimental;
int main()
{
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, -1> R2;
static_assert(
ex::ratio_not_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_not_equal_v<R1, R2> == std::ratio_not_equal<R1, R2>::value, ""
);
static_assert(
std::is_same<decltype(ex::ratio_not_equal_v<R1, R2>), const bool>::value
, ""
);
}
{
typedef std::ratio<1, 1> R1;
typedef std::ratio<1, 1> R2;
static_assert(
!ex::ratio_not_equal_v<R1, R2>, ""
);
static_assert(
ex::ratio_not_equal_v<R1, R2> == std::ratio_not_equal<R1, R2>::value, ""
);
}
}

13
test/std/experimental/utilities/ratio/nothing_to_do.pass.cpp
View File

@ -1,13 +0,0 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

21
test/std/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
View File

@ -1,21 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/system_error>
#include <experimental/system_error>
int main()
{
// Check that <system_error> has been included
std::error_code ec;
((void)ec);
}

37
test/std/experimental/utilities/syserror/header.system_error.synop/is_error_code_enum_v.pass.cpp
View File

@ -1,37 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/system_error>
// template <class T> constexpr bool is_error_code_enum_v;
#include <experimental/system_error>
#include <ios> /* for std::io_errc */
namespace ex = std::experimental;
int main() {
{
static_assert(ex::is_error_code_enum_v<std::io_errc>, "");
static_assert(ex::is_error_code_enum_v<std::io_errc> ==
std::is_error_code_enum <std::io_errc>::value, "");
static_assert(std::is_same<decltype(ex::is_error_code_enum_v<std::io_errc>),
const bool>::value, "");
}
{
static_assert(!ex::is_error_code_enum_v<int>, "");
static_assert(ex::is_error_code_enum_v<int> ==
std::is_error_code_enum <int>::value, "");
}
}

38
test/std/experimental/utilities/syserror/header.system_error.synop/is_error_condition_enum.pass.cpp
View File

@ -1,38 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/system_error>
// template <class T> constexpr bool is_error_condition_enum_v;
#include <experimental/system_error>
#include <type_traits>
namespace ex = std::experimental;
int main() {
{
static_assert(ex::is_error_condition_enum_v<std::errc>, "");
static_assert(ex::is_error_condition_enum_v<std::errc> ==
std::is_error_condition_enum <std::errc>::value, "");
static_assert(
std::is_same<decltype(ex::is_error_condition_enum_v<std::errc>),
const bool>::value,
"");
}
{
static_assert(!ex::is_error_condition_enum_v<int>, "");
static_assert(ex::is_error_condition_enum_v<int> ==
std::is_error_condition_enum <int>::value, "");
}
}

19
test/std/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <experimental/chrono>
#include <experimental/chrono>
int main()
{
// Check that <chrono> has been included.
std::chrono::seconds s;
((void)s);
}

49
test/std/experimental/utilities/time/header.chrono.synop/treat_as_floating_point_v.pass.cpp
View File

@ -1,49 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/chrono>
// template <class Rep> constexpr bool treat_as_floating_point_v;
#include <experimental/chrono>
#include <type_traits>
namespace ex = std::chrono::experimental;
namespace cr = std::chrono;
template <class T, bool Expect>
void test()
{
static_assert(
ex::treat_as_floating_point_v<T> == Expect, ""
);
static_assert(
ex::treat_as_floating_point_v<T> == cr::treat_as_floating_point<T>::value, ""
);
}
int main()
{
{
static_assert(
std::is_same<
decltype(ex::treat_as_floating_point_v<float>), const bool
>::value, ""
);
}
test<int, false>();
test<unsigned, false>();
test<char, false>();
test<bool, false>();
test<float, true>();
test<double, true>();
test<long double, true>();
}

20
test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
View File

@ -1,20 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
#include <experimental/tuple>
int main()
{
std::tuple<int> x(1);
(void)x;
}

187
test/std/experimental/utilities/tuple/tuple.apply/arg_type.pass.cpp
View File

@ -1,187 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Test with different ref/ptr/cv qualified argument types.
#include <experimental/tuple>
#include <array>
#include <utility>
#include <cassert>
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
#include "disable_missing_braces_warning.h"
namespace ex = std::experimental;
int call_with_value(int x, int y) { return (x + y); }
int call_with_ref(int & x, int & y) { return (x + y); }
int call_with_const_ref(int const & x, int const & y) { return (x + y); }
int call_with_rvalue_ref(int && x, int && y) { return (x + y); }
int call_with_pointer(int * x, int * y) { return (*x + *y); }
int call_with_const_pointer(int const* x, int const * y) { return (*x + *y); }
template <class Tuple>
void test_values()
{
{
Tuple t{1, 2};
assert(3 == ex::apply(call_with_value, t));
}
{
Tuple t{2, 2};
assert(4 == ex::apply(call_with_ref, t));
}
{
Tuple t{2, 3};
assert(5 == ex::apply(call_with_const_ref, t));
}
{
Tuple t{3, 3};
assert(6 == ex::apply(call_with_rvalue_ref, static_cast<Tuple &&>(t)));
}
{
Tuple const t{4, 4};
assert(8 == ex::apply(call_with_value, t));
}
{
Tuple const t{4, 5};
assert(9 == ex::apply(call_with_const_ref, t));
}
}
template <class Tuple>
void test_refs()
{
int x = 0;
int y = 0;
{
x = 1; y = 2;
Tuple t{x, y};
assert(3 == ex::apply(call_with_value, t));
}
{
x = 2; y = 2;
Tuple t{x, y};
assert(4 == ex::apply(call_with_ref, t));
}
{
x = 2; y = 3;
Tuple t{x, y};
assert(5 == ex::apply(call_with_const_ref, t));
}
{
x = 3; y = 3;
Tuple const t{x, y};
assert(6 == ex::apply(call_with_value, t));
}
{
x = 3; y = 4;
Tuple const t{x, y};
assert(7 == ex::apply(call_with_const_ref, t));
}
}
template <class Tuple>
void test_const_refs()
{
int x = 0;
int y = 0;
{
x = 1; y = 2;
Tuple t{x, y};
assert(3 == ex::apply(call_with_value, t));
}
{
x = 2; y = 3;
Tuple t{x, y};
assert(5 == ex::apply(call_with_const_ref, t));
}
{
x = 3; y = 3;
Tuple const t{x, y};
assert(6 == ex::apply(call_with_value, t));
}
{
x = 3; y = 4;
Tuple const t{x, y};
assert(7 == ex::apply(call_with_const_ref, t));
}
}
template <class Tuple>
void test_pointer()
{
int x = 0;
int y = 0;
{
x = 2; y = 2;
Tuple t{&x, &y};
assert(4 == ex::apply(call_with_pointer, t));
}
{
x = 2; y = 3;
Tuple t{&x, &y};
assert(5 == ex::apply(call_with_const_pointer, t));
}
{
x = 3; y = 4;
Tuple const t{&x, &y};
assert(7 == ex::apply(call_with_const_pointer, t));
}
}
template <class Tuple>
void test_const_pointer()
{
int x = 0;
int y = 0;
{
x = 2; y = 3;
Tuple t{&x, &y};
assert(5 == ex::apply(call_with_const_pointer, t));
}
{
x = 3; y = 4;
Tuple const t{&x, &y};
assert(7 == ex::apply(call_with_const_pointer, t));
}
}
int main()
{
test_values<std::tuple<int, int>>();
test_values<std::pair<int, int>>();
test_values<std::array<int, 2>>();
test_refs<std::tuple<int &, int &>>();
test_refs<std::pair<int &, int &>>();
test_const_refs<std::tuple<int const &, int const &>>();
test_const_refs<std::pair<int const &, int const &>>();
test_pointer<std::tuple<int *, int *>>();
test_pointer<std::pair<int *, int *>>();
test_pointer<std::array<int *, 2>>();
test_const_pointer<std::tuple<int const *, int const *>>();
test_const_pointer<std::pair<int const *, int const *>>();
test_const_pointer<std::array<int const *, 2>>();
}

118
test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
View File

@ -1,118 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Testing constexpr evaluation
#include <experimental/tuple>
#include <utility>
#include <cassert>
constexpr int f_int_0() { return 1; }
constexpr int f_int_1(int x) { return x; }
constexpr int f_int_2(int x, int y) { return (x + y); }
struct A_int_0
{
constexpr A_int_0() {}
constexpr int operator()() const { return 1; }
};
struct A_int_1
{
constexpr A_int_1() {}
constexpr int operator()(int x) const { return x; }
};
struct A_int_2
{
constexpr A_int_2() {}
constexpr int operator()(int x, int y) const { return (x + y); }
};
namespace ex = std::experimental;
template <class Tuple>
void test_0()
{
// function
{
constexpr Tuple t{};
static_assert(1 == ex::apply(f_int_0, t), "");
}
// function pointer
{
constexpr Tuple t{};
constexpr auto fp = &f_int_0;
static_assert(1 == ex::apply(fp, t), "");
}
// functor
{
constexpr Tuple t{};
constexpr A_int_0 a;
static_assert(1 == ex::apply(a, t), "");
}
}
template <class Tuple>
void test_1()
{
// function
{
constexpr Tuple t{1};
static_assert(1 == ex::apply(f_int_1, t), "");
}
// function pointer
{
constexpr Tuple t{2};
constexpr int (*fp)(int) = f_int_1;
static_assert(2 == ex::apply(fp, t), "");
}
// functor
{
constexpr Tuple t{3};
constexpr A_int_1 fn;
static_assert(3 == ex::apply(fn, t), "");
}
}
template <class Tuple>
void test_2()
{
// function
{
constexpr Tuple t{1, 2};
static_assert(3 == ex::apply(f_int_2, t), "");
}
// function pointer
{
constexpr Tuple t{2, 3};
constexpr auto fp = &f_int_2;
static_assert(5 == ex::apply(fp, t), "");
}
// functor
{
constexpr Tuple t{3, 4};
constexpr A_int_2 a;
static_assert(7 == ex::apply(a, t), "");
}
}
int main()
{
test_0<std::tuple<>>();
test_1<std::tuple<int>>();
test_2<std::tuple<int, int>>();
test_2<std::pair<int, int>>();
}

427
test/std/experimental/utilities/tuple/tuple.apply/extended_types.pass.cpp
View File

@ -1,427 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Testing extended function types. The extended function types are those
// named by INVOKE but that are not actual callable objects. These include
// bullets 1-4 of invoke.
#include <experimental/tuple>
#include <array>
#include <utility>
#include <cassert>
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
#include "disable_missing_braces_warning.h"
int count = 0;
struct A_int_0
{
A_int_0() : obj1(0){}
A_int_0(int x) : obj1(x) {}
int mem1() { return ++count; }
int mem2() const { return ++count; }
int const obj1;
};
struct A_int_1
{
A_int_1() {}
A_int_1(int) {}
int mem1(int x) { return count += x; }
int mem2(int x) const { return count += x; }
};
struct A_int_2
{
A_int_2() {}
A_int_2(int) {}
int mem1(int x, int y) { return count += (x + y); }
int mem2(int x, int y) const { return count += (x + y); }
};
template <class A>
struct A_wrap
{
A_wrap() {}
A_wrap(int x) : m_a(x) {}
A & operator*() { return m_a; }
A const & operator*() const { return m_a; }
A m_a;
};
typedef A_wrap<A_int_0> A_wrap_0;
typedef A_wrap<A_int_1> A_wrap_1;
typedef A_wrap<A_int_2> A_wrap_2;
template <class A>
struct A_base : public A
{
A_base() : A() {}
A_base(int x) : A(x) {}
};
typedef A_base<A_int_0> A_base_0;
typedef A_base<A_int_1> A_base_1;
typedef A_base<A_int_2> A_base_2;
namespace ex = std::experimental;
template <
class Tuple, class ConstTuple
, class TuplePtr, class ConstTuplePtr
, class TupleWrap, class ConstTupleWrap
, class TupleBase, class ConstTupleBase
>
void test_ext_int_0()
{
count = 0;
typedef A_int_0 T;
typedef A_wrap_0 Wrap;
typedef A_base_0 Base;
typedef int(T::*mem1_t)();
mem1_t mem1 = &T::mem1;
typedef int(T::*mem2_t)() const;
mem2_t mem2 = &T::mem2;
typedef int const T::*obj1_t;
obj1_t obj1 = &T::obj1;
// member function w/ref
{
T a;
Tuple t{a};
assert(1 == ex::apply(mem1, t));
assert(count == 1);
}
count = 0;
// member function w/pointer
{
T a;
TuplePtr t{&a};
assert(1 == ex::apply(mem1, t));
assert(count == 1);
}
count = 0;
// member function w/base
{
Base a;
TupleBase t{a};
assert(1 == ex::apply(mem1, t));
assert(count == 1);
}
count = 0;
// member function w/wrap
{
Wrap a;
TupleWrap t{a};
assert(1 == ex::apply(mem1, t));
assert(count == 1);
}
count = 0;
// const member function w/ref
{
T const a;
ConstTuple t{a};
assert(1 == ex::apply(mem2, t));
assert(count == 1);
}
count = 0;
// const member function w/pointer
{
T const a;
ConstTuplePtr t{&a};
assert(1 == ex::apply(mem2, t));
assert(count == 1);
}
count = 0;
// const member function w/base
{
Base const a;
ConstTupleBase t{a};
assert(1 == ex::apply(mem2, t));
assert(count == 1);
}
count = 0;
// const member function w/wrapper
{
Wrap const a;
ConstTupleWrap t{a};
assert(1 == ex::apply(mem2, t));
assert(1 == count);
}
// member object w/ref
{
T a{42};
Tuple t{a};
assert(42 == ex::apply(obj1, t));
}
// member object w/pointer
{
T a{42};
TuplePtr t{&a};
assert(42 == ex::apply(obj1, t));
}
// member object w/base
{
Base a{42};
TupleBase t{a};
assert(42 == ex::apply(obj1, t));
}
// member object w/wrapper
{
Wrap a{42};
TupleWrap t{a};
assert(42 == ex::apply(obj1, t));
}
}
template <
class Tuple, class ConstTuple
, class TuplePtr, class ConstTuplePtr
, class TupleWrap, class ConstTupleWrap
, class TupleBase, class ConstTupleBase
>
void test_ext_int_1()
{
count = 0;
typedef A_int_1 T;
typedef A_wrap_1 Wrap;
typedef A_base_1 Base;
typedef int(T::*mem1_t)(int);
mem1_t mem1 = &T::mem1;
typedef int(T::*mem2_t)(int) const;
mem2_t mem2 = &T::mem2;
// member function w/ref
{
T a;
Tuple t{a, 2};
assert(2 == ex::apply(mem1, t));
assert(count == 2);
}
count = 0;
// member function w/pointer
{
T a;
TuplePtr t{&a, 3};
assert(3 == ex::apply(mem1, t));
assert(count == 3);
}
count = 0;
// member function w/base
{
Base a;
TupleBase t{a, 4};
assert(4 == ex::apply(mem1, t));
assert(count == 4);
}
count = 0;
// member function w/wrap
{
Wrap a;
TupleWrap t{a, 5};
assert(5 == ex::apply(mem1, t));
assert(count == 5);
}
count = 0;
// const member function w/ref
{
T const a;
ConstTuple t{a, 6};
assert(6 == ex::apply(mem2, t));
assert(count == 6);
}
count = 0;
// const member function w/pointer
{
T const a;
ConstTuplePtr t{&a, 7};
assert(7 == ex::apply(mem2, t));
assert(count == 7);
}
count = 0;
// const member function w/base
{
Base const a;
ConstTupleBase t{a, 8};
assert(8 == ex::apply(mem2, t));
assert(count == 8);
}
count = 0;
// const member function w/wrapper
{
Wrap const a;
ConstTupleWrap t{a, 9};
assert(9 == ex::apply(mem2, t));
assert(9 == count);
}
}
template <
class Tuple, class ConstTuple
, class TuplePtr, class ConstTuplePtr
, class TupleWrap, class ConstTupleWrap
, class TupleBase, class ConstTupleBase
>
void test_ext_int_2()
{
count = 0;
typedef A_int_2 T;
typedef A_wrap_2 Wrap;
typedef A_base_2 Base;
typedef int(T::*mem1_t)(int, int);
mem1_t mem1 = &T::mem1;
typedef int(T::*mem2_t)(int, int) const;
mem2_t mem2 = &T::mem2;
// member function w/ref
{
T a;
Tuple t{a, 1, 1};
assert(2 == ex::apply(mem1, t));
assert(count == 2);
}
count = 0;
// member function w/pointer
{
T a;
TuplePtr t{&a, 1, 2};
assert(3 == ex::apply(mem1, t));
assert(count == 3);
}
count = 0;
// member function w/base
{
Base a;
TupleBase t{a, 2, 2};
assert(4 == ex::apply(mem1, t));
assert(count == 4);
}
count = 0;
// member function w/wrap
{
Wrap a;
TupleWrap t{a, 2, 3};
assert(5 == ex::apply(mem1, t));
assert(count == 5);
}
count = 0;
// const member function w/ref
{
T const a;
ConstTuple t{a, 3, 3};
assert(6 == ex::apply(mem2, t));
assert(count == 6);
}
count = 0;
// const member function w/pointer
{
T const a;
ConstTuplePtr t{&a, 3, 4};
assert(7 == ex::apply(mem2, t));
assert(count == 7);
}
count = 0;
// const member function w/base
{
Base const a;
ConstTupleBase t{a, 4, 4};
assert(8 == ex::apply(mem2, t));
assert(count == 8);
}
count = 0;
// const member function w/wrapper
{
Wrap const a;
ConstTupleWrap t{a, 4, 5};
assert(9 == ex::apply(mem2, t));
assert(9 == count);
}
}
int main()
{
{
test_ext_int_0<
std::tuple<A_int_0 &>, std::tuple<A_int_0 const &>
, std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
, std::tuple<A_wrap_0 &>, std::tuple<A_wrap_0 const &>
, std::tuple<A_base_0 &>, std::tuple<A_base_0 const &>
>();
test_ext_int_0<
std::tuple<A_int_0>, std::tuple<A_int_0 const>
, std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
, std::tuple<A_wrap_0>, std::tuple<A_wrap_0 const>
, std::tuple<A_base_0>, std::tuple<A_base_0 const>
>();
test_ext_int_0<
std::array<A_int_0, 1>, std::array<A_int_0 const, 1>
, std::array<A_int_0*, 1>, std::array<A_int_0 const*, 1>
, std::array<A_wrap_0, 1>, std::array<A_wrap_0 const, 1>
, std::array<A_base_0, 1>, std::array<A_base_0 const, 1>
>();
}
{
test_ext_int_1<
std::tuple<A_int_1 &, int>, std::tuple<A_int_1 const &, int>
, std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
, std::tuple<A_wrap_1 &, int>, std::tuple<A_wrap_1 const &, int>
, std::tuple<A_base_1 &, int>, std::tuple<A_base_1 const &, int>
>();
test_ext_int_1<
std::tuple<A_int_1, int>, std::tuple<A_int_1 const, int>
, std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
, std::tuple<A_wrap_1, int>, std::tuple<A_wrap_1 const, int>
, std::tuple<A_base_1, int>, std::tuple<A_base_1 const, int>
>();
test_ext_int_1<
std::pair<A_int_1 &, int>, std::pair<A_int_1 const &, int>
, std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
, std::pair<A_wrap_1 &, int>, std::pair<A_wrap_1 const &, int>
, std::pair<A_base_1 &, int>, std::pair<A_base_1 const &, int>
>();
test_ext_int_1<
std::pair<A_int_1, int>, std::pair<A_int_1 const, int>
, std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
, std::pair<A_wrap_1, int>, std::pair<A_wrap_1 const, int>
, std::pair<A_base_1, int>, std::pair<A_base_1 const, int>
>();
}
{
test_ext_int_2<
std::tuple<A_int_2 &, int, int>, std::tuple<A_int_2 const &, int, int>
, std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
, std::tuple<A_wrap_2 &, int, int>, std::tuple<A_wrap_2 const &, int, int>
, std::tuple<A_base_2 &, int, int>, std::tuple<A_base_2 const &, int, int>
>();
test_ext_int_2<
std::tuple<A_int_2, int, int>, std::tuple<A_int_2 const, int, int>
, std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
, std::tuple<A_wrap_2, int, int>, std::tuple<A_wrap_2 const, int, int>
, std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
>();
}
}

146
test/std/experimental/utilities/tuple/tuple.apply/large_arity.pass.cpp
View File

@ -1,146 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Stress testing large arities with tuple and array.
#include <experimental/tuple>
#include <array>
#include <utility>
#include <cassert>
////////////////////////////////////////////////////////////////////////////////
template <class T, std::size_t Dummy = 0>
struct always_imp
{
typedef T type;
};
template <class T, std::size_t Dummy = 0>
using always_t = typename always_imp<T, Dummy>::type;
////////////////////////////////////////////////////////////////////////////////
template <class Tuple, class Idx>
struct make_function;
template <class Tp, std::size_t ...Idx>
struct make_function<Tp, std::integer_sequence<std::size_t, Idx...>>
{
using type = bool (*)(always_t<Tp, Idx>...);
};
template <class Tp, std::size_t Size>
using make_function_t = typename make_function<Tp, std::make_index_sequence<Size>>::type;
////////////////////////////////////////////////////////////////////////////////
template <class Tp, class Idx>
struct make_tuple_imp;
////////////////////////////////////////////////////////////////////////////////
template <class Tp, std::size_t ...Idx>
struct make_tuple_imp<Tp, std::integer_sequence<std::size_t, Idx...>>
{
using type = std::tuple<always_t<Tp, Idx>...>;
};
template <class Tp, std::size_t Size>
using make_tuple_t = typename make_tuple_imp<Tp, std::make_index_sequence<Size>>::type;
template <class ...Types>
bool test_apply_fn(Types...) { return true; }
namespace ex = std::experimental;
template <std::size_t Size>
void test_all()
{
using A = std::array<int, Size>;
using ConstA = std::array<int const, Size>;
using Tuple = make_tuple_t<int, Size>;
using CTuple = make_tuple_t<const int, Size>;
using ValFn = make_function_t<int, Size>;
ValFn val_fn = &test_apply_fn;
using RefFn = make_function_t<int &, Size>;
RefFn ref_fn = &test_apply_fn;
using CRefFn = make_function_t<int const &, Size>;
CRefFn cref_fn = &test_apply_fn;
using RRefFn = make_function_t<int &&, Size>;
RRefFn rref_fn = &test_apply_fn;
{
A a{};
assert(ex::apply(val_fn, a));
assert(ex::apply(ref_fn, a));
assert(ex::apply(cref_fn, a));
assert(ex::apply(rref_fn, std::move(a)));
}
{
ConstA a{};
assert(ex::apply(val_fn, a));
assert(ex::apply(cref_fn, a));
}
{
Tuple a{};
assert(ex::apply(val_fn, a));
assert(ex::apply(ref_fn, a));
assert(ex::apply(cref_fn, a));
assert(ex::apply(rref_fn, std::move(a)));
}
{
CTuple a{};
assert(ex::apply(val_fn, a));
assert(ex::apply(cref_fn, a));
}
}
template <std::size_t Size>
void test_one()
{
using A = std::array<int, Size>;
using Tuple = make_tuple_t<int, Size>;
using ValFn = make_function_t<int, Size>;
ValFn val_fn = &test_apply_fn;
{
A a{};
assert(ex::apply(val_fn, a));
}
{
Tuple a{};
assert(ex::apply(val_fn, a));
}
}
int main()
{
// Instantiate with 1-5 arguments.
test_all<1>();
test_all<2>();
test_all<3>();
test_all<4>();
test_all<5>();
// Stress test with 128.
test_one<128>();
//test_one<256>();
}

53
test/std/experimental/utilities/tuple/tuple.apply/ref_qualifiers.pass.cpp
View File

@ -1,53 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Testing ref qualified functions
#include <experimental/tuple>
#include <cassert>
struct func_obj
{
constexpr func_obj() {}
constexpr int operator()() const & { return 1; }
constexpr int operator()() const && { return 2; }
constexpr int operator()() & { return 3; }
constexpr int operator()() && { return 4; }
};
namespace ex = std::experimental;
int main()
{
// TODO(ericwf): Re-enable constexpr support
/*
{
constexpr func_obj f;
constexpr std::tuple<> tp;
static_assert(1 == ex::apply(static_cast<func_obj const &>(f), tp), "");
static_assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp), "");
}
*/
{
func_obj f;
std::tuple<> tp;
assert(1 == ex::apply(static_cast<func_obj const &>(f), tp));
assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp));
assert(3 == ex::apply(static_cast<func_obj &>(f), tp));
assert(4 == ex::apply(static_cast<func_obj &&>(f), tp));
}
}

70
test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
View File

@ -1,70 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Test the return type deduction.
#include <experimental/tuple>
#include <cassert>
static int my_int = 42;
template <int N> struct index_t {};
void f(index_t<0>) {}
int f(index_t<1>) { return 0; }
int & f(index_t<2>) { return static_cast<int &>(my_int); }
int const & f(index_t<3>) { return static_cast<int const &>(my_int); }
int volatile & f(index_t<4>) { return static_cast<int volatile &>(my_int); }
int const volatile & f(index_t<5>) { return static_cast<int const volatile &>(my_int); }
int && f(index_t<6>) { return static_cast<int &&>(my_int); }
int const && f(index_t<7>) { return static_cast<int const &&>(my_int); }
int volatile && f(index_t<8>) { return static_cast<int volatile &&>(my_int); }
int const volatile && f(index_t<9>) { return static_cast<int const volatile &&>(my_int); }
int * f(index_t<10>) { return static_cast<int *>(&my_int); }
int const * f(index_t<11>) { return static_cast<int const *>(&my_int); }
int volatile * f(index_t<12>) { return static_cast<int volatile *>(&my_int); }
int const volatile * f(index_t<13>) { return static_cast<int const volatile *>(&my_int); }
template <int Func, class Expect>
void test()
{
using F = decltype(f(index_t<Func>{}));
static_assert(std::is_same<F, Expect>::value, "");
}
namespace ex = std::experimental;
int main()
{
test<0, void>();
test<1, int>();
test<2, int &>();
test<3, int const &>();
test<4, int volatile &>();
test<5, int const volatile &>();
test<6, int &&>();
test<7, int const &&>();
test<8, int volatile &&>();
test<9, int const volatile &&>();
test<10, int *>();
test<11, int const *>();
test<12, int volatile *>();
test<13, int const volatile *>();
}

431
test/std/experimental/utilities/tuple/tuple.apply/types.pass.cpp
View File

@ -1,431 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
// Test function types.
#include <experimental/tuple>
#include <array>
#include <utility>
#include <cassert>
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
#include "disable_missing_braces_warning.h"
namespace ex = std::experimental;
int count = 0;
void f_void_0() { ++count; }
void f_void_1(int i) { count += i; }
void f_void_2(int x, int y) { count += (x + y); }
void f_void_3(int x, int y, int z) { count += (x + y + z); }
int f_int_0() { return ++count; }
int f_int_1(int x) { return count += x; }
int f_int_2(int x, int y) { return count += (x + y); }
int f_int_3(int x, int y, int z) { return count += (x + y + z); }
struct A_void_0
{
A_void_0() {}
void operator()() { ++count; }
void operator()() const { ++count; ++count; }
};
struct A_void_1
{
A_void_1() {}
void operator()(int x) { count += x; }
void operator()(int x) const { count += x + 1; }
};
struct A_void_2
{
A_void_2() {}
void operator()(int x, int y) { count += (x + y); }
void operator()(int x, int y) const { count += (x + y) + 1; }
};
struct A_void_3
{
A_void_3() {}
void operator()(int x, int y, int z) { count += (x + y + z); }
void operator()(int x, int y, int z) const { count += (x + y + z) + 1; }
};
struct A_int_0
{
A_int_0() {}
int operator()() { return ++count; }
int operator()() const { ++count; return ++count; }
};
struct A_int_1
{
A_int_1() {}
int operator()(int x) { return count += x; }
int operator()(int x) const { return count += (x + 1); }
};
struct A_int_2
{
A_int_2() {}
int operator()(int x, int y) { return count += (x + y); }
int operator()(int x, int y) const { return count += (x + y + 1); }
};
struct A_int_3
{
A_int_3() {}
int operator()(int x, int y, int z) { return count += (x + y + z); }
int operator()(int x, int y, int z) const { return count += (x + y + z + 1); }
};
template <class Tuple>
void test_void_0()
{
count = 0;
// function
{
Tuple t{};
ex::apply(f_void_0, t);
assert(count == 1);
}
count = 0;
// function pointer
{
Tuple t{};
auto fp = &f_void_0;
ex::apply(fp, t);
assert(count == 1);
}
count = 0;
// functor
{
Tuple t{};
A_void_0 a;
ex::apply(a, t);
assert(count == 1);
}
count = 0;
// const functor
{
Tuple t{};
A_void_0 const a;
ex::apply(a, t);
assert(count == 2);
}
}
template <class Tuple>
void test_void_1()
{
count = 0;
// function
{
Tuple t{1};
ex::apply(f_void_1, t);
assert(count == 1);
}
count = 0;
// function pointer
{
Tuple t{2};
void (*fp)(int) = f_void_1;
ex::apply(fp, t);
assert(count == 2);
}
count = 0;
// functor
{
Tuple t{3};
A_void_1 fn;
ex::apply(fn, t);
assert(count == 3);
}
count = 0;
// const functor
{
Tuple t{4};
A_void_1 const a;
ex::apply(a, t);
assert(count == 5);
}
}
template <class Tuple>
void test_void_2()
{
count = 0;
// function
{
Tuple t{1, 2};
ex::apply(f_void_2, t);
assert(count == 3);
}
count = 0;
// function pointer
{
Tuple t{2, 3};
auto fp = &f_void_2;
ex::apply(fp, t);
assert(count == 5);
}
count = 0;
// functor
{
Tuple t{3, 4};
A_void_2 a;
ex::apply(a, t);
assert(count == 7);
}
count = 0;
// const functor
{
Tuple t{4, 5};
A_void_2 const a;
ex::apply(a, t);
assert(count == 10);
}
}
template <class Tuple>
void test_void_3()
{
count = 0;
// function
{
Tuple t{1, 2, 3};
ex::apply(f_void_3, t);
assert(count == 6);
}
count = 0;
// function pointer
{
Tuple t{2, 3, 4};
auto fp = &f_void_3;
ex::apply(fp, t);
assert(count == 9);
}
count = 0;
// functor
{
Tuple t{3, 4, 5};
A_void_3 a;
ex::apply(a, t);
assert(count == 12);
}
count = 0;
// const functor
{
Tuple t{4, 5, 6};
A_void_3 const a;
ex::apply(a, t);
assert(count == 16);
}
}
template <class Tuple>
void test_int_0()
{
count = 0;
// function
{
Tuple t{};
assert(1 == ex::apply(f_int_0, t));
assert(count == 1);
}
count = 0;
// function pointer
{
Tuple t{};
auto fp = &f_int_0;
assert(1 == ex::apply(fp, t));
assert(count == 1);
}
count = 0;
// functor
{
Tuple t{};
A_int_0 a;
assert(1 == ex::apply(a, t));
assert(count == 1);
}
count = 0;
// const functor
{
Tuple t{};
A_int_0 const a;
assert(2 == ex::apply(a, t));
assert(count == 2);
}
}
template <class Tuple>
void test_int_1()
{
count = 0;
// function
{
Tuple t{1};
assert(1 == ex::apply(f_int_1, t));
assert(count == 1);
}
count = 0;
// function pointer
{
Tuple t{2};
int (*fp)(int) = f_int_1;
assert(2 == ex::apply(fp, t));
assert(count == 2);
}
count = 0;
// functor
{
Tuple t{3};
A_int_1 fn;
assert(3 == ex::apply(fn, t));
assert(count == 3);
}
count = 0;
// const functor
{
Tuple t{4};
A_int_1 const a;
assert(5 == ex::apply(a, t));
assert(count == 5);
}
}
template <class Tuple>
void test_int_2()
{
count = 0;
// function
{
Tuple t{1, 2};
assert(3 == ex::apply(f_int_2, t));
assert(count == 3);
}
count = 0;
// function pointer
{
Tuple t{2, 3};
auto fp = &f_int_2;
assert(5 == ex::apply(fp, t));
assert(count == 5);
}
count = 0;
// functor
{
Tuple t{3, 4};
A_int_2 a;
assert(7 == ex::apply(a, t));
assert(count == 7);
}
count = 0;
// const functor
{
Tuple t{4, 5};
A_int_2 const a;
assert(10 == ex::apply(a, t));
assert(count == 10);
}
}
template <class Tuple>
void test_int_3()
{
count = 0;
// function
{
Tuple t{1, 2, 3};
assert(6 == ex::apply(f_int_3, t));
assert(count == 6);
}
count = 0;
// function pointer
{
Tuple t{2, 3, 4};
auto fp = &f_int_3;
assert(9 == ex::apply(fp, t));
assert(count == 9);
}
count = 0;
// functor
{
Tuple t{3, 4, 5};
A_int_3 a;
assert(12 == ex::apply(a, t));
assert(count == 12);
}
count = 0;
// const functor
{
Tuple t{4, 5, 6};
A_int_3 const a;
assert(16 == ex::apply(a, t));
assert(count == 16);
}
}
template <class Tuple>
void test_0()
{
test_void_0<Tuple>();
test_int_0<Tuple>();
}
template <class Tuple>
void test_1()
{
test_void_1<Tuple>();
test_int_1<Tuple>();
}
template <class Tuple>
void test_2()
{
test_void_2<Tuple>();
test_int_2<Tuple>();
}
template <class Tuple>
void test_3()
{
test_void_3<Tuple>();
test_int_3<Tuple>();
}
int main()
{
test_0<std::tuple<>>();
test_1<std::tuple<int>>();
test_1<std::array<int, 1>>();
test_2<std::tuple<int, int>>();
test_2<std::pair<int, int>>();
test_2<std::array<int, 2>>();
test_3<std::tuple<int, int, int>>();
test_3<std::array<int, 3>>();
}

25
test/std/experimental/utilities/tuple/tuple_size_v.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
// Test with reference
#include <experimental/tuple>
namespace ex = std::experimental;
int main()
{
auto x = ex::tuple_size_v<std::tuple<> &>;
}

45
test/std/experimental/utilities/tuple/tuple_size_v.pass.cpp
View File

@ -1,45 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
#include <experimental/tuple>
#include <utility>
#include <array>
namespace ex = std::experimental;
template <class Tuple, int Expect>
void test()
{
static_assert(ex::tuple_size_v<Tuple> == Expect, "");
static_assert(ex::tuple_size_v<Tuple> == std::tuple_size<Tuple>::value, "");
static_assert(ex::tuple_size_v<Tuple const> == std::tuple_size<Tuple>::value, "");
static_assert(ex::tuple_size_v<Tuple volatile> == std::tuple_size<Tuple>::value, "");
static_assert(ex::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
}
int main()
{
test<std::tuple<>, 0>();
test<std::tuple<int>, 1>();
test<std::array<int, 1>, 1>();
test<std::tuple<int, int>, 2>();
test<std::pair<int, int>, 2>();
test<std::array<int, 2>, 2>();
test<std::tuple<int, int, int>, 3>();
test<std::array<int, 3>, 3>();
}

25
test/std/experimental/utilities/tuple/tuple_size_v_2.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
// Test with non tuple type
#include <experimental/tuple>
namespace ex = std::experimental;
int main()
{
auto x = ex::tuple_size_v<int>;
}

25
test/std/experimental/utilities/tuple/tuple_size_v_3.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple>
// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
// Test with pointer
#include <experimental/tuple>
namespace ex = std::experimental;
int main()
{
auto x = ex::tuple_size_v<std::tuple<>*>;
}