invoke.pass.cpp revision b64f8b07c104c6cc986570ac8ee0ed16a9f23976 
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
19int count = 0;
20
21// 1 arg, return void
22
23void f_void_1(int i)
24{
25    count += i;
26}
27
28struct A_void_1
29{
30    void operator()(int i)
31    {
32        count += i;
33    }
34
35    void mem1() {++count;}
36    void mem2() const {++count;}
37};
38
39void
40test_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
101int f_int_1(int i)
102{
103    return i + 1;
104}
105
106struct A_int_1
107{
108    A_int_1() : data_(5) {}
109    int operator()(int i)
110    {
111        return i - 1;
112    }
113
114    int mem1() {return 3;}
115    int mem2() const {return 4;}
116    int data_;
117};
118
119void
120test_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
180void f_void_2(int i, int j)
181{
182    count += i+j;
183}
184
185struct A_void_2
186{
187    void operator()(int i, int j)
188    {
189        count += i+j;
190    }
191
192    void mem1(int i) {count += i;}
193    void mem2(int i) const {count += i;}
194};
195
196void
197test_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
263int f_int_2(int i, int j)
264{
265    return i+j;
266}
267
268struct A_int_2
269{
270    int operator()(int i, int j)
271    {
272        return i+j;
273    }
274
275    int mem1(int i) {return i+1;}
276    int mem2(int i) const {return i+2;}
277};
278
279void
280testint_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
329int main()
330{
331    test_void_1();
332    test_int_1();
333    test_void_2();
334    testint_2();
335}
336