diff options
Diffstat (limited to 'libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind')
4 files changed, 627 insertions, 4 deletions
diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp index 28ec9d4b123..61211308bba 100644 --- a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp @@ -1 +1,53 @@ -//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <functional>
#include <cassert>
template <class R, class F>
void
test(F f, R expected)
{
assert(f() == expected);
}
template <class R, class F>
void
test_const(const F& f, R expected)
{
assert(f() == expected);
}
int f() {return 1;}
struct A_int_0
{
int operator()() {return 4;}
int operator()() const {return 5;}
};
int main()
{
test(std::bind(f), 1);
test(std::bind(&f), 1);
test(std::bind(A_int_0()), 4);
test_const(std::bind(A_int_0()), 5);
test(std::bind<int>(f), 1);
test(std::bind<int>(&f), 1);
test(std::bind<int>(A_int_0()), 4);
test_const(std::bind<int>(A_int_0()), 5);
}
\ No newline at end of file +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template<CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); +// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); + +#include <functional> +#include <cassert> + +template <class R, class F> +void +test(F f, R expected) +{ + assert(f() == expected); +} + +template <class R, class F> +void +test_const(const F& f, R expected) +{ + assert(f() == expected); +} + +int f() {return 1;} + +struct A_int_0 +{ + int operator()() {return 4;} + int operator()() const {return 5;} +}; + +int main() +{ + test(std::bind(f), 1); + test(std::bind(&f), 1); + test(std::bind(A_int_0()), 4); + test_const(std::bind(A_int_0()), 5); + + test(std::bind<int>(f), 1); + test(std::bind<int>(&f), 1); + test(std::bind<int>(A_int_0()), 4); + test_const(std::bind<int>(A_int_0()), 5); +} diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp index 84afdea2b8c..3b6f5d44050 100644 --- a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp @@ -1 +1,267 @@ -//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <stdio.h>
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {count += 2;}
};
void
test_void_1()
{
using namespace std::placeholders;
int save_count = count;
// function
{
int i = 2;
std::bind(f_void_1, _1)(i);
assert(count == save_count + 2);
save_count = count;
}
{
int i = 2;
std::bind(f_void_1, i)();
assert(count == save_count + 2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
int i = 3;
std::bind(fp, _1)(i);
assert(count == save_count+3);
save_count = count;
}
{
void (*fp)(int) = f_void_1;
int i = 3;
std::bind(fp, i)();
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
int i = 4;
std::bind(a0, _1)(i);
assert(count == save_count+4);
save_count = count;
}
{
A_void_1 a0;
int i = 4;
std::bind(a0, i)();
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
A_void_1 a;
std::bind(fp, _1)(a);
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, _1)(ap);
assert(count == save_count+1);
save_count = count;
}
{
void (A_void_1::*fp)() = &A_void_1::mem1;
A_void_1 a;
std::bind(fp, a)();
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, ap)();
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
A_void_1 a;
std::bind(fp, _1)(a);
assert(count == save_count+2);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, _1)(ap);
assert(count == save_count+2);
save_count = count;
}
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
A_void_1 a;
std::bind(fp, a)();
assert(count == save_count+2);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, ap)();
assert(count == save_count+2);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
using namespace std::placeholders;
// function
{
int i = 2;
assert(std::bind(f_int_1, _1)(i) == 3);
assert(std::bind(f_int_1, i)() == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
int i = 3;
assert(std::bind(fp, _1)(i) == 4);
assert(std::bind(fp, i)() == 4);
}
// functor
{
int i = 4;
assert(std::bind(A_int_1(), _1)(i) == 3);
assert(std::bind(A_int_1(), i)() == 3);
}
// member function pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::mem1, _1)(a) == 3);
assert(std::bind(&A_int_1::mem1, a)() == 3);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::mem1, _1)(ap) == 3);
assert(std::bind(&A_int_1::mem1, ap)() == 3);
}
// const member function pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4);
assert(std::bind(&A_int_1::mem2, A_int_1())() == 4);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::mem2, _1)(ap) == 4);
assert(std::bind(&A_int_1::mem2, ap)() == 4);
}
// member data pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
assert(std::bind(&A_int_1::data_, a)() == 5);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
std::bind(&A_int_1::data_, _1)(a) = 6;
assert(std::bind(&A_int_1::data_, _1)(a) == 6);
assert(std::bind(&A_int_1::data_, _1)(ap) == 6);
std::bind(&A_int_1::data_, _1)(ap) = 7;
assert(std::bind(&A_int_1::data_, _1)(ap) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
using namespace std::placeholders;
int save_count = count;
// function
{
int i = 2;
int j = 3;
std::bind(f_void_2, _1, _2)(i, j);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, i, _1)(j);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, i, j)();
assert(count == save_count+5);
save_count = count;
}
// member function pointer
{
int j = 3;
std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), j);
assert(count == save_count+3);
save_count = count;
std::bind(&A_void_2::mem1, _2, _1)(j, A_void_2());
assert(count == save_count+3);
save_count = count;
}
}
int main()
{
test_void_1();
test_int_1();
}
\ No newline at end of file +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template<CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); +// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); + +#include <stdio.h> + +#include <functional> +#include <cassert> + +int count = 0; + +// 1 arg, return void + +void f_void_1(int i) +{ + count += i; +} + +struct A_void_1 +{ + void operator()(int i) + { + count += i; + } + + void mem1() {++count;} + void mem2() const {count += 2;} +}; + +void +test_void_1() +{ + using namespace std::placeholders; + int save_count = count; + // function + { + int i = 2; + std::bind(f_void_1, _1)(i); + assert(count == save_count + 2); + save_count = count; + } + { + int i = 2; + std::bind(f_void_1, i)(); + assert(count == save_count + 2); + save_count = count; + } + // function pointer + { + void (*fp)(int) = f_void_1; + int i = 3; + std::bind(fp, _1)(i); + assert(count == save_count+3); + save_count = count; + } + { + void (*fp)(int) = f_void_1; + int i = 3; + std::bind(fp, i)(); + assert(count == save_count+3); + save_count = count; + } + // functor + { + A_void_1 a0; + int i = 4; + std::bind(a0, _1)(i); + assert(count == save_count+4); + save_count = count; + } + { + A_void_1 a0; + int i = 4; + std::bind(a0, i)(); + assert(count == save_count+4); + save_count = count; + } + // member function pointer + { + void (A_void_1::*fp)() = &A_void_1::mem1; + A_void_1 a; + std::bind(fp, _1)(a); + assert(count == save_count+1); + save_count = count; + A_void_1* ap = &a; + std::bind(fp, _1)(ap); + assert(count == save_count+1); + save_count = count; + } + { + void (A_void_1::*fp)() = &A_void_1::mem1; + A_void_1 a; + std::bind(fp, a)(); + assert(count == save_count+1); + save_count = count; + A_void_1* ap = &a; + std::bind(fp, ap)(); + assert(count == save_count+1); + save_count = count; + } + // const member function pointer + { + void (A_void_1::*fp)() const = &A_void_1::mem2; + A_void_1 a; + std::bind(fp, _1)(a); + assert(count == save_count+2); + save_count = count; + A_void_1* ap = &a; + std::bind(fp, _1)(ap); + assert(count == save_count+2); + save_count = count; + } + { + void (A_void_1::*fp)() const = &A_void_1::mem2; + A_void_1 a; + std::bind(fp, a)(); + assert(count == save_count+2); + save_count = count; + A_void_1* ap = &a; + std::bind(fp, ap)(); + assert(count == save_count+2); + save_count = count; + } +} + +// 1 arg, return int + +int f_int_1(int i) +{ + return i + 1; +} + +struct A_int_1 +{ + A_int_1() : data_(5) {} + int operator()(int i) + { + return i - 1; + } + + int mem1() {return 3;} + int mem2() const {return 4;} + int data_; +}; + +void +test_int_1() +{ + using namespace std::placeholders; + // function + { + int i = 2; + assert(std::bind(f_int_1, _1)(i) == 3); + assert(std::bind(f_int_1, i)() == 3); + } + // function pointer + { + int (*fp)(int) = f_int_1; + int i = 3; + assert(std::bind(fp, _1)(i) == 4); + assert(std::bind(fp, i)() == 4); + } + // functor + { + int i = 4; + assert(std::bind(A_int_1(), _1)(i) == 3); + assert(std::bind(A_int_1(), i)() == 3); + } + // member function pointer + { + A_int_1 a; + assert(std::bind(&A_int_1::mem1, _1)(a) == 3); + assert(std::bind(&A_int_1::mem1, a)() == 3); + A_int_1* ap = &a; + assert(std::bind(&A_int_1::mem1, _1)(ap) == 3); + assert(std::bind(&A_int_1::mem1, ap)() == 3); + } + // const member function pointer + { + A_int_1 a; + assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4); + assert(std::bind(&A_int_1::mem2, A_int_1())() == 4); + A_int_1* ap = &a; + assert(std::bind(&A_int_1::mem2, _1)(ap) == 4); + assert(std::bind(&A_int_1::mem2, ap)() == 4); + } + // member data pointer + { + A_int_1 a; + assert(std::bind(&A_int_1::data_, _1)(a) == 5); + assert(std::bind(&A_int_1::data_, a)() == 5); + A_int_1* ap = &a; + assert(std::bind(&A_int_1::data_, _1)(a) == 5); + std::bind(&A_int_1::data_, _1)(a) = 6; + assert(std::bind(&A_int_1::data_, _1)(a) == 6); + assert(std::bind(&A_int_1::data_, _1)(ap) == 6); + std::bind(&A_int_1::data_, _1)(ap) = 7; + assert(std::bind(&A_int_1::data_, _1)(ap) == 7); + } +} + +// 2 arg, return void + +void f_void_2(int i, int j) +{ + count += i+j; +} + +struct A_void_2 +{ + void operator()(int i, int j) + { + count += i+j; + } + + void mem1(int i) {count += i;} + void mem2(int i) const {count += i;} +}; + +void +test_void_2() +{ + using namespace std::placeholders; + int save_count = count; + // function + { + int i = 2; + int j = 3; + std::bind(f_void_2, _1, _2)(i, j); + assert(count == save_count+5); + save_count = count; + std::bind(f_void_2, i, _1)(j); + assert(count == save_count+5); + save_count = count; + std::bind(f_void_2, i, j)(); + assert(count == save_count+5); + save_count = count; + } + // member function pointer + { + int j = 3; + std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), j); + assert(count == save_count+3); + save_count = count; + std::bind(&A_void_2::mem1, _2, _1)(j, A_void_2()); + assert(count == save_count+3); + save_count = count; + } +} + +int main() +{ + test_void_1(); + test_int_1(); +} diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp index 508caee69c6..365b38e87ec 100644 --- a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp @@ -1 +1,248 @@ -//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <stdio.h>
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {count += 2;}
};
void
test_void_1()
{
using namespace std::placeholders;
int save_count = count;
// function
{
std::bind(f_void_1, _1)(2);
assert(count == save_count + 2);
save_count = count;
}
{
std::bind(f_void_1, 2)();
assert(count == save_count + 2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
std::bind(fp, _1)(3);
assert(count == save_count+3);
save_count = count;
}
{
void (*fp)(int) = f_void_1;
std::bind(fp, 3)();
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
std::bind(a0, _1)(4);
assert(count == save_count+4);
save_count = count;
}
{
A_void_1 a0;
std::bind(a0, 4)();
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::bind(fp, _1)(A_void_1());
assert(count == save_count+1);
save_count = count;
A_void_1 a;
std::bind(fp, _1)(&a);
assert(count == save_count+1);
save_count = count;
}
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::bind(fp, A_void_1())();
assert(count == save_count+1);
save_count = count;
A_void_1 a;
std::bind(fp, &a)();
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::bind(fp, _1)(A_void_1());
assert(count == save_count+2);
save_count = count;
A_void_1 a;
std::bind(fp, _1)(&a);
assert(count == save_count+2);
save_count = count;
}
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::bind(fp, A_void_1())();
assert(count == save_count+2);
save_count = count;
A_void_1 a;
std::bind(fp, &a)();
assert(count == save_count+2);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
using namespace std::placeholders;
// function
{
assert(std::bind(f_int_1, _1)(2) == 3);
assert(std::bind(f_int_1, 2)() == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
assert(std::bind(fp, _1)(3) == 4);
assert(std::bind(fp, 3)() == 4);
}
// functor
{
assert(std::bind(A_int_1(), _1)(4) == 3);
assert(std::bind(A_int_1(), 4)() == 3);
}
// member function pointer
{
assert(std::bind(&A_int_1::mem1, _1)(A_int_1()) == 3);
assert(std::bind(&A_int_1::mem1, A_int_1())() == 3);
A_int_1 a;
assert(std::bind(&A_int_1::mem1, _1)(&a) == 3);
assert(std::bind(&A_int_1::mem1, &a)() == 3);
}
// const member function pointer
{
assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4);
assert(std::bind(&A_int_1::mem2, A_int_1())() == 4);
A_int_1 a;
assert(std::bind(&A_int_1::mem2, _1)(&a) == 4);
assert(std::bind(&A_int_1::mem2, &a)() == 4);
}
// member data pointer
{
assert(std::bind(&A_int_1::data_, _1)(A_int_1()) == 5);
assert(std::bind(&A_int_1::data_, A_int_1())() == 5);
A_int_1 a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
std::bind(&A_int_1::data_, _1)(a) = 6;
assert(std::bind(&A_int_1::data_, _1)(a) == 6);
assert(std::bind(&A_int_1::data_, _1)(&a) == 6);
std::bind(&A_int_1::data_, _1)(&a) = 7;
assert(std::bind(&A_int_1::data_, _1)(&a) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
using namespace std::placeholders;
int save_count = count;
// function
{
std::bind(f_void_2, _1, _2)(2, 3);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, 2, _1)(3);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, 2, 3)();
assert(count == save_count+5);
save_count = count;
}
// member function pointer
{
std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), 3);
assert(count == save_count+3);
save_count = count;
std::bind(&A_void_2::mem1, _2, _1)(3, A_void_2());
assert(count == save_count+3);
save_count = count;
}
}
int main()
{
test_void_1();
test_int_1();
}
\ No newline at end of file +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template<CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); +// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); + +#include <stdio.h> + +#include <functional> +#include <cassert> + +int count = 0; + +// 1 arg, return void + +void f_void_1(int i) +{ + count += i; +} + +struct A_void_1 +{ + void operator()(int i) + { + count += i; + } + + void mem1() {++count;} + void mem2() const {count += 2;} +}; + +void +test_void_1() +{ + using namespace std::placeholders; + int save_count = count; + // function + { + std::bind(f_void_1, _1)(2); + assert(count == save_count + 2); + save_count = count; + } + { + std::bind(f_void_1, 2)(); + assert(count == save_count + 2); + save_count = count; + } + // function pointer + { + void (*fp)(int) = f_void_1; + std::bind(fp, _1)(3); + assert(count == save_count+3); + save_count = count; + } + { + void (*fp)(int) = f_void_1; + std::bind(fp, 3)(); + assert(count == save_count+3); + save_count = count; + } + // functor + { + A_void_1 a0; + std::bind(a0, _1)(4); + assert(count == save_count+4); + save_count = count; + } + { + A_void_1 a0; + std::bind(a0, 4)(); + assert(count == save_count+4); + save_count = count; + } + // member function pointer + { + void (A_void_1::*fp)() = &A_void_1::mem1; + std::bind(fp, _1)(A_void_1()); + assert(count == save_count+1); + save_count = count; + A_void_1 a; + std::bind(fp, _1)(&a); + assert(count == save_count+1); + save_count = count; + } + { + void (A_void_1::*fp)() = &A_void_1::mem1; + std::bind(fp, A_void_1())(); + assert(count == save_count+1); + save_count = count; + A_void_1 a; + std::bind(fp, &a)(); + assert(count == save_count+1); + save_count = count; + } + // const member function pointer + { + void (A_void_1::*fp)() const = &A_void_1::mem2; + std::bind(fp, _1)(A_void_1()); + assert(count == save_count+2); + save_count = count; + A_void_1 a; + std::bind(fp, _1)(&a); + assert(count == save_count+2); + save_count = count; + } + { + void (A_void_1::*fp)() const = &A_void_1::mem2; + std::bind(fp, A_void_1())(); + assert(count == save_count+2); + save_count = count; + A_void_1 a; + std::bind(fp, &a)(); + assert(count == save_count+2); + save_count = count; + } +} + +// 1 arg, return int + +int f_int_1(int i) +{ + return i + 1; +} + +struct A_int_1 +{ + A_int_1() : data_(5) {} + int operator()(int i) + { + return i - 1; + } + + int mem1() {return 3;} + int mem2() const {return 4;} + int data_; +}; + +void +test_int_1() +{ + using namespace std::placeholders; + // function + { + assert(std::bind(f_int_1, _1)(2) == 3); + assert(std::bind(f_int_1, 2)() == 3); + } + // function pointer + { + int (*fp)(int) = f_int_1; + assert(std::bind(fp, _1)(3) == 4); + assert(std::bind(fp, 3)() == 4); + } + // functor + { + assert(std::bind(A_int_1(), _1)(4) == 3); + assert(std::bind(A_int_1(), 4)() == 3); + } + // member function pointer + { + assert(std::bind(&A_int_1::mem1, _1)(A_int_1()) == 3); + assert(std::bind(&A_int_1::mem1, A_int_1())() == 3); + A_int_1 a; + assert(std::bind(&A_int_1::mem1, _1)(&a) == 3); + assert(std::bind(&A_int_1::mem1, &a)() == 3); + } + // const member function pointer + { + assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4); + assert(std::bind(&A_int_1::mem2, A_int_1())() == 4); + A_int_1 a; + assert(std::bind(&A_int_1::mem2, _1)(&a) == 4); + assert(std::bind(&A_int_1::mem2, &a)() == 4); + } + // member data pointer + { + assert(std::bind(&A_int_1::data_, _1)(A_int_1()) == 5); + assert(std::bind(&A_int_1::data_, A_int_1())() == 5); + A_int_1 a; + assert(std::bind(&A_int_1::data_, _1)(a) == 5); + std::bind(&A_int_1::data_, _1)(a) = 6; + assert(std::bind(&A_int_1::data_, _1)(a) == 6); + assert(std::bind(&A_int_1::data_, _1)(&a) == 6); + std::bind(&A_int_1::data_, _1)(&a) = 7; + assert(std::bind(&A_int_1::data_, _1)(&a) == 7); + } +} + +// 2 arg, return void + +void f_void_2(int i, int j) +{ + count += i+j; +} + +struct A_void_2 +{ + void operator()(int i, int j) + { + count += i+j; + } + + void mem1(int i) {count += i;} + void mem2(int i) const {count += i;} +}; + +void +test_void_2() +{ + using namespace std::placeholders; + int save_count = count; + // function + { + std::bind(f_void_2, _1, _2)(2, 3); + assert(count == save_count+5); + save_count = count; + std::bind(f_void_2, 2, _1)(3); + assert(count == save_count+5); + save_count = count; + std::bind(f_void_2, 2, 3)(); + assert(count == save_count+5); + save_count = count; + } + // member function pointer + { + std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), 3); + assert(count == save_count+3); + save_count = count; + std::bind(&A_void_2::mem1, _2, _1)(3, A_void_2()); + assert(count == save_count+3); + save_count = count; + } +} + +int main() +{ + test_void_1(); + test_int_1(); +} diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp index d9d7e94df14..f84d1bf1825 100644 --- a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp @@ -1 +1,59 @@ -//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <functional>
#include <cassert>
int count = 0;
template <class F>
void
test(F f)
{
int save_count = count;
f();
assert(count == save_count + 1);
}
template <class F>
void
test_const(const F& f)
{
int save_count = count;
f();
assert(count == save_count + 2);
}
void f() {++count;}
struct A_int_0
{
void operator()() {++count;}
void operator()() const {count += 2;}
};
int main()
{
test(std::bind(f));
test(std::bind(&f));
test(std::bind(A_int_0()));
test_const(std::bind(A_int_0()));
test(std::bind<void>(f));
test(std::bind<void>(&f));
test(std::bind<void>(A_int_0()));
test_const(std::bind<void>(A_int_0()));
}
\ No newline at end of file +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template<CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); +// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types> +// unspecified bind(Fn, Types...); + +#include <functional> +#include <cassert> + +int count = 0; + +template <class F> +void +test(F f) +{ + int save_count = count; + f(); + assert(count == save_count + 1); +} + +template <class F> +void +test_const(const F& f) +{ + int save_count = count; + f(); + assert(count == save_count + 2); +} + +void f() {++count;} + +struct A_int_0 +{ + void operator()() {++count;} + void operator()() const {count += 2;} +}; + +int main() +{ + test(std::bind(f)); + test(std::bind(&f)); + test(std::bind(A_int_0())); + test_const(std::bind(A_int_0())); + + test(std::bind<void>(f)); + test(std::bind<void>(&f)); + test(std::bind<void>(A_int_0())); + test_const(std::bind<void>(A_int_0())); +} |
