1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <functional>
10
11 // class function<R(ArgTypes...)>
12
13 // R operator()(ArgTypes... args) const
14
15 // This test runs in C++03, but we have deprecated using std::function in C++03.
16 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
17
18 #include <functional>
19 #include <cassert>
20
21 #include "test_macros.h"
22
23
24 int count = 0;
25
26
27 // 0 args, return int
28
f_int_0()29 int f_int_0()
30 {
31 return 3;
32 }
33
34 struct A_int_0
35 {
operator ()A_int_036 int operator()() {return 4;}
37 };
38
test_int_0()39 void test_int_0()
40 {
41 // function
42 {
43 std::function<int ()> r1(f_int_0);
44 assert(r1() == 3);
45 }
46 // function pointer
47 {
48 int (*fp)() = f_int_0;
49 std::function<int ()> r1(fp);
50 assert(r1() == 3);
51 }
52 // functor
53 {
54 A_int_0 a0;
55 std::function<int ()> r1(a0);
56 assert(r1() == 4);
57 }
58 }
59
60
61 // 0 args, return void
62
f_void_0()63 void f_void_0()
64 {
65 ++count;
66 }
67
68 struct A_void_0
69 {
operator ()A_void_070 void operator()() {++count;}
71 };
72
73 void
test_void_0()74 test_void_0()
75 {
76 int save_count = count;
77 // function
78 {
79 std::function<void ()> r1(f_void_0);
80 r1();
81 assert(count == save_count+1);
82 save_count = count;
83 }
84 // function pointer
85 {
86 void (*fp)() = f_void_0;
87 std::function<void ()> r1(fp);
88 r1();
89 assert(count == save_count+1);
90 save_count = count;
91 }
92 // functor
93 {
94 A_void_0 a0;
95 std::function<void ()> r1(a0);
96 r1();
97 assert(count == save_count+1);
98 save_count = count;
99 }
100 }
101
102 // 1 arg, return void
103
f_void_1(int i)104 void f_void_1(int i)
105 {
106 count += i;
107 }
108
109 struct A_void_1
110 {
operator ()A_void_1111 void operator()(int i)
112 {
113 count += i;
114 }
115
mem1A_void_1116 void mem1() {++count;}
mem2A_void_1117 void mem2() const {++count;}
118 };
119
120 void
test_void_1()121 test_void_1()
122 {
123 int save_count = count;
124 // function
125 {
126 std::function<void (int)> r1(f_void_1);
127 int i = 2;
128 r1(i);
129 assert(count == save_count+2);
130 save_count = count;
131 }
132 // function pointer
133 {
134 void (*fp)(int) = f_void_1;
135 std::function<void (int)> r1(fp);
136 int i = 3;
137 r1(i);
138 assert(count == save_count+3);
139 save_count = count;
140 }
141 // functor
142 {
143 A_void_1 a0;
144 std::function<void (int)> r1(a0);
145 int i = 4;
146 r1(i);
147 assert(count == save_count+4);
148 save_count = count;
149 }
150 // member function pointer
151 {
152 void (A_void_1::*fp)() = &A_void_1::mem1;
153 std::function<void (A_void_1)> r1(fp);
154 A_void_1 a;
155 r1(a);
156 assert(count == save_count+1);
157 save_count = count;
158 A_void_1* ap = &a;
159 std::function<void (A_void_1*)> r2 = fp;
160 r2(ap);
161 assert(count == save_count+1);
162 save_count = count;
163 }
164 // const member function pointer
165 {
166 void (A_void_1::*fp)() const = &A_void_1::mem2;
167 std::function<void (A_void_1)> r1(fp);
168 A_void_1 a;
169 r1(a);
170 assert(count == save_count+1);
171 save_count = count;
172 std::function<void (A_void_1*)> r2(fp);
173 A_void_1* ap = &a;
174 r2(ap);
175 assert(count == save_count+1);
176 save_count = count;
177 }
178 }
179
180 // 1 arg, return int
181
f_int_1(int i)182 int f_int_1(int i)
183 {
184 return i + 1;
185 }
186
187 struct A_int_1
188 {
A_int_1A_int_1189 A_int_1() : data_(5) {}
operator ()A_int_1190 int operator()(int i)
191 {
192 return i - 1;
193 }
194
mem1A_int_1195 int mem1() {return 3;}
mem2A_int_1196 int mem2() const {return 4;}
197 int data_;
198 };
199
200 void
test_int_1()201 test_int_1()
202 {
203 // function
204 {
205 std::function<int (int)> r1(f_int_1);
206 int i = 2;
207 assert(r1(i) == 3);
208 }
209 // function pointer
210 {
211 int (*fp)(int) = f_int_1;
212 std::function<int (int)> r1(fp);
213 int i = 3;
214 assert(r1(i) == 4);
215 }
216 // functor
217 {
218 A_int_1 a0;
219 std::function<int (int)> r1(a0);
220 int i = 4;
221 assert(r1(i) == 3);
222 }
223 // member function pointer
224 {
225 int (A_int_1::*fp)() = &A_int_1::mem1;
226 std::function<int (A_int_1)> r1(fp);
227 A_int_1 a;
228 assert(r1(a) == 3);
229 std::function<int (A_int_1*)> r2(fp);
230 A_int_1* ap = &a;
231 assert(r2(ap) == 3);
232 }
233 // const member function pointer
234 {
235 int (A_int_1::*fp)() const = &A_int_1::mem2;
236 std::function<int (A_int_1)> r1(fp);
237 A_int_1 a;
238 assert(r1(a) == 4);
239 std::function<int (A_int_1*)> r2(fp);
240 A_int_1* ap = &a;
241 assert(r2(ap) == 4);
242 }
243 // member data pointer
244 {
245 int A_int_1::*fp = &A_int_1::data_;
246 std::function<int& (A_int_1&)> r1(fp);
247 A_int_1 a;
248 assert(r1(a) == 5);
249 r1(a) = 6;
250 assert(r1(a) == 6);
251 std::function<int& (A_int_1*)> r2(fp);
252 A_int_1* ap = &a;
253 assert(r2(ap) == 6);
254 r2(ap) = 7;
255 assert(r2(ap) == 7);
256 }
257 }
258
259 // 2 arg, return void
260
f_void_2(int i,int j)261 void f_void_2(int i, int j)
262 {
263 count += i+j;
264 }
265
266 struct A_void_2
267 {
operator ()A_void_2268 void operator()(int i, int j)
269 {
270 count += i+j;
271 }
272
mem1A_void_2273 void mem1(int i) {count += i;}
mem2A_void_2274 void mem2(int i) const {count += i;}
275 };
276
277 void
test_void_2()278 test_void_2()
279 {
280 int save_count = count;
281 // function
282 {
283 std::function<void (int, int)> r1(f_void_2);
284 int i = 2;
285 int j = 3;
286 r1(i, j);
287 assert(count == save_count+5);
288 save_count = count;
289 }
290 // function pointer
291 {
292 void (*fp)(int, int) = f_void_2;
293 std::function<void (int, int)> r1(fp);
294 int i = 3;
295 int j = 4;
296 r1(i, j);
297 assert(count == save_count+7);
298 save_count = count;
299 }
300 // functor
301 {
302 A_void_2 a0;
303 std::function<void (int, int)> r1(a0);
304 int i = 4;
305 int j = 5;
306 r1(i, j);
307 assert(count == save_count+9);
308 save_count = count;
309 }
310 // member function pointer
311 {
312 void (A_void_2::*fp)(int) = &A_void_2::mem1;
313 std::function<void (A_void_2, int)> r1(fp);
314 A_void_2 a;
315 int i = 3;
316 r1(a, i);
317 assert(count == save_count+3);
318 save_count = count;
319 std::function<void (A_void_2*, int)> r2(fp);
320 A_void_2* ap = &a;
321 r2(ap, i);
322 assert(count == save_count+3);
323 save_count = count;
324 }
325 // const member function pointer
326 {
327 void (A_void_2::*fp)(int) const = &A_void_2::mem2;
328 std::function<void (A_void_2, int)> r1(fp);
329 A_void_2 a;
330 int i = 4;
331 r1(a, i);
332 assert(count == save_count+4);
333 save_count = count;
334 std::function<void (A_void_2*, int)> r2(fp);
335 A_void_2* ap = &a;
336 r2(ap, i);
337 assert(count == save_count+4);
338 save_count = count;
339 }
340 }
341
342 // 2 arg, return int
343
f_int_2(int i,int j)344 int f_int_2(int i, int j)
345 {
346 return i+j;
347 }
348
349 struct A_int_2
350 {
operator ()A_int_2351 int operator()(int i, int j)
352 {
353 return i+j;
354 }
355
mem1A_int_2356 int mem1(int i) {return i+1;}
mem2A_int_2357 int mem2(int i) const {return i+2;}
358 };
359
test_int_2()360 void test_int_2()
361 {
362 // function
363 {
364 std::function<int (int, int)> r1(f_int_2);
365 int i = 2;
366 int j = 3;
367 assert(r1(i, j) == i+j);
368 }
369 // function pointer
370 {
371 int (*fp)(int, int) = f_int_2;
372 std::function<int (int, int)> r1(fp);
373 int i = 3;
374 int j = 4;
375 assert(r1(i, j) == i+j);
376 }
377 // functor
378 {
379 A_int_2 a0;
380 std::function<int (int, int)> r1(a0);
381 int i = 4;
382 int j = 5;
383 assert(r1(i, j) == i+j);
384 }
385 // member function pointer
386 {
387 int(A_int_2::*fp)(int) = &A_int_2::mem1;
388 std::function<int (A_int_2, int)> r1(fp);
389 A_int_2 a;
390 int i = 3;
391 assert(r1(a, i) == i+1);
392 std::function<int (A_int_2*, int)> r2(fp);
393 A_int_2* ap = &a;
394 assert(r2(ap, i) == i+1);
395 }
396 // const member function pointer
397 {
398 int (A_int_2::*fp)(int) const = &A_int_2::mem2;
399 std::function<int (A_int_2, int)> r1(fp);
400 A_int_2 a;
401 int i = 4;
402 assert(r1(a, i) == i+2);
403 std::function<int (A_int_2*, int)> r2(fp);
404 A_int_2* ap = &a;
405 assert(r2(ap, i) == i+2);
406 }
407 }
408
main(int,char **)409 int main(int, char**)
410 {
411 test_void_0();
412 test_int_0();
413 test_void_1();
414 test_int_1();
415 test_void_2();
416 test_int_2();
417
418 return 0;
419 }
420