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 // R operator()(ArgTypes... args) const
15 
16 #include <functional>
17 #include <cassert>
18 
19 int count = 0;
20 
21 // 1 arg, return void
22 
f_void_1(int i)23 void f_void_1(int i)
24 {
25     count += i;
26 }
27 
28 struct A_void_1
29 {
operator ()A_void_130     void operator()(int i)
31     {
32         count += i;
33     }
34 
mem1A_void_135     void mem1() {++count;}
mem2A_void_136     void mem2() const {++count;}
37 };
38 
39 void
test_void_1()40 test_void_1()
41 {
42     int save_count = count;
43     // function
44     {
45     std::function<void (int)> r1(f_void_1);
46     int i = 2;
47     r1(i);
48     assert(count == save_count+2);
49     save_count = count;
50     }
51     // function pointer
52     {
53     void (*fp)(int) = f_void_1;
54     std::function<void (int)> r1(fp);
55     int i = 3;
56     r1(i);
57     assert(count == save_count+3);
58     save_count = count;
59     }
60     // functor
61     {
62     A_void_1 a0;
63     std::function<void (int)> r1(a0);
64     int i = 4;
65     r1(i);
66     assert(count == save_count+4);
67     save_count = count;
68     }
69     // member function pointer
70     {
71     void (A_void_1::*fp)() = &A_void_1::mem1;
72     std::function<void (A_void_1)> r1(fp);
73     A_void_1 a;
74     r1(a);
75     assert(count == save_count+1);
76     save_count = count;
77     A_void_1* ap = &a;
78     std::function<void (A_void_1*)> r2 = fp;
79     r2(ap);
80     assert(count == save_count+1);
81     save_count = count;
82     }
83     // const member function pointer
84     {
85     void (A_void_1::*fp)() const = &A_void_1::mem2;
86     std::function<void (A_void_1)> r1(fp);
87     A_void_1 a;
88     r1(a);
89     assert(count == save_count+1);
90     save_count = count;
91     std::function<void (A_void_1*)> r2(fp);
92     A_void_1* ap = &a;
93     r2(ap);
94     assert(count == save_count+1);
95     save_count = count;
96     }
97 }
98 
99 // 1 arg, return int
100 
f_int_1(int i)101 int f_int_1(int i)
102 {
103     return i + 1;
104 }
105 
106 struct A_int_1
107 {
A_int_1A_int_1108     A_int_1() : data_(5) {}
operator ()A_int_1109     int operator()(int i)
110     {
111         return i - 1;
112     }
113 
mem1A_int_1114     int mem1() {return 3;}
mem2A_int_1115     int mem2() const {return 4;}
116     int data_;
117 };
118 
119 void
test_int_1()120 test_int_1()
121 {
122     // function
123     {
124     std::function<int (int)> r1(f_int_1);
125     int i = 2;
126     assert(r1(i) == 3);
127     }
128     // function pointer
129     {
130     int (*fp)(int) = f_int_1;
131     std::function<int (int)> r1(fp);
132     int i = 3;
133     assert(r1(i) == 4);
134     }
135     // functor
136     {
137     A_int_1 a0;
138     std::function<int (int)> r1(a0);
139     int i = 4;
140     assert(r1(i) == 3);
141     }
142     // member function pointer
143     {
144     int (A_int_1::*fp)() = &A_int_1::mem1;
145     std::function<int (A_int_1)> r1(fp);
146     A_int_1 a;
147     assert(r1(a) == 3);
148     std::function<int (A_int_1*)> r2(fp);
149     A_int_1* ap = &a;
150     assert(r2(ap) == 3);
151     }
152     // const member function pointer
153     {
154     int (A_int_1::*fp)() const = &A_int_1::mem2;
155     std::function<int (A_int_1)> r1(fp);
156     A_int_1 a;
157     assert(r1(a) == 4);
158     std::function<int (A_int_1*)> r2(fp);
159     A_int_1* ap = &a;
160     assert(r2(ap) == 4);
161     }
162     // member data pointer
163     {
164     int A_int_1::*fp = &A_int_1::data_;
165     std::function<int& (A_int_1&)> r1(fp);
166     A_int_1 a;
167     assert(r1(a) == 5);
168     r1(a) = 6;
169     assert(r1(a) == 6);
170     std::function<int& (A_int_1*)> r2(fp);
171     A_int_1* ap = &a;
172     assert(r2(ap) == 6);
173     r2(ap) = 7;
174     assert(r2(ap) == 7);
175     }
176 }
177 
178 // 2 arg, return void
179 
f_void_2(int i,int j)180 void f_void_2(int i, int j)
181 {
182     count += i+j;
183 }
184 
185 struct A_void_2
186 {
operator ()A_void_2187     void operator()(int i, int j)
188     {
189         count += i+j;
190     }
191 
mem1A_void_2192     void mem1(int i) {count += i;}
mem2A_void_2193     void mem2(int i) const {count += i;}
194 };
195 
196 void
test_void_2()197 test_void_2()
198 {
199     int save_count = count;
200     // function
201     {
202     std::function<void (int, int)> r1(f_void_2);
203     int i = 2;
204     int j = 3;
205     r1(i, j);
206     assert(count == save_count+5);
207     save_count = count;
208     }
209     // function pointer
210     {
211     void (*fp)(int, int) = f_void_2;
212     std::function<void (int, int)> r1(fp);
213     int i = 3;
214     int j = 4;
215     r1(i, j);
216     assert(count == save_count+7);
217     save_count = count;
218     }
219     // functor
220     {
221     A_void_2 a0;
222     std::function<void (int, int)> r1(a0);
223     int i = 4;
224     int j = 5;
225     r1(i, j);
226     assert(count == save_count+9);
227     save_count = count;
228     }
229     // member function pointer
230     {
231     void (A_void_2::*fp)(int) = &A_void_2::mem1;
232     std::function<void (A_void_2, int)> r1(fp);
233     A_void_2 a;
234     int i = 3;
235     r1(a, i);
236     assert(count == save_count+3);
237     save_count = count;
238     std::function<void (A_void_2*, int)> r2(fp);
239     A_void_2* ap = &a;
240     r2(ap, i);
241     assert(count == save_count+3);
242     save_count = count;
243     }
244     // const member function pointer
245     {
246     void (A_void_2::*fp)(int) const = &A_void_2::mem2;
247     std::function<void (A_void_2, int)> r1(fp);
248     A_void_2 a;
249     int i = 4;
250     r1(a, i);
251     assert(count == save_count+4);
252     save_count = count;
253     std::function<void (A_void_2*, int)> r2(fp);
254     A_void_2* ap = &a;
255     r2(ap, i);
256     assert(count == save_count+4);
257     save_count = count;
258     }
259 }
260 
261 // 2 arg, return int
262 
f_int_2(int i,int j)263 int f_int_2(int i, int j)
264 {
265     return i+j;
266 }
267 
268 struct A_int_2
269 {
operator ()A_int_2270     int operator()(int i, int j)
271     {
272         return i+j;
273     }
274 
mem1A_int_2275     int mem1(int i) {return i+1;}
mem2A_int_2276     int mem2(int i) const {return i+2;}
277 };
278 
279 void
testint_2()280 testint_2()
281 {
282     // function
283     {
284     std::function<int (int, int)> r1(f_int_2);
285     int i = 2;
286     int j = 3;
287     assert(r1(i, j) == i+j);
288     }
289     // function pointer
290     {
291     int (*fp)(int, int) = f_int_2;
292     std::function<int (int, int)> r1(fp);
293     int i = 3;
294     int j = 4;
295     assert(r1(i, j) == i+j);
296     }
297     // functor
298     {
299     A_int_2 a0;
300     std::function<int (int, int)> r1(a0);
301     int i = 4;
302     int j = 5;
303     assert(r1(i, j) == i+j);
304     }
305     // member function pointer
306     {
307     int(A_int_2::*fp)(int) = &A_int_2::mem1;
308     std::function<int (A_int_2, int)> r1(fp);
309     A_int_2 a;
310     int i = 3;
311     assert(r1(a, i) == i+1);
312     std::function<int (A_int_2*, int)> r2(fp);
313     A_int_2* ap = &a;
314     assert(r2(ap, i) == i+1);
315     }
316     // const member function pointer
317     {
318     int (A_int_2::*fp)(int) const = &A_int_2::mem2;
319     std::function<int (A_int_2, int)> r1(fp);
320     A_int_2 a;
321     int i = 4;
322     assert(r1(a, i) == i+2);
323     std::function<int (A_int_2*, int)> r2(fp);
324     A_int_2* ap = &a;
325     assert(r2(ap, i) == i+2);
326     }
327 }
328 
main()329 int main()
330 {
331     test_void_1();
332     test_int_1();
333     test_void_2();
334     testint_2();
335 }
336