diff options
21 files changed, 575 insertions, 15 deletions
diff --git a/libcxx/include/__functional_base b/libcxx/include/__functional_base index 5b0d7201d6f..2bc2d2c1466 100644 --- a/libcxx/include/__functional_base +++ b/libcxx/include/__functional_base @@ -50,13 +50,27 @@ public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS less : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x < __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS less<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } +}; +#endif + #ifdef _LIBCPP_HAS_NO_VARIADICS #include <__functional_base_03> diff --git a/libcxx/include/functional b/libcxx/include/functional index d1a6301fb87..2130f0e36cd 100644 --- a/libcxx/include/functional +++ b/libcxx/include/functional @@ -68,96 +68,120 @@ template <class T> reference_wrapper<const T> cref(const T& t) noexcept; template <class T> void cref(const T&& t) = delete; template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept; -template <class T> +template <class T> // <class T=void> in C++14 struct plus : binary_function<T, T, T> { T operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct minus : binary_function<T, T, T> { T operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct multiplies : binary_function<T, T, T> { T operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct divides : binary_function<T, T, T> { T operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct modulus : binary_function<T, T, T> { T operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct negate : unary_function<T, T> { T operator()(const T& x) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct equal_to : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct not_equal_to : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct greater : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct less : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct greater_equal : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct less_equal : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct logical_and : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct logical_or : binary_function<T, T, bool> { bool operator()(const T& x, const T& y) const; }; -template <class T> +template <class T> // <class T=void> in C++14 struct logical_not : unary_function<T, bool> { bool operator()(const T& x) const; }; +template <class T> // <class T=void> in C++14 +struct bit_and : unary_function<T, bool> +{ + bool operator()(const T& x, const T& y) const; +}; + +template <class T> // <class T=void> in C++14 +struct bit_or : unary_function<T, bool> +{ + bool operator()(const T& x, const T& y) const; +}; + +template <class T> // <class T=void> in C++14 +struct bit_xor : unary_function<T, bool> +{ + bool operator()(const T& x, const T& y) const; +}; + +template <class T=void> // C++14 +struct bit_xor : unary_function<T, bool> +{ + bool operator()(const T& x) const; +}; + template <class Predicate> class unary_negate : public unary_function<typename Predicate::argument_type, bool> @@ -473,127 +497,399 @@ POLICY: For non-variadic implementations, the number of arguments is limited _LIBCPP_BEGIN_NAMESPACE_STD +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x + __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS plus<void> +{ + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x - __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS minus<void> +{ + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x * __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS multiplies<void> +{ + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x / __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS divides<void> +{ + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x % __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS modulus<void> +{ + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return -__x;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS negate<void> +{ + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const + { return -_VSTD::forward<_Tp>(__x); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x == __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS equal_to<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x != __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS not_equal_to<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x > __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS greater<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } +}; +#endif + + // less in <__functional_base> +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x >= __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS greater_equal<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x <= __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS less_equal<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x && __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS logical_and<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x || __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS logical_or<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const {return !__x;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS logical_not<void> +{ + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const + { return !_VSTD::forward<_Tp>(__x); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x & __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS bit_and<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x | __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS bit_or<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +#else template <class _Tp> +#endif struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x ^ __y;} }; +#if _LIBCPP_STD_VER > 11 +template <> +struct _LIBCPP_TYPE_VIS bit_xor<void> +{ + template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } +}; +#endif + + +#if _LIBCPP_STD_VER > 11 +template <class _Tp = void> +struct _LIBCPP_TYPE_VIS bit_not : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const + {return ~__x;} +}; + +template <> +struct _LIBCPP_TYPE_VIS bit_not<void> +{ + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const + { return ~_VSTD::forward<_Tp>(__x); } +}; +#endif + template <class _Predicate> class _LIBCPP_TYPE_VIS unary_negate : public unary_function<typename _Predicate::argument_type, bool> diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp index 13e5b68a30a..5eeba18b657 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), ""); assert(f(36, 4) == 9); +#if _LIBCPP_STD_VER > 11 + typedef std::divides<> F2; + const F2 f2 = F2(); + assert(f2(36, 4) == 9); + assert(f2(36.0, 4) == 9); + assert(f2(18, 4.0) == 4.5); // exact in binary +#endif } diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp index f777b2397ea..2a8ecd6b876 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), ""); assert(f(3, 2) == 1); +#if _LIBCPP_STD_VER > 11 + typedef std::minus<> F2; + const F2 f2 = F2(); + assert(f2(3,2) == 1); + assert(f2(3.0, 2) == 1); + assert(f2(3, 2.5) == 0.5); +#endif } diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp index 542711fb2ee..421f9452d62 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), ""); assert(f(36, 8) == 4); +#if _LIBCPP_STD_VER > 11 + typedef std::modulus<> F2; + const F2 f2 = F2(); + assert(f2(36, 8) == 4); + assert(f2(36L, 8) == 4); + assert(f2(36, 8L) == 4); +#endif } diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp index c96938f8c5e..67bb5a5e3d0 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), ""); assert(f(3, 2) == 6); +#if _LIBCPP_STD_VER > 11 + typedef std::multiplies<> F2; + const F2 f2 = F2(); + assert(f2(3,2) == 6); + assert(f2(3.0, 2) == 6); + assert(f2(3, 2.5) == 7.5); // exact in binary +#endif } diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp index 6c6957ab1e7..181c1fb7aa8 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::unary_function<int, int>, F>::value), ""); assert(f(36) == -36); +#if _LIBCPP_STD_VER > 11 + typedef std::negate<> F2; + const F2 f2 = F2(); + assert(f2(36) == -36); + assert(f2(36L) == -36); + assert(f2(36.0) == -36); +#endif } diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp index bc72195d91a..4de23fff086 100644 --- a/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp @@ -21,4 +21,11 @@ int main() const F f = F(); static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), ""); assert(f(3, 2) == 5); +#if _LIBCPP_STD_VER > 11 + typedef std::plus<> F2; + const F2 f2 = F2(); + assert(f2(3,2) == 5); + assert(f2(3.0, 2) == 5); + assert(f2(3, 2.5) == 5.5); +#endif } diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp index ac10acdbd09..1841232728e 100644 --- a/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp @@ -25,4 +25,27 @@ int main() assert(f(0x58D3, 0xEA95) == 0x4891); assert(f(0x58D3, 0) == 0); assert(f(0xFFFF, 0x58D3) == 0x58D3); +#if _LIBCPP_STD_VER > 11 + typedef std::bit_and<> F2; + const F2 f2 = F2(); + assert(f2(0xEA95, 0xEA95) == 0xEA95); + assert(f2(0xEA95L, 0xEA95) == 0xEA95); + assert(f2(0xEA95, 0xEA95L) == 0xEA95); + + assert(f2(0xEA95, 0x58D3) == 0x4891); + assert(f2(0xEA95L, 0x58D3) == 0x4891); + assert(f2(0xEA95, 0x58D3L) == 0x4891); + + assert(f2(0x58D3, 0xEA95) == 0x4891); + assert(f2(0x58D3L, 0xEA95) == 0x4891); + assert(f2(0x58D3, 0xEA95L) == 0x4891); + + assert(f2(0x58D3, 0) == 0); + assert(f2(0x58D3L, 0) == 0); + assert(f2(0x58D3, 0L) == 0); + + assert(f2(0xFFFF, 0x58D3) == 0x58D3); + assert(f2(0xFFFFL, 0x58D3) == 0x58D3); + assert(f2(0xFFFF, 0x58D3L) == 0x58D3); +#endif } diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_not.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_not.pass.cpp new file mode 100644 index 00000000000..2158292f435 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_not.pass.cpp @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// bit_not + +#include <functional> +#include <type_traits> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + typedef std::bit_not<int> F; + const F f = F(); + static_assert((std::is_base_of<std::unary_function<int, int>, F>::value), ""); + assert((f(0xEA95) & 0xFFFF ) == 0x156A); + assert((f(0x58D3) & 0xFFFF ) == 0xA72C); + assert((f(0) & 0xFFFF ) == 0xFFFF); + assert((f(0xFFFF) & 0xFFFF ) == 0); + + typedef std::bit_not<> F2; + const F2 f2 = F2(); + assert((f2(0xEA95) & 0xFFFF ) == 0x156A); + assert((f2(0xEA95L) & 0xFFFF ) == 0x156A); + assert((f2(0x58D3) & 0xFFFF ) == 0xA72C); + assert((f2(0x58D3L) & 0xFFFF ) == 0xA72C); + assert((f2(0) & 0xFFFF ) == 0xFFFF); + assert((f2(0L) & 0xFFFF ) == 0xFFFF); + assert((f2(0xFFFF) & 0xFFFF ) == 0); + assert((f2(0xFFFFL) & 0xFFFF ) == 0); +#endif +} diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp index 6dc3911df50..21ada1270ac 100644 --- a/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp @@ -25,4 +25,27 @@ int main() assert(f(0x58D3, 0xEA95) == 0xFAD7); assert(f(0x58D3, 0) == 0x58D3); assert(f(0xFFFF, 0x58D3) == 0xFFFF); +#if _LIBCPP_STD_VER > 11 + typedef std::bit_or<> F2; + const F2 f2 = F2(); + assert(f2(0xEA95, 0xEA95) == 0xEA95); + assert(f2(0xEA95L, 0xEA95) == 0xEA95); + assert(f2(0xEA95, 0xEA95L) == 0xEA95); + + assert(f2(0xEA95, 0x58D3) == 0xFAD7); + assert(f2(0xEA95L, 0x58D3) == 0xFAD7); + assert(f2(0xEA95, 0x58D3L) == 0xFAD7); + + assert(f2(0x58D3, 0xEA95) == 0xFAD7); + assert(f2(0x58D3L, 0xEA95) == 0xFAD7); + assert(f2(0x58D3, 0xEA95L) == 0xFAD7); + + assert(f2(0x58D3, 0) == 0x58D3); + assert(f2(0x58D3L, 0) == 0x58D3); + assert(f2(0x58D3, 0L) == 0x58D3); + + assert(f2(0xFFFF, 0x58D3) == 0xFFFF); + assert(f2(0xFFFFL, 0x58D3) == 0xFFFF); + assert(f2(0xFFFF, 0x58D3L) == 0xFFFF); +#endif } diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp index c3af462bbf2..8417d6ed25e 100644 --- a/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp @@ -25,4 +25,27 @@ int main() assert(f(0x58D3, 0xEA95) == 0xB246); assert(f(0x58D3, 0) == 0x58D3); assert(f(0xFFFF, 0x58D3) == 0xA72C); +#if _LIBCPP_STD_VER > 11 + typedef std::bit_xor<> F2; + const F2 f2 = F2(); + assert(f(0xEA95, 0xEA95) == 0); + assert(f(0xEA95L, 0xEA95) == 0); + assert(f(0xEA95, 0xEA95L) == 0); + + assert(f(0xEA95, 0x58D3) == 0xB246); + assert(f(0xEA95L, 0x58D3) == 0xB246); + assert(f(0xEA95, 0x58D3L) == 0xB246); + + assert(f(0x58D3, 0xEA95) == 0xB246); + assert(f(0x58D3L, 0xEA95) == 0xB246); + assert(f(0x58D3, 0xEA95L) == 0xB246); + + assert(f(0x58D3, 0) == 0x58D3); + assert(f(0x58D3L, 0) == 0x58D3); + assert(f(0x58D3, 0L) == 0x58D3); + + assert(f(0xFFFF, 0x58D3) == 0xA72C); + assert(f(0xFFFFL, 0x58D3) == 0xA72C); + assert(f(0xFFFF, 0x58D3L) == 0xA72C); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp index 988e957e982..7904887c686 100644 --- a/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp @@ -22,4 +22,12 @@ int main() static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), ""); assert(f(36, 36)); assert(!f(36, 6)); +#if _LIBCPP_STD_VER > 11 + typedef std::equal_to<> F2; + const F2 f2 = F2(); + assert(f2(36, 36)); + assert(!f2(36, 6)); + assert(f2(36, 36.0)); + assert(f2(36.0, 36L)); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp index 2cadd6def36..8e9a8919296 100644 --- a/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp @@ -23,4 +23,15 @@ int main() assert(!f(36, 36)); assert(f(36, 6)); assert(!f(6, 36)); +#if _LIBCPP_STD_VER > 11 + typedef std::greater<> F2; + const F2 f2 = F2(); + assert(!f2(36, 36)); + assert(f2(36, 6)); + assert(!f2(6, 36)); + assert( f2(36, 6.0)); + assert( f2(36.0, 6)); + assert(!f2(6, 36.0)); + assert(!f2(6.0, 36)); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp index 3ecadd416e0..63aad6751a7 100644 --- a/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp @@ -23,4 +23,15 @@ int main() assert(f(36, 36)); assert(f(36, 6)); assert(!f(6, 36)); +#if _LIBCPP_STD_VER > 11 + typedef std::greater_equal<> F2; + const F2 f2 = F2(); + assert(f2(36, 36)); + assert(f2(36, 6)); + assert(!f2(6, 36)); + assert( f2(36, 6.0)); + assert( f2(36.0, 6)); + assert(!f2(6, 36.0)); + assert(!f2(6.0, 36)); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp index 0946bbfa6f7..606096435a2 100644 --- a/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp @@ -23,4 +23,15 @@ int main() assert(!f(36, 36)); assert(!f(36, 6)); assert(f(6, 36)); +#if _LIBCPP_STD_VER > 11 + typedef std::less<> F2; + const F2 f2 = F2(); + assert(!f2(36, 36)); + assert(!f2(36, 6)); + assert( f2(6, 36)); + assert(!f2(36, 6.0)); + assert(!f2(36.0, 6)); + assert( f2(6, 36.0)); + assert( f2(6.0, 36)); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp index 818af4a8f6d..346e68b9768 100644 --- a/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp @@ -23,4 +23,15 @@ int main() assert(f(36, 36)); assert(!f(36, 6)); assert(f(6, 36)); +#if _LIBCPP_STD_VER > 11 + typedef std::less_equal<> F2; + const F2 f2 = F2(); + assert( f2(36, 36)); + assert(!f2(36, 6)); + assert( f2(6, 36)); + assert(!f2(36, 6.0)); + assert(!f2(36.0, 6)); + assert( f2(6, 36.0)); + assert( f2(6.0, 36)); +#endif } diff --git a/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp index 0b8f8dda87a..d481e47c449 100644 --- a/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp +++ b/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp @@ -22,4 +22,14 @@ int main() static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), ""); assert(!f(36, 36)); assert(f(36, 6)); +#if _LIBCPP_STD_VER > 11 + typedef std::not_equal_to<> F2; + const F2 f2 = F2(); + assert(!f2(36, 36)); + assert( f2(36, 6)); + assert( f2(36, 6.0)); + assert( f2(36.0, 6)); + assert(!f2(36.0, 36)); + assert(!f2(36, 36.0)); +#endif } diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp index 914eb4c67a1..4302f771046 100644 --- a/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp @@ -24,4 +24,19 @@ int main() assert(!f(36, 0)); assert(!f(0, 36)); assert(!f(0, 0)); +#if _LIBCPP_STD_VER > 11 + typedef std::logical_and<> F2; + const F2 f2 = F2(); + assert( f2(36, 36)); + assert( f2(36, 36L)); + assert( f2(36L, 36)); + assert(!f2(36, 0)); + assert(!f2(0, 36)); + assert( f2(36, 36L)); + assert(!f2(36, 0L)); + assert(!f2(0, 36L)); + assert( f2(36L, 36)); + assert(!f2(36L, 0)); + assert(!f2(0L, 36)); +#endif } diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp index 289c9241bd3..40a475445bc 100644 --- a/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp @@ -22,4 +22,12 @@ int main() static_assert((std::is_base_of<std::unary_function<int, bool>, F>::value), ""); assert(!f(36)); assert(f(0)); +#if _LIBCPP_STD_VER > 11 + typedef std::logical_not<> F2; + const F2 f2 = F2(); + assert(!f2(36)); + assert( f2(0)); + assert(!f2(36L)); + assert( f2(0L)); +#endif } diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp index 0cf217fc649..1c9b243c16d 100644 --- a/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp @@ -24,4 +24,18 @@ int main() assert(f(36, 0)); assert(f(0, 36)); assert(!f(0, 0)); +#if _LIBCPP_STD_VER > 11 + typedef std::logical_or<> F2; + const F2 f2 = F2(); + assert( f2(36, 36)); + assert( f2(36, 36L)); + assert( f2(36L, 36)); + assert( f2(36, 0)); + assert( f2(0, 36)); + assert( f2(36, 0L)); + assert( f2(0, 36L)); + assert(!f2(0, 0)); + assert(!f2(0, 0L)); + assert(!f2(0L, 0)); +#endif } |