diff options
Diffstat (limited to 'test/std/utilities/function.objects')
43 files changed, 712 insertions, 144 deletions
diff --git a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp index 490dc16b60e21..7419b70e0b8f6 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::divides<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" ); assert(f(36, 4) == 9); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::divides<> F2; const F2 f2 = F2(); assert(f2(36, 4) == 9); @@ -33,7 +35,7 @@ int main() constexpr int foo = std::divides<int> () (3, 2); static_assert ( foo == 1, "" ); - constexpr int bar = std::divides<> () (3.0, 2); - static_assert ( bar == 1, "" ); + constexpr double bar = std::divides<> () (3.0, 2); + static_assert ( bar == 1.5, "" ); // exact in binary #endif } diff --git a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp index 9bda541f896a8..25df69d60e964 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::minus<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" ); assert(f(3, 2) == 1); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::minus<> F2; const F2 f2 = F2(); assert(f2(3,2) == 1); @@ -33,7 +35,7 @@ int main() constexpr int foo = std::minus<int> () (3, 2); static_assert ( foo == 1, "" ); - constexpr int bar = std::minus<> () (3.0, 2); - static_assert ( bar == 1, "" ); + constexpr double bar = std::minus<> () (3.0, 2); + static_assert ( bar == 1.0, "" ); #endif } diff --git a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp index ca5bba6d5b8ea..6f39792e925ff 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::modulus<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" ); assert(f(36, 8) == 4); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::modulus<> F2; const F2 f2 = F2(); assert(f2(36, 8) == 4); diff --git a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp index f132c8d4bd9b2..2b354826960eb 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::multiplies<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" ); assert(f(3, 2) == 6); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::multiplies<> F2; const F2 f2 = F2(); assert(f2(3,2) == 6); @@ -33,7 +35,7 @@ int main() constexpr int foo = std::multiplies<int> () (3, 2); static_assert ( foo == 6, "" ); - constexpr int bar = std::multiplies<> () (3.0, 2); - static_assert ( bar == 6, "" ); + constexpr double bar = std::multiplies<> () (3.0, 2); + static_assert ( bar == 6.0, "" ); #endif } diff --git a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp index 0adac659123b4..198894023cd79 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::negate<int> F; @@ -22,7 +24,7 @@ int main() static_assert((std::is_same<F::argument_type, int>::value), "" ); static_assert((std::is_same<F::result_type, int>::value), "" ); assert(f(36) == -36); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::negate<> F2; const F2 f2 = F2(); assert(f2(36) == -36); @@ -32,7 +34,7 @@ int main() constexpr int foo = std::negate<int> () (3); static_assert ( foo == -3, "" ); - constexpr int bar = std::negate<> () (3.0); - static_assert ( bar == -3, "" ); + constexpr double bar = std::negate<> () (3.0); + static_assert ( bar == -3.0, "" ); #endif } diff --git a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp index ce544c78b6768..b56d3ef2b346a 100644 --- a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp +++ b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::plus<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" ); assert(f(3, 2) == 5); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::plus<> F2; const F2 f2 = F2(); assert(f2(3,2) == 5); @@ -33,7 +35,7 @@ int main() constexpr int foo = std::plus<int> () (3, 2); static_assert ( foo == 5, "" ); - constexpr int bar = std::plus<> () (3.0, 2); - static_assert ( bar == 5, "" ); + constexpr double bar = std::plus<> () (3.0, 2); + static_assert ( bar == 5.0, "" ); #endif } diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp index 63d3c9b0de923..a543fffedbb57 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp @@ -24,6 +24,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int dummy = 42; int return_value(int) { return dummy; } @@ -81,10 +83,10 @@ void do_test(Fn* func) { // Check that the call operator SFINAE's away when too few arguments // are provided but is well-formed otherwise. { - static_assert(!CheckCall<Bind>(), ""); + LIBCPP_STATIC_ASSERT(!CheckCall<Bind>(), ""); static_assert(CheckCall<Bind, int>(), ""); static_assert(CheckCall<Bind, int, int>(), ""); - static_assert(!CheckCall<BindR>(), ""); + LIBCPP_STATIC_ASSERT(!CheckCall<BindR>(), ""); static_assert(CheckCall<BindR, int>(), ""); static_assert(CheckCall<BindR, int, int>(), ""); } @@ -108,7 +110,7 @@ void do_test_r(Fn* func) { // Check that the call operator SFINAE's away when too few arguments // are provided but is well-formed otherwise. { - static_assert(!CheckCall<Bind>(), ""); + LIBCPP_STATIC_ASSERT(!CheckCall<Bind>(), ""); static_assert(CheckCall<Bind, int>(), ""); static_assert(CheckCall<Bind, int, int>(), ""); } diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp index a0c686de77ba4..180433109f26f 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp @@ -29,7 +29,7 @@ struct DummyUnaryFunction struct BadUnaryFunction { template <typename S> - constexpr int operator()(S const & s) const + constexpr int operator()(S const &) const { // Trigger a compile error if this function is instantiated. // The constexpr is needed so that it is instantiated while checking diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp index f61d93aefd896..0d4244b4d8605 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp @@ -28,7 +28,7 @@ struct power T operator()(T a, T b) { - return std::pow(a, b); + return static_cast<T>(std::pow(a, b)); } }; diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp index 83fa452fecb39..5d833e28830b2 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp @@ -14,12 +14,16 @@ // template<class T> struct is_bind_expression #include <functional> +#include "test_macros.h" template <bool Expected, class T> void test(const T&) { static_assert(std::is_bind_expression<T>::value == Expected, ""); +#if TEST_STD_VER > 14 + static_assert(std::is_bind_expression_v<T> == Expected, ""); +#endif } struct C {}; diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp index 6a52bd1848e9b..1d7c649dfc0e4 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp @@ -12,12 +12,16 @@ // struct is_placeholder #include <functional> +#include "test_macros.h" template <int Expected, class T> void test(const T&) { static_assert(std::is_placeholder<T>::value == Expected, ""); +#if TEST_STD_VER > 14 + static_assert(std::is_placeholder_v<T> == Expected, ""); +#endif } struct C {}; diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp index 68986ac1aeb34..59709d0ed5b2b 100644 --- a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp +++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp @@ -56,8 +56,34 @@ constexpr decltype(std::placeholders::_9) cp9 = std::placeholders::_9; constexpr decltype(std::placeholders::_10) cp10 = std::placeholders::_10; #endif // TEST_STD_VER >= 11 +void use_placeholders_to_prevent_unused_warning() { +#if TEST_STD_VER >= 11 + ((void)cp1); + ((void)cp2); + ((void)cp3); + ((void)cp4); + ((void)cp5); + ((void)cp6); + ((void)cp7); + ((void)cp8); + ((void)cp9); + ((void)cp10); + ((void)default1); + ((void)default2); + ((void)default3); + ((void)default4); + ((void)default5); + ((void)default6); + ((void)default7); + ((void)default8); + ((void)default9); + ((void)default10); +#endif +} + int main() { + use_placeholders_to_prevent_unused_warning(); test(std::placeholders::_1); test(std::placeholders::_2); test(std::placeholders::_3); diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp index c0135fad19827..12d968f42c0a3 100644 --- a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp +++ b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::bit_and<int> F; @@ -27,7 +29,7 @@ int main() assert(f(0x58D3, 0xEA95) == 0x4891); assert(f(0x58D3, 0) == 0); assert(f(0xFFFF, 0x58D3) == 0x58D3); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::bit_and<> F2; const F2 f2 = F2(); assert(f2(0xEA95, 0xEA95) == 0xEA95); diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp index cb33df3d84b7f..90dd9bc098bb6 100644 --- a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp +++ b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::bit_or<int> F; @@ -27,7 +29,7 @@ int main() assert(f(0x58D3, 0xEA95) == 0xFAD7); assert(f(0x58D3, 0) == 0x58D3); assert(f(0xFFFF, 0x58D3) == 0xFFFF); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::bit_or<> F2; const F2 f2 = F2(); assert(f2(0xEA95, 0xEA95) == 0xEA95); diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp index bbf2ce5baf1bb..a5cbd17a0d0e9 100644 --- a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp +++ b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { { @@ -29,7 +31,7 @@ int main() assert(f(0x58D3, 0) == 0x58D3); assert(f(0xFFFF, 0x58D3) == 0xA72C); } -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 { typedef std::bit_xor<> F2; const F2 f = F2(); diff --git a/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp b/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp index 66d783a6e3577..b23d4e8bb478c 100644 --- a/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp +++ b/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp @@ -19,13 +19,13 @@ void do_pointer_comparison_test() { #endif std::vector<std::shared_ptr<T> > pointers; const std::size_t test_size = 100; - for (int i=0; i < test_size; ++i) + for (size_t i=0; i < test_size; ++i) pointers.push_back(std::shared_ptr<T>(new T())); Compare comp; UIntCompare ucomp; VoidCompare vcomp; - for (int i=0; i < test_size; ++i) { - for (int j=0; j < test_size; ++j) { + for (size_t i=0; i < test_size; ++i) { + for (size_t j=0; j < test_size; ++j) { T* lhs = pointers[i].get(); T* rhs = pointers[j].get(); std::uintptr_t lhs_uint = reinterpret_cast<std::uintptr_t>(lhs); diff --git a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp new file mode 100644 index 0000000000000..aaac98474fcb2 --- /dev/null +++ b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// template <class F, class ...Args> +// result_of_t<F&&(Args&&...)> invoke(F&&, Args&&...); + +#include <functional> +#include <cassert> + +#include "test_macros.h" + +#if TEST_STD_VER <= 14 +# ifdef __cpp_lib_invoke +# error Feature test macro should be defined +# endif +#else +# ifndef __cpp_lib_invoke +# error Feature test macro not defined +# endif +# if __cpp_lib_invoke != 201411 +# error __cpp_lib_invoke has the wrong value +# endif +#endif + +int foo(int) { return 42; } + +int main() { +#if defined(__cpp_lib_invoke) + assert(std::invoke(foo, 101) == 42); +#endif +}
\ No newline at end of file diff --git a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp index c12fa7920974c..47a3e1cc59698 100644 --- a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp +++ b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp @@ -138,26 +138,26 @@ inline constexpr CallType operator|(CallType LHS, CallType RHS) { struct ForwardingCallObject { template <class ...Args> - bool operator()(Args&&... args) & { + bool operator()(Args&&...) & { set_call<Args&&...>(CT_NonConst | CT_LValue); return true; } template <class ...Args> - bool operator()(Args&&... args) const & { + bool operator()(Args&&...) const & { set_call<Args&&...>(CT_Const | CT_LValue); return true; } // Don't allow the call operator to be invoked as an rvalue. template <class ...Args> - bool operator()(Args&&... args) && { + bool operator()(Args&&...) && { set_call<Args&&...>(CT_NonConst | CT_RValue); return true; } template <class ...Args> - bool operator()(Args&&... args) const && { + bool operator()(Args&&...) const && { set_call<Args&&...>(CT_Const | CT_RValue); return true; } @@ -526,7 +526,6 @@ void call_operator_forwarding_test() assert(Fn::check_call<int&&>(CT_Const | CT_RValue)); } { // test multi arg - int x = 42; const double y = 3.14; std::string s = "abc"; obj(42, std::move(y), s, std::string{"foo"}); @@ -554,7 +553,10 @@ void call_operator_noexcept_test() using T = NoExceptCallable<bool>; T value(true); auto ret = std::not_fn(value); - static_assert(noexcept(!_VSTD::__invoke(value)), ""); + LIBCPP_STATIC_ASSERT(noexcept(!_VSTD::__invoke(value)), ""); +#if TEST_STD_VER > 14 + static_assert(noexcept(!std::invoke(value)), ""); +#endif static_assert(noexcept(ret()), "call should be noexcept"); auto const& cret = ret; static_assert(noexcept(cret()), "call should be noexcept"); @@ -577,6 +579,19 @@ void call_operator_noexcept_test() } } +void test_lwg2767() { + // See http://wg21.link/LWG2767 + struct Abstract { virtual void f() const = 0; }; + struct Derived : public Abstract { void f() const {} }; + struct F { bool operator()(Abstract&&) { return false; } }; + { + Derived d; + Abstract &a = d; + bool b = std::not_fn(F{})(std::move(a)); + assert(b); + } +} + int main() { constructor_tests(); @@ -586,4 +601,5 @@ int main() call_operator_sfinae_test(); // somewhat of an extension call_operator_forwarding_test(); call_operator_noexcept_test(); + test_lwg2767(); } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp new file mode 100644 index 0000000000000..e156fa966ac5a --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// XFAIL: c++11, c++14 + +// <functional> + +#include <functional> +#include <type_traits> + +#include "test_macros.h" + +struct S : public std::function<void()> { using function::function; }; + +int main() { + S f1( [](){} ); + S f2(std::allocator_arg, std::allocator<int>{}, f1); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp new file mode 100644 index 0000000000000..5bdf9e98e897a --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// REQUIRES-ANY: c++11, c++14 + +// <functional> + +// See https://llvm.org/bugs/show_bug.cgi?id=20002 + +#include <functional> +#include <type_traits> + +#include "test_macros.h" + +using Fn = std::function<void()>; +struct S : public std::function<void()> { using function::function; }; + +int main() { + S s( [](){} ); + S f1( s ); + S f2(std::allocator_arg, std::allocator<int>{}, s); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp index 58192c928d585..1a9206e0e7f39 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp @@ -12,13 +12,14 @@ // class function<R(ArgTypes...)> // template <MoveConstructible R, MoveConstructible ... ArgTypes> -// void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&); +// void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept; #include <functional> #include <cstdlib> #include <cassert> +#include "test_macros.h" #include "count_new.hpp" class A @@ -63,6 +64,9 @@ int main() { std::function<int(int)> f1 = A(1); std::function<int(int)> f2 = A(2); +#if TEST_STD_VER >= 11 + static_assert(noexcept(swap(f1, f2)), "" ); +#endif assert(A::count == 2); assert(globalMemCounter.checkOutstandingNewEq(2)); assert(f1.target<A>()->id() == 1); @@ -78,6 +82,9 @@ int main() { std::function<int(int)> f1 = A(1); std::function<int(int)> f2 = g; +#if TEST_STD_VER >= 11 + static_assert(noexcept(swap(f1, f2)), "" ); +#endif assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f1.target<A>()->id() == 1); @@ -93,6 +100,9 @@ int main() { std::function<int(int)> f1 = g; std::function<int(int)> f2 = A(1); +#if TEST_STD_VER >= 11 + static_assert(noexcept(swap(f1, f2)), "" ); +#endif assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(*f1.target<int(*)(int)>() == g); @@ -108,6 +118,9 @@ int main() { std::function<int(int)> f1 = g; std::function<int(int)> f2 = h; +#if TEST_STD_VER >= 11 + static_assert(noexcept(swap(f1, f2)), "" ); +#endif assert(A::count == 0); assert(globalMemCounter.checkOutstandingNewEq(0)); assert(*f1.target<int(*)(int)>() == g); diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp index 82a6f6c5215e9..fd296a7367b88 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp @@ -16,6 +16,7 @@ #include <functional> #include <cassert> +#include "test_macros.h" #include "count_new.hpp" class A @@ -49,6 +50,17 @@ int A::count = 0; int g(int) {return 0;} +#if TEST_STD_VER >= 11 +struct RValueCallable { + template <class ...Args> + void operator()(Args&&...) && {} +}; +struct LValueCallable { + template <class ...Args> + void operator()(Args&&...) & {} +}; +#endif + int main() { assert(globalMemCounter.checkOutstandingNewEq(0)); @@ -91,4 +103,13 @@ int main() std::function <void()> f(static_cast<void (*)()>(0)); assert(!f); } +#if TEST_STD_VER >= 11 + { + using Fn = std::function<void(int, int, int)>; + static_assert(std::is_constructible<Fn, LValueCallable&>::value, ""); + static_assert(std::is_constructible<Fn, LValueCallable>::value, ""); + static_assert(!std::is_constructible<Fn, RValueCallable&>::value, ""); + static_assert(!std::is_constructible<Fn, RValueCallable>::value, ""); + } +#endif } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp index 11716e7946b04..e927ad42c06b0 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp @@ -19,6 +19,7 @@ #include <functional> #include <cassert> +#include "test_macros.h" #include "count_new.hpp" class A @@ -52,6 +53,17 @@ int A::count = 0; int g(int) {return 0;} +#if TEST_STD_VER >= 11 +struct RValueCallable { + template <class ...Args> + void operator()(Args&&...) && {} +}; +struct LValueCallable { + template <class ...Args> + void operator()(Args&&...) & {} +}; +#endif + int main() { assert(globalMemCounter.checkOutstandingNewEq(0)); @@ -95,4 +107,13 @@ int main() assert(f.target<int(*)(int)>() != 0); f(1); } +#if TEST_STD_VER >= 11 + { + using Fn = std::function<void(int, int, int)>; + static_assert(std::is_assignable<Fn&, LValueCallable&>::value, ""); + static_assert(std::is_assignable<Fn&, LValueCallable>::value, ""); + static_assert(!std::is_assignable<Fn&, RValueCallable&>::value, ""); + static_assert(!std::is_assignable<Fn&, RValueCallable>::value, ""); + } +#endif } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp new file mode 100644 index 0000000000000..f455f0311847f --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// 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> +// XFAIL: c++98, c++03, c++11, c++14 + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&); + +#include <functional> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + std::function<int(int)> f(std::allocator_arg, std::allocator<int>()); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp index f97e34d3f2cbe..392dfc1993bce 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp @@ -8,10 +8,13 @@ //===----------------------------------------------------------------------===// // <functional> +// REQUIRES-ANY: c++98, c++03, c++11, c++14 // class function<R(ArgTypes...)> // template<class A> function(allocator_arg_t, const A&); +// +// This signature was removed in C++17 #include <functional> #include <cassert> diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp new file mode 100644 index 0000000000000..24f7fceb877b8 --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// 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> +// XFAIL: c++98, c++03, c++11, c++14 + +// class function<R(ArgTypes...)> + +// template<class F, class A> function(allocator_arg_t, const A&, F); +// +// This signature was removed in C++17 + +#include <functional> +#include <cassert> + +#include "test_macros.h" + +void foo(int) {} + +int main() +{ + std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp index 352ecfc602be4..8d454723320c4 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// // <functional> +// REQUIRES-ANY: c++98, c++03, c++11, c++14 // class function<R(ArgTypes...)> @@ -16,11 +17,24 @@ #include <functional> #include <cassert> +#include "test_macros.h" #include "min_allocator.h" #include "test_allocator.h" #include "count_new.hpp" #include "../function_types.h" + +#if TEST_STD_VER >= 11 +struct RValueCallable { + template <class ...Args> + void operator()(Args&&...) && {} +}; +struct LValueCallable { + template <class ...Args> + void operator()(Args&&...) & {} +}; +#endif + class DummyClass {}; template <class FuncType, class AllocType> @@ -103,4 +117,14 @@ int main() non_default_test_allocator<DummyClass> non_default_alloc(42); test_for_alloc(non_default_alloc); } +#if TEST_STD_VER >= 11 + { + using Fn = std::function<void(int, int, int)>; + static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable&>::value, ""); + static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable>::value, ""); + static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable&>::value, ""); + static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable>::value, ""); + } +#endif + } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp new file mode 100644 index 0000000000000..9967457ff821e --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// 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> +// XFAIL: c++98, c++03, c++11, c++14 + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, const function&); +// +// This signature was removed in C++17 + + +#include <functional> +#include <cassert> + +#include "test_macros.h" + +int main() +{ + typedef std::function<void(int)> F; + F f1; + F f2(std::allocator_arg, std::allocator<int>(), f1); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp index 371eb98de1a9b..718aa49341d22 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// // <functional> +// REQUIRES-ANY: c++98, c++03, c++11, c++14 // class function<R(ArgTypes...)> diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp new file mode 100644 index 0000000000000..cc4ecce751389 --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp @@ -0,0 +1,27 @@ +//===----------------------------------------------------------------------===// +// +// 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> +// XFAIL: c++98, c++03, c++11, c++14 + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, nullptr_t); +// +// This signature was removed in C++17 + +#include <functional> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + std::function<int(int)> f(std::allocator_arg, std::allocator<int>(), nullptr); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp index 2350f92f0f893..354ad955f207a 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp @@ -8,10 +8,13 @@ //===----------------------------------------------------------------------===// // <functional> +// REQUIRES-ANY: c++98, c++03, c++11, c++14 // class function<R(ArgTypes...)> // template<class A> function(allocator_arg_t, const A&, nullptr_t); +// +// This signature was removed in C++17 #include <functional> #include <cassert> diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp new file mode 100644 index 0000000000000..cb9fb9afad2ba --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> +// XFAIL: c++98, c++03, c++11, c++14 + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, function&&); +// +// This signature was removed in C++17 + +#include <functional> +#include <memory> +#include <cassert> + +#include "test_macros.h" + +class A +{ + int data_[10]; +public: + static int count; + + A() + { + ++count; + for (int i = 0; i < 10; ++i) + data_[i] = i; + } + + A(const A&) {++count;} + + ~A() {--count;} + + int operator()(int i) const + { + for (int j = 0; j < 10; ++j) + i += data_[j]; + return i; + } +}; + +int A::count = 0; + +int g(int) { return 0; } + +int main() +{ + { + std::function<int(int)> f = A(); + std::function<int(int)> f2(std::allocator_arg, std::allocator<A>(), std::move(f)); + } +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp index 403d646f4216e..e328481b274d0 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp @@ -8,12 +8,15 @@ //===----------------------------------------------------------------------===// // UNSUPPORTED: c++98, c++03 +// REQUIRES-ANY: c++11, c++14 // <functional> // class function<R(ArgTypes...)> // template<class A> function(allocator_arg_t, const A&, function&&); +// +// This signature was removed in C++17 #include <functional> #include <memory> diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp index c91eaa2d56744..9b83ddecb9742 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp @@ -16,94 +16,123 @@ #include <functional> #include <cassert> +#include "test_macros.h" #include "count_new.hpp" -class A -{ - int data_[10]; +class A { + int data_[10]; + public: - static int count; + static int count; - A() - { - ++count; - for (int i = 0; i < 10; ++i) - data_[i] = i; - } + A() { + ++count; + for (int i = 0; i < 10; ++i) + data_[i] = i; + } - A(const A&) {++count;} + A(const A &) { ++count; } - ~A() {--count;} + ~A() { --count; } - int operator()(int i) const - { - for (int j = 0; j < 10; ++j) - i += data_[j]; - return i; - } + int operator()(int i) const { + for (int j = 0; j < 10; ++j) + i += data_[j]; + return i; + } }; int A::count = 0; -int g(int) {return 0;} +int g0() { return 0; } +int g(int) { return 0; } +int g2(int, int) { return 2; } +int g3(int, int, int) { return 3; } -int main() -{ - assert(globalMemCounter.checkOutstandingNewEq(0)); - { +int main() { + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f = A(); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f.target<A>()); - assert(f.target<int(*)(int)>() == 0); + assert(f.target<int (*)(int)>() == 0); std::function<int(int)> f2; f2 = f; assert(A::count == 2); assert(globalMemCounter.checkOutstandingNewEq(2)); assert(f2.target<A>()); - assert(f2.target<int(*)(int)>() == 0); - } - assert(A::count == 0); - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + assert(f2.target<int (*)(int)>() == 0); + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f = g; assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(f.target<int(*)(int)>()); + assert(f.target<int (*)(int)>()); assert(f.target<A>() == 0); std::function<int(int)> f2; f2 = f; assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(f2.target<int(*)(int)>()); + assert(f2.target<int (*)(int)>()); assert(f2.target<A>() == 0); - } - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f; assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(f.target<int(*)(int)>() == 0); + assert(f.target<int (*)(int)>() == 0); assert(f.target<A>() == 0); std::function<int(int)> f2; f2 = f; assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(f2.target<int(*)(int)>() == 0); + assert(f2.target<int (*)(int)>() == 0); assert(f2.target<A>() == 0); - } -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + } + { + typedef std::function<int()> Func; + Func f = g0; + Func& fr = (f = f); + assert(&fr == &f); + assert(*f.target<int(*)()>() == g0); + } + { + typedef std::function<int(int)> Func; + Func f = g; + Func& fr = (f = f); + assert(&fr == &f); + assert(*f.target<int(*)(int)>() == g); + } + { + typedef std::function<int(int, int)> Func; + Func f = g2; + Func& fr = (f = f); + assert(&fr == &f); + assert(*f.target<int(*)(int, int)>() == g2); + } + { + typedef std::function<int(int, int, int)> Func; + Func f = g3; + Func& fr = (f = f); + assert(&fr == &f); + assert(*f.target<int(*)(int, int, int)>() == g3); + } +#if TEST_STD_VER >= 11 + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f = A(); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f.target<A>()); - assert(f.target<int(*)(int)>() == 0); + assert(f.target<int (*)(int)>() == 0); std::function<int(int)> f2; f2 = std::move(f); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f2.target<A>()); - assert(f2.target<int(*)(int)>() == 0); + assert(f2.target<int (*)(int)>() == 0); assert(f.target<A>() == 0); - assert(f.target<int(*)(int)>() == 0); - } -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + assert(f.target<int (*)(int)>() == 0); + } +#endif } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp index 387b371a93311..9d5681a3db769 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp @@ -132,7 +132,7 @@ int main() assert(A::count == 1); assert(f2.target<A>() == nullptr); assert(f2.target<Ref>()); - assert(f.target<Ref>()); // f is unchanged because the target is small + LIBCPP_ASSERT(f.target<Ref>()); // f is unchanged because the target is small } { // Test that moving a function constructed from a function pointer @@ -146,7 +146,7 @@ int main() std::function<int(int)> f2(std::move(f)); assert(f2.target<A>() == nullptr); assert(f2.target<Ptr>()); - assert(f.target<Ptr>()); // f is unchanged because the target is small + LIBCPP_ASSERT(f.target<Ptr>()); // f is unchanged because the target is small } #endif // TEST_STD_VER >= 11 } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp index f94e689b2a6bc..214c3f7c5d832 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp @@ -18,46 +18,49 @@ #include "count_new.hpp" -class A -{ - int data_[10]; +class A { + int data_[10]; + public: - static int count; + static int count; - explicit A(int j) - { - ++count; - data_[0] = j; - } + explicit A(int j) { + ++count; + data_[0] = j; + } - A(const A& a) - { - ++count; - for (int i = 0; i < 10; ++i) - data_[i] = a.data_[i]; - } + A(const A &a) { + ++count; + for (int i = 0; i < 10; ++i) + data_[i] = a.data_[i]; + } - ~A() {--count;} + ~A() { --count; } - int operator()(int i) const - { - for (int j = 0; j < 10; ++j) - i += data_[j]; - return i; - } + int operator()(int i) const { + for (int j = 0; j < 10; ++j) + i += data_[j]; + return i; + } + + int operator()() const { return -1; } + int operator()(int, int) const { return -2; } + int operator()(int, int, int) const { return -3; } - int id() const {return data_[0];} + int id() const { return data_[0]; } }; int A::count = 0; -int g(int) {return 0;} -int h(int) {return 1;} +int g0() { return 0; } +int g(int) { return 0; } +int h(int) { return 1; } +int g2(int, int) { return 2; } +int g3(int, int, int) { return 3; } -int main() -{ - assert(globalMemCounter.checkOutstandingNewEq(0)); - { +int main() { + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f1 = A(1); std::function<int(int)> f2 = A(2); assert(A::count == 2); @@ -69,52 +72,122 @@ int main() assert(globalMemCounter.checkOutstandingNewEq(2)); assert(f1.target<A>()->id() == 2); assert(f2.target<A>()->id() == 1); - } - assert(A::count == 0); - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f1 = A(1); std::function<int(int)> f2 = g; assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f1.target<A>()->id() == 1); - assert(*f2.target<int(*)(int)>() == g); + assert(*f2.target<int (*)(int)>() == g); f1.swap(f2); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); - assert(*f1.target<int(*)(int)>() == g); + assert(*f1.target<int (*)(int)>() == g); assert(f2.target<A>()->id() == 1); - } - assert(A::count == 0); - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f1 = g; std::function<int(int)> f2 = A(1); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); - assert(*f1.target<int(*)(int)>() == g); + assert(*f1.target<int (*)(int)>() == g); assert(f2.target<A>()->id() == 1); f1.swap(f2); assert(A::count == 1); assert(globalMemCounter.checkOutstandingNewEq(1)); assert(f1.target<A>()->id() == 1); - assert(*f2.target<int(*)(int)>() == g); - } - assert(A::count == 0); - assert(globalMemCounter.checkOutstandingNewEq(0)); - { + assert(*f2.target<int (*)(int)>() == g); + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { std::function<int(int)> f1 = g; std::function<int(int)> f2 = h; assert(A::count == 0); assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(*f1.target<int(*)(int)>() == g); - assert(*f2.target<int(*)(int)>() == h); + assert(*f1.target<int (*)(int)>() == g); + assert(*f2.target<int (*)(int)>() == h); f1.swap(f2); assert(A::count == 0); assert(globalMemCounter.checkOutstandingNewEq(0)); - assert(*f1.target<int(*)(int)>() == h); - assert(*f2.target<int(*)(int)>() == g); + assert(*f1.target<int (*)(int)>() == h); + assert(*f2.target<int (*)(int)>() == g); + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { + std::function<int(int)> f1 = A(1); + assert(A::count == 1); + { + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); } - assert(A::count == 0); - assert(globalMemCounter.checkOutstandingNewEq(0)); + assert(A::count == 1); + assert(f1.target<A>()->id() == 1); + } + assert(A::count == 0); + assert(globalMemCounter.checkOutstandingNewEq(0)); + { + std::function<int()> f1 = g0; + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(*f1.target<int (*)()>() == g0); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + { + std::function<int(int, int)> f1 = g2; + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(*f1.target<int (*)(int, int)>() == g2); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + { + std::function<int(int, int, int)> f1 = g3; + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(*f1.target<int (*)(int, int, int)>() == g3); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + { + std::function<int()> f1 = A(1); + assert(A::count == 1); + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(A::count == 1); + assert(f1.target<A>()->id() == 1); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + assert(A::count == 0); + { + std::function<int(int, int)> f1 = A(2); + assert(A::count == 1); + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(A::count == 1); + assert(f1.target<A>()->id() == 2); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + assert(A::count == 0); + { + std::function<int(int, int, int)> f1 = A(3); + assert(A::count == 1); + DisableAllocationGuard guard; + ((void)guard); + f1.swap(f1); + assert(A::count == 1); + assert(f1.target<A>()->id() == 3); + } + assert(globalMemCounter.checkOutstandingNewEq(0)); + assert(A::count == 0); } diff --git a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp index 72f9dc20144de..ac94fa5362e89 100644 --- a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp +++ b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::logical_and<int> F; @@ -26,7 +28,7 @@ int main() assert(!f(36, 0)); assert(!f(0, 36)); assert(!f(0, 0)); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::logical_and<> F2; const F2 f2 = F2(); assert( f2(36, 36)); diff --git a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp index 8484625a727c1..4f783dd0f23a1 100644 --- a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp +++ b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::logical_not<int> F; @@ -23,7 +25,7 @@ int main() static_assert((std::is_same<F::result_type, bool>::value), "" ); assert(!f(36)); assert(f(0)); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::logical_not<> F2; const F2 f2 = F2(); assert(!f2(36)); diff --git a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp index 7280504403f48..3c450a05de19a 100644 --- a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp +++ b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp @@ -15,6 +15,8 @@ #include <type_traits> #include <cassert> +#include "test_macros.h" + int main() { typedef std::logical_or<int> F; @@ -26,7 +28,7 @@ int main() assert(f(36, 0)); assert(f(0, 36)); assert(!f(0, 0)); -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 typedef std::logical_or<> F2; const F2 f2 = F2(); assert( f2(36, 36)); diff --git a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp index 3c00bd20ac648..261a306ca156e 100644 --- a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp +++ b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp @@ -21,7 +21,9 @@ #include <type_traits> #include <string> -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#include "test_macros.h" + +#if TEST_STD_VER >= 11 class MoveOnly { MoveOnly(const MoveOnly&); @@ -55,7 +57,7 @@ int main() test<int>(); test<double>(); test<std::string>(); -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#if TEST_STD_VER >= 11 test<MoveOnly>(); #endif } diff --git a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp index 8aa2c1df89358..af367789a105b 100644 --- a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp +++ b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp @@ -7,6 +7,8 @@ // //===----------------------------------------------------------------------===// +// UNSUPPORTED: c++98, c++03, c++11 + // <functional> // make sure that we can hash enumeration values @@ -14,8 +16,6 @@ #include "test_macros.h" -#if TEST_STD_VER >= 14 - #include <functional> #include <cassert> #include <type_traits> @@ -59,6 +59,3 @@ int main() test<Fruits>(); } -#else -int main () {} -#endif diff --git a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp index 8954f4f3664b7..2f3f9bee4bc36 100644 --- a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp +++ b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp @@ -35,11 +35,11 @@ test() for (int i = 0; i <= 5; ++i) { - T t(i); + T t(static_cast<T>(i)); if (sizeof(T) <= sizeof(std::size_t)) { const std::size_t result = h(t); - LIBCPP_ASSERT(result == t); + LIBCPP_ASSERT(result == static_cast<size_t>(t)); ((void)result); // Prevent unused warning } } diff --git a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp new file mode 100644 index 0000000000000..ed173f280d057 --- /dev/null +++ b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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 + +// <functional> + +// Hashing a struct w/o a defined hash should *not* fail, but it should +// create a type that is not constructible and not callable. +// See also: http://cplusplus.github.io/LWG/lwg-active.html#2543 + +#include <functional> +#include <cassert> +#include <type_traits> + +#include "test_macros.h" + +struct X {}; + +int main() +{ + using H = std::hash<X>; + static_assert(!std::is_default_constructible<H>::value, ""); + static_assert(!std::is_copy_constructible<H>::value, ""); + static_assert(!std::is_move_constructible<H>::value, ""); + static_assert(!std::is_copy_assignable<H>::value, ""); + static_assert(!std::is_move_assignable<H>::value, ""); +#if TEST_STD_VER > 14 + static_assert(!std::is_callable<H(X&)>::value, ""); + static_assert(!std::is_callable<H(X const&)>::value, ""); +#endif +} |