1/*
2Copyright 2019 Glen Joseph Fernandes
3(glenjofe@gmail.com)
4
5Distributed under the Boost Software License, Version 1.0.
6(http://www.boost.org/LICENSE_1_0.txt)
7*/
8#include <boost/config.hpp>
9#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
10 BOOST_LIBSTDCXX_VERSION >= 48000) && \
11 !defined(BOOST_NO_CXX11_SMART_PTR)
12#include <boost/smart_ptr/allocate_unique.hpp>
13#include <boost/core/lightweight_test.hpp>
14
15template<class T = void>
16struct creator {
17 typedef T value_type;
18 typedef T* pointer;
19
20 template<class U>
21 struct rebind {
22 typedef creator<U> other;
23 };
24
25 creator() { }
26
27 template<class U>
28 creator(const creator<U>&) { }
29
30 T* allocate(std::size_t size) {
31 return static_cast<T*>(::operator new(sizeof(T) * size));
32 }
33
34 void deallocate(T* ptr, std::size_t) {
35 ::operator delete(ptr);
36 }
37};
38
39template<class T, class U>
40inline bool
41operator==(const creator<T>&, const creator<U>&)
42{
43 return true;
44}
45
46template<class T, class U>
47inline bool
48operator!=(const creator<T>&, const creator<U>&)
49{
50 return false;
51}
52
53class type {
54public:
55 static unsigned instances;
56
57 type()
58 : value_(0.0) {
59 ++instances;
60 }
61
62 ~type() {
63 --instances;
64 }
65
66 void set(long double value) {
67 value_ = value;
68 }
69
70 long double get() const {
71 return value_;
72 }
73
74private:
75 type(const type&);
76 type& operator=(const type&);
77
78 long double value_;
79};
80
81unsigned type::instances = 0;
82
83int main()
84{
85 {
86 std::unique_ptr<int[],
87 boost::alloc_deleter<int[], creator<int> > > result =
88 boost::allocate_unique<int[]>(alloc: creator<int>(), size: 3);
89 BOOST_TEST(result.get() != 0);
90 BOOST_TEST(result[0] == 0);
91 BOOST_TEST(result[1] == 0);
92 BOOST_TEST(result[2] == 0);
93 }
94 {
95 std::unique_ptr<int[],
96 boost::alloc_deleter<int[3], creator<int> > > result =
97 boost::allocate_unique<int[3]>(alloc: creator<int>());
98 BOOST_TEST(result.get() != 0);
99 BOOST_TEST(result[0] == 0);
100 BOOST_TEST(result[1] == 0);
101 BOOST_TEST(result[2] == 0);
102 }
103 {
104 std::unique_ptr<int[][2],
105 boost::alloc_deleter<int[][2], creator<> > > result =
106 boost::allocate_unique<int[][2]>(alloc: creator<>(), size: 2);
107 BOOST_TEST(result.get() != 0);
108 BOOST_TEST(result[0][0] == 0);
109 BOOST_TEST(result[0][1] == 0);
110 BOOST_TEST(result[1][0] == 0);
111 BOOST_TEST(result[1][1] == 0);
112 }
113 {
114 std::unique_ptr<int[][2],
115 boost::alloc_deleter<int[2][2], creator<> > > result =
116 boost::allocate_unique<int[2][2]>(alloc: creator<>());
117 BOOST_TEST(result.get() != 0);
118 BOOST_TEST(result[0][0] == 0);
119 BOOST_TEST(result[0][1] == 0);
120 BOOST_TEST(result[1][0] == 0);
121 BOOST_TEST(result[1][1] == 0);
122 }
123 {
124 std::unique_ptr<const int[],
125 boost::alloc_deleter<const int[], creator<> > > result =
126 boost::allocate_unique<const int[]>(alloc: creator<>(), size: 3);
127 BOOST_TEST(result.get() != 0);
128 BOOST_TEST(result[0] == 0);
129 BOOST_TEST(result[1] == 0);
130 BOOST_TEST(result[2] == 0);
131 }
132 {
133 std::unique_ptr<const int[],
134 boost::alloc_deleter<const int[3], creator<> > > result =
135 boost::allocate_unique<const int[3]>(alloc: creator<>());
136 BOOST_TEST(result.get() != 0);
137 BOOST_TEST(result[0] == 0);
138 BOOST_TEST(result[1] == 0);
139 BOOST_TEST(result[2] == 0);
140 }
141 {
142 std::unique_ptr<const int[][2],
143 boost::alloc_deleter<const int[][2], creator<> > > result =
144 boost::allocate_unique<const int[][2]>(alloc: creator<>(), size: 2);
145 BOOST_TEST(result.get() != 0);
146 BOOST_TEST(result[0][0] == 0);
147 BOOST_TEST(result[0][1] == 0);
148 BOOST_TEST(result[1][0] == 0);
149 BOOST_TEST(result[1][1] == 0);
150 }
151 {
152 std::unique_ptr<const int[][2],
153 boost::alloc_deleter<const int[2][2], creator<> > > result =
154 boost::allocate_unique<const int[2][2]>(alloc: creator<>());
155 BOOST_TEST(result.get() != 0);
156 BOOST_TEST(result[0][0] == 0);
157 BOOST_TEST(result[0][1] == 0);
158 BOOST_TEST(result[1][0] == 0);
159 BOOST_TEST(result[1][1] == 0);
160 }
161 {
162 std::unique_ptr<type[],
163 boost::alloc_deleter<type[], creator<type> > > result =
164 boost::allocate_unique<type[]>(alloc: creator<type>(), size: 3);
165 BOOST_TEST(result.get() != 0);
166 BOOST_TEST(type::instances == 3);
167 result.reset();
168 BOOST_TEST(type::instances == 0);
169 }
170 {
171 std::unique_ptr<type[],
172 boost::alloc_deleter<type[3], creator<type> > > result =
173 boost::allocate_unique<type[3]>(alloc: creator<type>());
174 BOOST_TEST(result.get() != 0);
175 BOOST_TEST(type::instances == 3);
176 result.reset();
177 BOOST_TEST(type::instances == 0);
178 }
179 {
180 std::unique_ptr<type[][2],
181 boost::alloc_deleter<type[][2], creator<> > > result =
182 boost::allocate_unique<type[][2]>(alloc: creator<>(), size: 2);
183 BOOST_TEST(result.get() != 0);
184 BOOST_TEST(type::instances == 4);
185 result.reset();
186 BOOST_TEST(type::instances == 0);
187 }
188 {
189 std::unique_ptr<type[][2],
190 boost::alloc_deleter<type[2][2], creator<> > > result =
191 boost::allocate_unique<type[2][2]>(alloc: creator<>());
192 BOOST_TEST(result.get() != 0);
193 BOOST_TEST(type::instances == 4);
194 result.reset();
195 BOOST_TEST(type::instances == 0);
196 }
197 {
198 std::unique_ptr<const type[],
199 boost::alloc_deleter<const type[], creator<> > > result =
200 boost::allocate_unique<const type[]>(alloc: creator<>(), size: 3);
201 BOOST_TEST(result.get() != 0);
202 BOOST_TEST(type::instances == 3);
203 result.reset();
204 BOOST_TEST(type::instances == 0);
205 }
206 {
207 std::unique_ptr<const type[],
208 boost::alloc_deleter<const type[3], creator<> > > result =
209 boost::allocate_unique<const type[3]>(alloc: creator<>());
210 BOOST_TEST(result.get() != 0);
211 BOOST_TEST(type::instances == 3);
212 result.reset();
213 BOOST_TEST(type::instances == 0);
214 }
215 {
216 std::unique_ptr<const type[][2],
217 boost::alloc_deleter<const type[][2], creator<> > > result =
218 boost::allocate_unique<const type[][2]>(alloc: creator<>(), size: 2);
219 BOOST_TEST(result.get() != 0);
220 BOOST_TEST(type::instances == 4);
221 result.reset();
222 BOOST_TEST(type::instances == 0);
223 }
224 {
225 std::unique_ptr<const type[][2],
226 boost::alloc_deleter<const type[2][2], creator<> > > result =
227 boost::allocate_unique<const type[2][2]>(alloc: creator<>());
228 BOOST_TEST(result.get() != 0);
229 BOOST_TEST(type::instances == 4);
230 result.reset();
231 BOOST_TEST(type::instances == 0);
232 }
233 return boost::report_errors();
234}
235#else
236int main()
237{
238 return 0;
239}
240#endif
241

source code of boost/libs/smart_ptr/test/allocate_unique_array_test.cpp