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 F, class A> function(allocator_arg_t, const A&, F);
15 
16 #include <functional>
17 #include <cassert>
18 
19 #include "min_allocator.h"
20 #include "test_allocator.h"
21 #include "count_new.hpp"
22 #include "../function_types.h"
23 
24 class DummyClass {};
25 
26 template <class FuncType, class AllocType>
27 void test_FunctionObject(AllocType& alloc)
28 {
29     assert(globalMemCounter.checkOutstandingNewEq(0));
30     {
31     FunctionObject target;
32     assert(FunctionObject::count == 1);
33     assert(globalMemCounter.checkOutstandingNewEq(0));
34     std::function<FuncType> f2(std::allocator_arg, alloc, target);
35     assert(FunctionObject::count == 2);
36     assert(globalMemCounter.checkOutstandingNewEq(1));
37     assert(f2.template target<FunctionObject>());
38     assert(f2.template target<FuncType>() == 0);
39     assert(f2.template target<FuncType*>() == 0);
40     }
41     assert(FunctionObject::count == 0);
42     assert(globalMemCounter.checkOutstandingNewEq(0));
43 }
44 
45 
46 template <class FuncType, class AllocType>
47 void test_FreeFunction(AllocType& alloc)
48 {
49     assert(globalMemCounter.checkOutstandingNewEq(0));
50     {
51     FuncType* target = &FreeFunction;
52     assert(globalMemCounter.checkOutstandingNewEq(0));
53     std::function<FuncType> f2(std::allocator_arg, alloc, target);
54     assert(globalMemCounter.checkOutstandingNewEq(0));
55     assert(f2.template target<FuncType*>());
56     assert(*f2.template target<FuncType*>() == target);
57     assert(f2.template target<FuncType>() == 0);
58     assert(f2.template target<DummyClass>() == 0);
59     }
60     assert(globalMemCounter.checkOutstandingNewEq(0));
61 }
62 
63 template <class TargetType, class FuncType, class AllocType>
64 void test_MemFunClass(AllocType& alloc)
65 {
66     assert(globalMemCounter.checkOutstandingNewEq(0));
67     {
68     TargetType target = &MemFunClass::foo;
69     assert(globalMemCounter.checkOutstandingNewEq(0));
70     std::function<FuncType> f2(std::allocator_arg, alloc, target);
71     assert(globalMemCounter.checkOutstandingNewEq(0));
72     assert(f2.template target<TargetType>());
73     assert(*f2.template target<TargetType>() == target);
74     assert(f2.template target<FuncType*>() == 0);
75     }
76     assert(globalMemCounter.checkOutstandingNewEq(0));
77 }
78 
79 template <class Alloc>
80 void test_for_alloc(Alloc& alloc) {
81     test_FunctionObject<int()>(alloc);
82     test_FunctionObject<int(int)>(alloc);
83     test_FunctionObject<int(int, int)>(alloc);
84     test_FunctionObject<int(int, int, int)>(alloc);
85 
86     test_FreeFunction<int()>(alloc);
87     test_FreeFunction<int(int)>(alloc);
88     test_FreeFunction<int(int, int)>(alloc);
89     test_FreeFunction<int(int, int, int)>(alloc);
90 
91     test_MemFunClass<int(MemFunClass::*)() const, int(MemFunClass&)>(alloc);
92     test_MemFunClass<int(MemFunClass::*)(int) const, int(MemFunClass&, int)>(alloc);
93     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
94 }
95 
96 int main()
97 {
98     {
99         bare_allocator<DummyClass> bare_alloc;
100         test_for_alloc(bare_alloc);
101     }
102     {
103         non_default_test_allocator<DummyClass> non_default_alloc(42);
104         test_for_alloc(non_default_alloc);
105     }
106 }
107