From b4c64ad90b81d2a779786b7edb4c5c6dd28cc57d Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Wed, 30 Dec 2015 11:54:09 +0000 Subject: Vendor import of libc++ trunk r256633: https://llvm.org/svn/llvm-project/libcxx/trunk@256633 --- .../func.wrap.func/func.wrap.func.con/F.pass.cpp | 6 +- .../func.wrap.func.con/F_nullptr.pass.cpp | 247 +++++++++++++ .../func.wrap.func.con/no-variadics.pass.cpp | 24 -- .../func.wrap.func.inv/invoke.fail.cpp | 14 +- .../func.wrap.func.inv/invoke.pass.cpp | 382 +++++++++++++-------- .../func.wrap.func.inv/invoke_int_0.pass.cpp | 58 ---- .../invoke_no_variadics.pass.cpp | 60 ---- .../func.wrap.func.inv/invoke_void_0.pass.cpp | 67 ---- 8 files changed, 489 insertions(+), 369 deletions(-) create mode 100644 test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/no-variadics.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_no_variadics.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp (limited to 'test/std/utilities/function.objects/func.wrap') 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 cd86e4cbf8eb..82a6f6c5215e 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 @@ -11,7 +11,7 @@ // class function -// function(nullptr_t); +// function(F); #include #include @@ -87,4 +87,8 @@ int main() assert(f.target() != 0); f(1); } + { + std::function f(static_cast(0)); + assert(!f); + } } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp new file mode 100644 index 000000000000..f89bde8e6544 --- /dev/null +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp @@ -0,0 +1,247 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// + +// class function + +// function(Fp); + +// Ensure that __not_null works for all function types. +// See https://llvm.org/bugs/show_bug.cgi?id=23589 + +//------------------------------------------------------------------------------ +// TESTING std::function<...>::__not_null(Callable) +// +// Concerns: +// 1) The call __not_null(Callable) is well formed and correct for each +// possible 'Callable' type category. These categories include: +// 1a) function pointers +// 1b) member function pointer +// 1c) member data pointer +// 1d) callable class type +// 1e) lambdas +// Categories 1a, 1b, and 1c are 'Nullable' types. Only objects of these +// types can be null. The other categories are not tested here. +// 3) '__not_null(Callable)' is well formed when the call signature includes +// varargs. +// 4) '__not_null(Callable)' works for Callable types with all aritys less +// than or equal to 3 in C++03. +// 5) '__not_null(Callable)' works when 'Callable' is a member function +// pointer to a cv or ref qualified function type. +// +// Plan: +// 1 For categories 1a, 1b and 1c define a set of +// 'Callable' objects for this category. This set should include examples +// of arity 0, 1, 2 and possible 3 including versions with varargs as the +// last parameter. +// +// 2 For each 'Callable' object in categories 1a, 1b and 1c do the following. +// +// 1 Define a type 'std::function' as 'F' where 'Sig' is compatible with +// the signature of the 'Callable' object. +// +// 2 Create an object of type 'F' using a null pointer of type 'Callable'. +// Check that 'F.target()' is null. +// +// 3 Create an object of type 'F' that is not null. Check that +// 'F.target()' is not null and is equal to the original +// argument. + +#include +#include +#include + +#include "test_macros.h" + +/////////////////////////////////////////////////////////////////////////////// +int foo() { return 42; } +int foo(int) { return 42; } +int foo(int, int) { return 42; } +int foo(int, int, int) { return 42; } + +int foo(...) { return 42; } +int foo(int, ...) { return 42; } +int foo(int, int, ...) { return 42; } +int foo(int, int, int, ...) { return 42; } + +/////////////////////////////////////////////////////////////////////////////// +struct MemFun03 { + int foo() { return 42; } + int foo() const { return 42; } + int foo() volatile { return 42; } + int foo() const volatile { return 42; } + + int foo(int) { return 42; } + int foo(int) const { return 42; } + int foo(int) volatile { return 42; } + int foo(int) const volatile { return 42; } + + int foo(int, int) { return 42; } + int foo(int, int) const { return 42; } + int foo(int, int) volatile { return 42; } + int foo(int, int) const volatile { return 42; } + + int foo(int, int, int) { return 42; } + int foo(int, int, int) const { return 42; } + int foo(int, int, int) volatile { return 42; } + int foo(int, int, int) const volatile { return 42; } + + int foo(...) { return 42; } + int foo(...) const { return 42; } + int foo(...) volatile { return 42; } + int foo(...) const volatile { return 42; } + + int foo(int, ...) { return 42; } + int foo(int, ...) const { return 42; } + int foo(int, ...) volatile { return 42; } + int foo(int, ...) const volatile { return 42; } + + int foo(int, int, ...) { return 42; } + int foo(int, int, ...) const { return 42; } + int foo(int, int, ...) volatile { return 42; } + int foo(int, int, ...) const volatile { return 42; } + + int foo(int, int, int, ...) { return 42; } + int foo(int, int, int, ...) const { return 42; } + int foo(int, int, int, ...) volatile { return 42; } + int foo(int, int, int, ...) const volatile { return 42; } +}; + +#if TEST_STD_VER >= 11 +struct MemFun11 { + int foo() & { return 42; } + int foo() const & { return 42; } + int foo() volatile & { return 42; } + int foo() const volatile & { return 42; } + + int foo(...) & { return 42; } + int foo(...) const & { return 42; } + int foo(...) volatile & { return 42; } + int foo(...) const volatile & { return 42; } + + int foo() && { return 42; } + int foo() const && { return 42; } + int foo() volatile && { return 42; } + int foo() const volatile && { return 42; } + + int foo(...) && { return 42; } + int foo(...) const && { return 42; } + int foo(...) volatile && { return 42; } + int foo(...) const volatile && { return 42; } +}; +#endif // TEST_STD_VER >= 11 + +struct MemData { + int foo; +}; + +// Create a non-null free function by taking the address of +// &static_cast(foo); +template +struct Creator { + static Tp create() { + return &foo; + } +}; + +// Create a non-null member pointer. +template +struct Creator { + typedef Ret Class::*ReturnType; + static ReturnType create() { + return &Class::foo; + } +}; + +template +void test_imp() { + { // Check that the null value is detected + TestFn tf = nullptr; + std::function f = tf; + assert(f.template target() == nullptr); + } + { // Check that the non-null value is detected. + TestFn tf = Creator::create(); + assert(tf != nullptr); + std::function f = tf; + assert(f.template target() != nullptr); + assert(*f.template target() == tf); + } +} + +void test_func() { + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); +} + +void test_mf() { + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + +#if TEST_STD_VER >= 11 + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); + test_imp(); +#endif +} + +void test_md() { + test_imp(); +} + +int main() { + test_func(); + test_mf(); + test_md(); +} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/no-variadics.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/no-variadics.pass.cpp deleted file mode 100644 index 7099c45fab81..000000000000 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/no-variadics.pass.cpp +++ /dev/null @@ -1,24 +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. -// -//===----------------------------------------------------------------------===// - -// - -// class function - -// template function(F); - -#define _LIBCPP_HAS_NO_VARIADICS -#include -#include - -int main() -{ - std::function f(static_cast(0)); - assert(!f); -} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp index 6dcd2857452c..61eda7244d3b 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp @@ -30,13 +30,13 @@ test_int_1() { // member data pointer { - int A_int_1::*fp = &A_int_1::data_; - A_int_1 a; - std::function r2(fp); - const A_int_1* ap = &a; - assert(r2(ap) == 6); - r2(ap) = 7; - assert(r2(ap) == 7); + int A_int_1::*fp = &A_int_1::data_; + A_int_1 a; + std::function r2(fp); + const A_int_1* ap = &a; + assert(r2(ap) == 6); + r2(ap) = 7; + assert(r2(ap) == 7); } } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp index 31b80c3323c1..cc4315c14422 100644 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp +++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp @@ -16,8 +16,85 @@ #include #include + int count = 0; + +// 0 args, return int + +int f_int_0() +{ + return 3; +} + +struct A_int_0 +{ + int operator()() {return 4;} +}; + +void test_int_0() +{ + // function + { + std::function r1(f_int_0); + assert(r1() == 3); + } + // function pointer + { + int (*fp)() = f_int_0; + std::function r1(fp); + assert(r1() == 3); + } + // functor + { + A_int_0 a0; + std::function r1(a0); + assert(r1() == 4); + } +} + + +// 0 args, return void + +void f_void_0() +{ + ++count; +} + +struct A_void_0 +{ + void operator()() {++count;} +}; + +void +test_void_0() +{ + int save_count = count; + // function + { + std::function r1(f_void_0); + r1(); + assert(count == save_count+1); + save_count = count; + } + // function pointer + { + void (*fp)() = f_void_0; + std::function r1(fp); + r1(); + assert(count == save_count+1); + save_count = count; + } + // functor + { + A_void_0 a0; + std::function r1(a0); + r1(); + assert(count == save_count+1); + save_count = count; + } +} + // 1 arg, return void void f_void_1(int i) @@ -42,57 +119,57 @@ test_void_1() int save_count = count; // function { - std::function r1(f_void_1); - int i = 2; - r1(i); - assert(count == save_count+2); - save_count = count; + std::function r1(f_void_1); + int i = 2; + r1(i); + assert(count == save_count+2); + save_count = count; } // function pointer { - void (*fp)(int) = f_void_1; - std::function r1(fp); - int i = 3; - r1(i); - assert(count == save_count+3); - save_count = count; + void (*fp)(int) = f_void_1; + std::function r1(fp); + int i = 3; + r1(i); + assert(count == save_count+3); + save_count = count; } // functor { - A_void_1 a0; - std::function r1(a0); - int i = 4; - r1(i); - assert(count == save_count+4); - save_count = count; + A_void_1 a0; + std::function r1(a0); + int i = 4; + r1(i); + assert(count == save_count+4); + save_count = count; } // member function pointer { - void (A_void_1::*fp)() = &A_void_1::mem1; - std::function r1(fp); - A_void_1 a; - r1(a); - assert(count == save_count+1); - save_count = count; - A_void_1* ap = &a; - std::function r2 = fp; - r2(ap); - assert(count == save_count+1); - save_count = count; + void (A_void_1::*fp)() = &A_void_1::mem1; + std::function r1(fp); + A_void_1 a; + r1(a); + assert(count == save_count+1); + save_count = count; + A_void_1* ap = &a; + std::function r2 = fp; + r2(ap); + assert(count == save_count+1); + save_count = count; } // const member function pointer { - void (A_void_1::*fp)() const = &A_void_1::mem2; - std::function r1(fp); - A_void_1 a; - r1(a); - assert(count == save_count+1); - save_count = count; - std::function r2(fp); - A_void_1* ap = &a; - r2(ap); - assert(count == save_count+1); - save_count = count; + void (A_void_1::*fp)() const = &A_void_1::mem2; + std::function r1(fp); + A_void_1 a; + r1(a); + assert(count == save_count+1); + save_count = count; + std::function r2(fp); + A_void_1* ap = &a; + r2(ap); + assert(count == save_count+1); + save_count = count; } } @@ -121,57 +198,57 @@ test_int_1() { // function { - std::function r1(f_int_1); - int i = 2; - assert(r1(i) == 3); + std::function r1(f_int_1); + int i = 2; + assert(r1(i) == 3); } // function pointer { - int (*fp)(int) = f_int_1; - std::function r1(fp); - int i = 3; - assert(r1(i) == 4); + int (*fp)(int) = f_int_1; + std::function r1(fp); + int i = 3; + assert(r1(i) == 4); } // functor { - A_int_1 a0; - std::function r1(a0); - int i = 4; - assert(r1(i) == 3); + A_int_1 a0; + std::function r1(a0); + int i = 4; + assert(r1(i) == 3); } // member function pointer { - int (A_int_1::*fp)() = &A_int_1::mem1; - std::function r1(fp); - A_int_1 a; - assert(r1(a) == 3); - std::function r2(fp); - A_int_1* ap = &a; - assert(r2(ap) == 3); + int (A_int_1::*fp)() = &A_int_1::mem1; + std::function r1(fp); + A_int_1 a; + assert(r1(a) == 3); + std::function r2(fp); + A_int_1* ap = &a; + assert(r2(ap) == 3); } // const member function pointer { - int (A_int_1::*fp)() const = &A_int_1::mem2; - std::function r1(fp); - A_int_1 a; - assert(r1(a) == 4); - std::function r2(fp); - A_int_1* ap = &a; - assert(r2(ap) == 4); + int (A_int_1::*fp)() const = &A_int_1::mem2; + std::function r1(fp); + A_int_1 a; + assert(r1(a) == 4); + std::function r2(fp); + A_int_1* ap = &a; + assert(r2(ap) == 4); } // member data pointer { - int A_int_1::*fp = &A_int_1::data_; - std::function r1(fp); - A_int_1 a; - assert(r1(a) == 5); - r1(a) = 6; - assert(r1(a) == 6); - std::function r2(fp); - A_int_1* ap = &a; - assert(r2(ap) == 6); - r2(ap) = 7; - assert(r2(ap) == 7); + int A_int_1::*fp = &A_int_1::data_; + std::function r1(fp); + A_int_1 a; + assert(r1(a) == 5); + r1(a) = 6; + assert(r1(a) == 6); + std::function r2(fp); + A_int_1* ap = &a; + assert(r2(ap) == 6); + r2(ap) = 7; + assert(r2(ap) == 7); } } @@ -199,62 +276,62 @@ test_void_2() int save_count = count; // function { - std::function r1(f_void_2); - int i = 2; - int j = 3; - r1(i, j); - assert(count == save_count+5); - save_count = count; + std::function r1(f_void_2); + int i = 2; + int j = 3; + r1(i, j); + assert(count == save_count+5); + save_count = count; } // function pointer { - void (*fp)(int, int) = f_void_2; - std::function r1(fp); - int i = 3; - int j = 4; - r1(i, j); - assert(count == save_count+7); - save_count = count; + void (*fp)(int, int) = f_void_2; + std::function r1(fp); + int i = 3; + int j = 4; + r1(i, j); + assert(count == save_count+7); + save_count = count; } // functor { - A_void_2 a0; - std::function r1(a0); - int i = 4; - int j = 5; - r1(i, j); - assert(count == save_count+9); - save_count = count; + A_void_2 a0; + std::function r1(a0); + int i = 4; + int j = 5; + r1(i, j); + assert(count == save_count+9); + save_count = count; } // member function pointer { - void (A_void_2::*fp)(int) = &A_void_2::mem1; - std::function r1(fp); - A_void_2 a; - int i = 3; - r1(a, i); - assert(count == save_count+3); - save_count = count; - std::function r2(fp); - A_void_2* ap = &a; - r2(ap, i); - assert(count == save_count+3); - save_count = count; + void (A_void_2::*fp)(int) = &A_void_2::mem1; + std::function r1(fp); + A_void_2 a; + int i = 3; + r1(a, i); + assert(count == save_count+3); + save_count = count; + std::function r2(fp); + A_void_2* ap = &a; + r2(ap, i); + assert(count == save_count+3); + save_count = count; } // const member function pointer { - void (A_void_2::*fp)(int) const = &A_void_2::mem2; - std::function r1(fp); - A_void_2 a; - int i = 4; - r1(a, i); - assert(count == save_count+4); - save_count = count; - std::function r2(fp); - A_void_2* ap = &a; - r2(ap, i); - assert(count == save_count+4); - save_count = count; + void (A_void_2::*fp)(int) const = &A_void_2::mem2; + std::function r1(fp); + A_void_2 a; + int i = 4; + r1(a, i); + assert(count == save_count+4); + save_count = count; + std::function r2(fp); + A_void_2* ap = &a; + r2(ap, i); + assert(count == save_count+4); + save_count = count; } } @@ -276,60 +353,61 @@ struct A_int_2 int mem2(int i) const {return i+2;} }; -void -testint_2() +void test_int_2() { // function { - std::function r1(f_int_2); - int i = 2; - int j = 3; - assert(r1(i, j) == i+j); + std::function r1(f_int_2); + int i = 2; + int j = 3; + assert(r1(i, j) == i+j); } // function pointer { - int (*fp)(int, int) = f_int_2; - std::function r1(fp); - int i = 3; - int j = 4; - assert(r1(i, j) == i+j); + int (*fp)(int, int) = f_int_2; + std::function r1(fp); + int i = 3; + int j = 4; + assert(r1(i, j) == i+j); } // functor { - A_int_2 a0; - std::function r1(a0); - int i = 4; - int j = 5; - assert(r1(i, j) == i+j); + A_int_2 a0; + std::function r1(a0); + int i = 4; + int j = 5; + assert(r1(i, j) == i+j); } // member function pointer { - int(A_int_2::*fp)(int) = &A_int_2::mem1; - std::function r1(fp); - A_int_2 a; - int i = 3; - assert(r1(a, i) == i+1); - std::function r2(fp); - A_int_2* ap = &a; - assert(r2(ap, i) == i+1); + int(A_int_2::*fp)(int) = &A_int_2::mem1; + std::function r1(fp); + A_int_2 a; + int i = 3; + assert(r1(a, i) == i+1); + std::function r2(fp); + A_int_2* ap = &a; + assert(r2(ap, i) == i+1); } // const member function pointer { - int (A_int_2::*fp)(int) const = &A_int_2::mem2; - std::function r1(fp); - A_int_2 a; - int i = 4; - assert(r1(a, i) == i+2); - std::function r2(fp); - A_int_2* ap = &a; - assert(r2(ap, i) == i+2); + int (A_int_2::*fp)(int) const = &A_int_2::mem2; + std::function r1(fp); + A_int_2 a; + int i = 4; + assert(r1(a, i) == i+2); + std::function r2(fp); + A_int_2* ap = &a; + assert(r2(ap, i) == i+2); } } int main() { + test_void_0(); + test_int_0(); test_void_1(); test_int_1(); test_void_2(); - testint_2(); + test_int_2(); } diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp deleted file mode 100644 index 67b4ec22da8c..000000000000 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp +++ /dev/null @@ -1,58 +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. -// -//===----------------------------------------------------------------------===// - -// - -// class function - -// R operator()(ArgTypes... args) const - -#include -#include - -// 0 args, return int - -int count = 0; - -int f_int_0() -{ - return 3; -} - -struct A_int_0 -{ - int operator()() {return 4;} -}; - -void -test_int_0() -{ - // function - { - std::function r1(f_int_0); - assert(r1() == 3); - } - // function pointer - { - int (*fp)() = f_int_0; - std::function r1(fp); - assert(r1() == 3); - } - // functor - { - A_int_0 a0; - std::function r1(a0); - assert(r1() == 4); - } -} - -int main() -{ - test_int_0(); -} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_no_variadics.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_no_variadics.pass.cpp deleted file mode 100644 index c0a14fd96fcb..000000000000 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_no_variadics.pass.cpp +++ /dev/null @@ -1,60 +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. -// -//===----------------------------------------------------------------------===// - -// - -// class function - -// Test that we properly return both values and void for all non-variadic -// overloads of function::operator()(...) - -#define _LIBCPP_HAS_NO_VARIADICS -#include -#include - -int foo0() { return 42; } -int foo1(int) { return 42; } -int foo2(int, int) { return 42; } -int foo3(int, int, int) { return 42; } - -int main() -{ - { - std::function f(&foo0); - assert(f() == 42); - } - { - std::function f(&foo1); - assert(f(1) == 42); - } - { - std::function f(&foo2); - assert(f(1, 1) == 42); - } - { - std::function f(&foo3); - assert(f(1, 1, 1) == 42); - } - { - std::function f(&foo0); - f(); - } - { - std::function f(&foo1); - f(1); - } - { - std::function f(&foo2); - f(1, 1); - } - { - std::function f(&foo3); - f(1, 1, 1); - } -} diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp deleted file mode 100644 index a820cb1b8f38..000000000000 --- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp +++ /dev/null @@ -1,67 +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. -// -//===----------------------------------------------------------------------===// - -// - -// class function - -// R operator()(ArgTypes... args) const - -#include -#include -#include -#include - -// 0 args, return void - -int count = 0; - -void f_void_0() -{ - ++count; -} - -struct A_void_0 -{ - void operator()() {++count;} -}; - -void -test_void_0() -{ - int save_count = count; - // function - { - std::function r1(f_void_0); - r1(); - assert(count == save_count+1); - save_count = count; - } - // function pointer - { - void (*fp)() = f_void_0; - std::function r1(fp); - r1(); - assert(count == save_count+1); - save_count = count; - } - // functor - { - A_void_0 a0; - std::function r1(a0); - r1(); - assert(count == save_count+1); - save_count = count; - } -} - -int main() -{ - test_void_0(); -} -- cgit v1.3