1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <functional>
11
12 // class function<R(ArgTypes...)>
13
14 // template<class A> function(allocator_arg_t, const A&, const function&);
15
16 #include <functional>
17 #include <new>
18 #include <cstdlib>
19 #include <cassert>
20
21 #include "test_allocator.h"
22
23 int new_called = 0;
24
operator new(std::size_t s)25 void* operator new(std::size_t s) throw(std::bad_alloc)
26 {
27 ++new_called;
28 return std::malloc(s);
29 }
30
operator delete(void * p)31 void operator delete(void* p) throw()
32 {
33 --new_called;
34 std::free(p);
35 }
36
37 class A
38 {
39 int data_[10];
40 public:
41 static int count;
42
A()43 A()
44 {
45 ++count;
46 for (int i = 0; i < 10; ++i)
47 data_[i] = i;
48 }
49
A(const A &)50 A(const A&) {++count;}
51
~A()52 ~A() {--count;}
53
operator ()(int i) const54 int operator()(int i) const
55 {
56 for (int j = 0; j < 10; ++j)
57 i += data_[j];
58 return i;
59 }
60 };
61
62 int A::count = 0;
63
g(int)64 int g(int) {return 0;}
65
main()66 int main()
67 {
68 assert(new_called == 0);
69 {
70 std::function<int(int)> f = A();
71 assert(A::count == 1);
72 assert(new_called == 1);
73 assert(f.target<A>());
74 assert(f.target<int(*)(int)>() == 0);
75 std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), f);
76 assert(A::count == 2);
77 assert(new_called == 2);
78 assert(f2.target<A>());
79 assert(f2.target<int(*)(int)>() == 0);
80 }
81 assert(A::count == 0);
82 assert(new_called == 0);
83 {
84 std::function<int(int)> f = g;
85 assert(new_called == 0);
86 assert(f.target<int(*)(int)>());
87 assert(f.target<A>() == 0);
88 std::function<int(int)> f2(std::allocator_arg, test_allocator<int(*)(int)>(), f);
89 assert(new_called == 0);
90 assert(f2.target<int(*)(int)>());
91 assert(f2.target<A>() == 0);
92 }
93 assert(new_called == 0);
94 {
95 assert(new_called == 0);
96 non_default_test_allocator<std::function<int(int)>> al(1);
97 std::function<int(int)> f2(std::allocator_arg, al, g);
98 assert(new_called == 0);
99 assert(f2.target<int(*)(int)>());
100 assert(f2.target<A>() == 0);
101 }
102 assert(new_called == 0);
103 {
104 std::function<int(int)> f;
105 assert(new_called == 0);
106 assert(f.target<int(*)(int)>() == 0);
107 assert(f.target<A>() == 0);
108 std::function<int(int)> f2(std::allocator_arg, test_allocator<int>(), f);
109 assert(new_called == 0);
110 assert(f2.target<int(*)(int)>() == 0);
111 assert(f2.target<A>() == 0);
112 }
113 }
114