1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <functional>
// REQUIRES: c++11 || c++14
// class function<R(ArgTypes...)>
// template<class A> function(allocator_arg_t, const A&, const function&);
#include <functional>
#include <cassert>
#include "test_macros.h"
#include "min_allocator.h"
#include "test_allocator.h"
#include "count_new.h"
#include "../function_types.h"
class DummyClass {};
template <class FuncType, class AllocType>
void test_FunctionObject(AllocType& alloc)
{
assert(globalMemCounter.checkOutstandingNewEq(0));
{
// Construct function from FunctionObject.
std::function<FuncType> f = FunctionObject();
assert(FunctionObject::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
RTTI_ASSERT(f.template target<FunctionObject>());
RTTI_ASSERT(f.template target<FuncType>() == 0);
RTTI_ASSERT(f.template target<FuncType*>() == 0);
// Copy function with allocator
std::function<FuncType> f2(std::allocator_arg, alloc, f);
assert(FunctionObject::count == 2);
assert(globalMemCounter.checkOutstandingNewEq(2));
RTTI_ASSERT(f2.template target<FunctionObject>());
RTTI_ASSERT(f2.template target<FuncType>() == 0);
RTTI_ASSERT(f2.template target<FuncType*>() == 0);
}
assert(FunctionObject::count == 0);
assert(globalMemCounter.checkOutstandingNewEq(0));
}
template <class FuncType, class AllocType>
void test_FreeFunction(AllocType& alloc)
{
assert(globalMemCounter.checkOutstandingNewEq(0));
{
// Construct function from function pointer.
FuncType* target = &FreeFunction;
std::function<FuncType> f = target;
assert(globalMemCounter.checkOutstandingNewEq(0));
RTTI_ASSERT(f.template target<FuncType*>());
RTTI_ASSERT(*f.template target<FuncType*>() == target);
RTTI_ASSERT(f.template target<FuncType>() == 0);
// Copy function with allocator
std::function<FuncType> f2(std::allocator_arg, alloc, f);
assert(globalMemCounter.checkOutstandingNewEq(0));
RTTI_ASSERT(f2.template target<FuncType*>());
RTTI_ASSERT(*f2.template target<FuncType*>() == target);
RTTI_ASSERT(f2.template target<FuncType>() == 0);
}
assert(globalMemCounter.checkOutstandingNewEq(0));
}
template <class TargetType, class FuncType, class AllocType>
void test_MemFunClass(AllocType& alloc)
{
assert(globalMemCounter.checkOutstandingNewEq(0));
{
// Construct function from function pointer.
TargetType target = &MemFunClass::foo;
std::function<FuncType> f = target;
assert(globalMemCounter.checkOutstandingNewEq(0));
RTTI_ASSERT(f.template target<TargetType>());
RTTI_ASSERT(*f.template target<TargetType>() == target);
RTTI_ASSERT(f.template target<FuncType*>() == 0);
// Copy function with allocator
std::function<FuncType> f2(std::allocator_arg, alloc, f);
assert(globalMemCounter.checkOutstandingNewEq(0));
RTTI_ASSERT(f2.template target<TargetType>());
RTTI_ASSERT(*f2.template target<TargetType>() == target);
RTTI_ASSERT(f2.template target<FuncType*>() == 0);
}
assert(globalMemCounter.checkOutstandingNewEq(0));
}
template <class Alloc>
void test_for_alloc(Alloc& alloc)
{
// Large FunctionObject -- Allocation should occur
test_FunctionObject<int()>(alloc);
test_FunctionObject<int(int)>(alloc);
test_FunctionObject<int(int, int)>(alloc);
test_FunctionObject<int(int, int, int)>(alloc);
// Free function -- No allocation should occur
test_FreeFunction<int()>(alloc);
test_FreeFunction<int(int)>(alloc);
test_FreeFunction<int(int, int)>(alloc);
test_FreeFunction<int(int, int, int)>(alloc);
// Member function -- No allocation should occur.
test_MemFunClass<int(MemFunClass::*)() const, int(MemFunClass&)>(alloc);
test_MemFunClass<int(MemFunClass::*)(int) const, int(MemFunClass&, int)>(alloc);
test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
}
int main(int, char**)
{
globalMemCounter.reset();
{
bare_allocator<DummyClass> alloc;
test_for_alloc(alloc);
}
{
non_default_test_allocator<DummyClass> alloc(42);
test_for_alloc(alloc);
}
return 0;
}
|
