1 | ////////////////////////////////////////////////////////////////////////////// |
2 | // |
3 | // (C) Copyright Howard Hinnant 2009 |
4 | // (C) Copyright Ion Gaztanaga 2014-2014. |
5 | // |
6 | // Distributed under the Boost Software License, Version 1.0. |
7 | // (See accompanying file LICENSE_1_0.txt or copy at |
8 | // http://www.boost.org/LICENSE_1_0.txt) |
9 | // |
10 | // See http://www.boost.org/libs/move for documentation. |
11 | // |
12 | ////////////////////////////////////////////////////////////////////////////// |
13 | #include <boost/move/utility_core.hpp> |
14 | #include <boost/move/unique_ptr.hpp> |
15 | #include <boost/core/lightweight_test.hpp> |
16 | |
17 | ////////////////////////////////////////////// |
18 | // |
19 | // The initial implementation of these tests |
20 | // was written by Howard Hinnant. |
21 | // |
22 | // These test were later refactored grouping |
23 | // and porting them to Boost.Move. |
24 | // |
25 | // Many thanks to Howard for releasing his C++03 |
26 | // unique_ptr implementation with such detailed |
27 | // test cases. |
28 | // |
29 | ////////////////////////////////////////////// |
30 | |
31 | #include "unique_ptr_test_utils_beg.hpp" |
32 | |
33 | namespace bml = ::boost::movelib; |
34 | |
35 | //////////////////////////////// |
36 | // unique_ptr_asgn_move_convert_defdel |
37 | //////////////////////////////// |
38 | namespace unique_ptr_asgn_move_convert_defdel { |
39 | |
40 | void test() |
41 | { |
42 | //Single unique_ptr |
43 | reset_counters(); |
44 | { |
45 | bml::unique_ptr<B> s(new B); |
46 | A* p = s.get(); |
47 | bml::unique_ptr<A> s2(new A); |
48 | BOOST_TEST(A::count == 2); |
49 | s2 = boost::move(t&: s); |
50 | BOOST_TEST(s2.get() == p); |
51 | BOOST_TEST(s.get() == 0); |
52 | BOOST_TEST(A::count == 1); |
53 | BOOST_TEST(B::count == 1); |
54 | } |
55 | BOOST_TEST(A::count == 0); |
56 | BOOST_TEST(B::count == 0); |
57 | |
58 | //Unbounded array unique_ptr |
59 | reset_counters(); |
60 | { |
61 | bml::unique_ptr<A[]> s(new A[2]); |
62 | A* p = s.get(); |
63 | bml::unique_ptr<const A[]> s2(new const A[2]); |
64 | BOOST_TEST(A::count == 4); |
65 | s2 = boost::move(t&: s); |
66 | BOOST_TEST(s2.get() == p); |
67 | BOOST_TEST(s.get() == 0); |
68 | BOOST_TEST(A::count == 2); |
69 | } |
70 | BOOST_TEST(A::count == 0); |
71 | //Bounded array unique_ptr |
72 | reset_counters(); |
73 | { |
74 | bml::unique_ptr<A[2]> s(new A[2]); |
75 | A* p = s.get(); |
76 | bml::unique_ptr<const A[2]> s2(new const A[2]); |
77 | BOOST_TEST(A::count == 4); |
78 | s2 = boost::move(t&: s); |
79 | BOOST_TEST(s2.get() == p); |
80 | BOOST_TEST(s.get() == 0); |
81 | BOOST_TEST(A::count == 2); |
82 | } |
83 | { |
84 | BOOST_TEST(A::count == 0); |
85 | bml::unique_ptr<A[2]> s(new A[2]); |
86 | A* p = s.get(); |
87 | bml::unique_ptr<const A[]> s2(new const A[2]); |
88 | BOOST_TEST(A::count == 4); |
89 | s2 = boost::move(t&: s); |
90 | BOOST_TEST(s2.get() == p); |
91 | BOOST_TEST(s.get() == 0); |
92 | BOOST_TEST(A::count == 2); |
93 | } |
94 | BOOST_TEST(A::count == 0); |
95 | } |
96 | |
97 | } //namespace unique_ptr_asgn_move_convert_defdel{ |
98 | |
99 | //////////////////////////////// |
100 | // unique_ptr_asgn_move_convert_movdel |
101 | //////////////////////////////// |
102 | |
103 | namespace unique_ptr_asgn_move_convert_movedel{ |
104 | |
105 | void test() |
106 | { |
107 | //Single unique_ptr |
108 | reset_counters(); |
109 | { |
110 | bml::unique_ptr<B, move_constr_deleter<B> > s(new B); |
111 | A* p = s.get(); |
112 | bml::unique_ptr<A, move_constr_deleter<A> > s2(new A); |
113 | BOOST_TEST(A::count == 2); |
114 | s2 = (boost::move(t&: s)); |
115 | BOOST_TEST(s2.get() == p); |
116 | BOOST_TEST(s.get() == 0); |
117 | BOOST_TEST(A::count == 1); |
118 | BOOST_TEST(B::count == 1); |
119 | BOOST_TEST(s2.get_deleter().state() == 5); |
120 | BOOST_TEST(s.get_deleter().state() == 0); |
121 | } |
122 | BOOST_TEST(A::count == 0); |
123 | BOOST_TEST(B::count == 0); |
124 | |
125 | //Unbounded array unique_ptr |
126 | reset_counters(); |
127 | { |
128 | bml::unique_ptr<A[], move_constr_deleter<A[]> > s(new A[2]); |
129 | A* p = s.get(); |
130 | bml::unique_ptr<const A[], move_constr_deleter<const A[]> > s2(new const A[2]); |
131 | BOOST_TEST(A::count == 4); |
132 | s2 = (boost::move(t&: s)); |
133 | BOOST_TEST(s2.get() == p); |
134 | BOOST_TEST(s.get() == 0); |
135 | BOOST_TEST(A::count == 2); |
136 | BOOST_TEST(s2.get_deleter().state() == 5); |
137 | BOOST_TEST(s.get_deleter().state() == 0); |
138 | } |
139 | BOOST_TEST(A::count == 0); |
140 | |
141 | //Bounded array unique_ptr |
142 | reset_counters(); |
143 | { |
144 | bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s(new A[3]); |
145 | A* p = s.get(); |
146 | bml::unique_ptr<const A[2], move_constr_deleter<const A[2]> > s2(new const A[2]); |
147 | BOOST_TEST(A::count == 5); |
148 | s2 = (boost::move(t&: s)); |
149 | BOOST_TEST(s2.get() == p); |
150 | BOOST_TEST(s.get() == 0); |
151 | BOOST_TEST(A::count == 3); |
152 | BOOST_TEST(s2.get_deleter().state() == 5); |
153 | BOOST_TEST(s.get_deleter().state() == 0); |
154 | } |
155 | BOOST_TEST(A::count == 0); |
156 | reset_counters(); |
157 | { |
158 | bml::unique_ptr<A[2], move_constr_deleter<A[3]> > s(new A[2]); |
159 | A* p = s.get(); |
160 | bml::unique_ptr<const A[], move_constr_deleter<const A[]> > s2(new const A[2]); |
161 | BOOST_TEST(A::count == 4); |
162 | s2 = (boost::move(t&: s)); |
163 | BOOST_TEST(s2.get() == p); |
164 | BOOST_TEST(s.get() == 0); |
165 | BOOST_TEST(A::count == 2); |
166 | BOOST_TEST(s2.get_deleter().state() == 5); |
167 | BOOST_TEST(s.get_deleter().state() == 0); |
168 | } |
169 | BOOST_TEST(A::count == 0); |
170 | } |
171 | |
172 | } //namespace unique_ptr_asgn_move_convert_movedel{ |
173 | |
174 | //////////////////////////////// |
175 | // unique_ptr_asgn_move_convert_copydelref |
176 | //////////////////////////////// |
177 | |
178 | namespace unique_ptr_asgn_move_convert_copydelref{ |
179 | |
180 | // test converting move assignment with reference deleters |
181 | |
182 | void test() |
183 | { |
184 | //Single unique_ptr |
185 | reset_counters(); |
186 | { |
187 | copy_constr_deleter<B> db(5); |
188 | bml::unique_ptr<B, copy_constr_deleter<B>&> s(new B, db); |
189 | A* p = s.get(); |
190 | copy_constr_deleter<A> da(6); |
191 | bml::unique_ptr<A, copy_constr_deleter<A>&> s2(new A, da); |
192 | s2 = boost::move(t&: s); |
193 | BOOST_TEST(s2.get() == p); |
194 | BOOST_TEST(s.get() == 0); |
195 | BOOST_TEST(A::count == 1); |
196 | BOOST_TEST(B::count == 1); |
197 | BOOST_TEST(s2.get_deleter().state() == 5); |
198 | } |
199 | BOOST_TEST(A::count == 0); |
200 | BOOST_TEST(B::count == 0); |
201 | |
202 | //Unbounded array unique_ptr |
203 | reset_counters(); |
204 | { |
205 | copy_constr_deleter<A[]> db(5); |
206 | bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s(new A[2], db); |
207 | A* p = s.get(); |
208 | copy_constr_deleter<const A[]> da(6); |
209 | bml::unique_ptr<const A[], copy_constr_deleter<const A[]>&> s2(new const A[2], da); |
210 | BOOST_TEST(A::count == 4); |
211 | s2 = boost::move(t&: s); |
212 | BOOST_TEST(s2.get() == p); |
213 | BOOST_TEST(s.get() == 0); |
214 | BOOST_TEST(A::count == 2); |
215 | BOOST_TEST(s2.get_deleter().state() == 5); |
216 | } |
217 | BOOST_TEST(A::count == 0); |
218 | |
219 | //Bounded array unique_ptr |
220 | reset_counters(); |
221 | { |
222 | copy_constr_deleter<A[2]> db(5); |
223 | bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s(new A[2], db); |
224 | A* p = s.get(); |
225 | copy_constr_deleter<const A[2]> da(6); |
226 | bml::unique_ptr<const A[2], copy_constr_deleter<const A[2]>&> s2(new const A[2], da); |
227 | BOOST_TEST(A::count == 4); |
228 | s2 = boost::move(t&: s); |
229 | BOOST_TEST(s2.get() == p); |
230 | BOOST_TEST(s.get() == 0); |
231 | BOOST_TEST(A::count == 2); |
232 | BOOST_TEST(s2.get_deleter().state() == 5); |
233 | } |
234 | BOOST_TEST(A::count == 0); |
235 | reset_counters(); |
236 | { |
237 | copy_constr_deleter<A[2]> db(5); |
238 | bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s(new A[2], db); |
239 | A* p = s.get(); |
240 | copy_constr_deleter<const A[]> da(6); |
241 | bml::unique_ptr<const A[], copy_constr_deleter<const A[]>&> s2(new const A[2], da); |
242 | BOOST_TEST(A::count == 4); |
243 | s2 = boost::move(t&: s); |
244 | BOOST_TEST(s2.get() == p); |
245 | BOOST_TEST(s.get() == 0); |
246 | BOOST_TEST(A::count == 2); |
247 | BOOST_TEST(s2.get_deleter().state() == 5); |
248 | } |
249 | BOOST_TEST(A::count == 0); |
250 | } |
251 | |
252 | } //namespace unique_ptr_asgn_move_convert_copydelref{ |
253 | |
254 | //////////////////////////////// |
255 | // unique_ptr_asgn_move_defdel |
256 | //////////////////////////////// |
257 | namespace unique_ptr_asgn_move_defdel { |
258 | |
259 | void test() |
260 | { |
261 | //Single unique_ptr |
262 | reset_counters(); |
263 | { |
264 | bml::unique_ptr<A> s1(new A); |
265 | A* p = s1.get(); |
266 | bml::unique_ptr<A> s2(new A); |
267 | BOOST_TEST(A::count == 2); |
268 | s2 = boost::move(t&: s1); |
269 | BOOST_TEST(A::count == 1); |
270 | BOOST_TEST(s2.get() == p); |
271 | BOOST_TEST(s1.get() == 0); |
272 | } |
273 | BOOST_TEST(A::count == 0); |
274 | |
275 | //Unbounded array unique_ptr |
276 | reset_counters(); |
277 | { |
278 | bml::unique_ptr<A[]> s1(new A[2]); |
279 | A* p = s1.get(); |
280 | bml::unique_ptr<A[]> s2(new A[2]); |
281 | BOOST_TEST(A::count == 4); |
282 | s2 = boost::move(t&: s1); |
283 | BOOST_TEST(A::count == 2); |
284 | BOOST_TEST(s2.get() == p); |
285 | BOOST_TEST(s1.get() == 0); |
286 | } |
287 | BOOST_TEST(A::count == 0); |
288 | //Bounded array unique_ptr |
289 | reset_counters(); |
290 | { |
291 | bml::unique_ptr<A[2]> s1(new A[2]); |
292 | A* p = s1.get(); |
293 | bml::unique_ptr<A[2]> s2(new A[2]); |
294 | BOOST_TEST(A::count == 4); |
295 | s2 = boost::move(t&: s1); |
296 | BOOST_TEST(A::count == 2); |
297 | BOOST_TEST(s2.get() == p); |
298 | BOOST_TEST(s1.get() == 0); |
299 | } |
300 | BOOST_TEST(A::count == 0); |
301 | } |
302 | |
303 | } //unique_ptr_asgn_move_defdel |
304 | |
305 | //////////////////////////////// |
306 | // unique_ptr_asgn_move_movedel |
307 | //////////////////////////////// |
308 | namespace unique_ptr_asgn_move_movedel { |
309 | |
310 | void test() |
311 | { |
312 | //Single unique_ptr |
313 | reset_counters(); |
314 | { |
315 | bml::unique_ptr<A, move_constr_deleter<A> > s1(new A); |
316 | A* p = s1.get(); |
317 | bml::unique_ptr<A, move_constr_deleter<A> > s2(new A); |
318 | BOOST_TEST(A::count == 2); |
319 | s2 = boost::move(t&: s1); |
320 | BOOST_TEST(s2.get() == p); |
321 | BOOST_TEST(s1.get() == 0); |
322 | BOOST_TEST(A::count == 1); |
323 | BOOST_TEST(s2.get_deleter().state() == 5); |
324 | BOOST_TEST(s1.get_deleter().state() == 0); |
325 | } |
326 | BOOST_TEST(A::count == 0); |
327 | |
328 | //Unbounded array unique_ptr |
329 | reset_counters(); |
330 | { |
331 | bml::unique_ptr<A[], move_constr_deleter<A[]> > s1(new A[2]); |
332 | A* p = s1.get(); |
333 | bml::unique_ptr<A[], move_constr_deleter<A[]> > s2(new A[2]); |
334 | BOOST_TEST(A::count == 4); |
335 | s2 = boost::move(t&: s1); |
336 | BOOST_TEST(s2.get() == p); |
337 | BOOST_TEST(s1.get() == 0); |
338 | BOOST_TEST(A::count == 2); |
339 | BOOST_TEST(s2.get_deleter().state() == 5); |
340 | BOOST_TEST(s1.get_deleter().state() == 0); |
341 | } |
342 | BOOST_TEST(A::count == 0); |
343 | |
344 | BOOST_TEST(A::count == 0); |
345 | //Bounded array unique_ptr |
346 | reset_counters(); |
347 | { |
348 | bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s1(new A[2]); |
349 | A* p = s1.get(); |
350 | bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s2(new A[2]); |
351 | BOOST_TEST(A::count == 4); |
352 | s2 = boost::move(t&: s1); |
353 | BOOST_TEST(s2.get() == p); |
354 | BOOST_TEST(s1.get() == 0); |
355 | BOOST_TEST(A::count == 2); |
356 | BOOST_TEST(s2.get_deleter().state() == 5); |
357 | BOOST_TEST(s1.get_deleter().state() == 0); |
358 | } |
359 | BOOST_TEST(A::count == 0); |
360 | } |
361 | |
362 | } //unique_ptr_asgn_move_movedel |
363 | |
364 | //////////////////////////////// |
365 | // unique_ptr_asgn_move_copydelref |
366 | //////////////////////////////// |
367 | namespace unique_ptr_asgn_move_copydelref { |
368 | |
369 | void test() |
370 | { |
371 | //Single unique_ptr |
372 | reset_counters(); |
373 | { |
374 | copy_constr_deleter<A> d1(5); |
375 | bml::unique_ptr<A, copy_constr_deleter<A>&> s1(new A, d1); |
376 | A* p = s1.get(); |
377 | copy_constr_deleter<A> d2(6); |
378 | bml::unique_ptr<A, copy_constr_deleter<A>&> s2(new A, d2); |
379 | s2 = boost::move(t&: s1); |
380 | BOOST_TEST(s2.get() == p); |
381 | BOOST_TEST(s1.get() == 0); |
382 | BOOST_TEST(A::count == 1); |
383 | BOOST_TEST(d1.state() == 5); |
384 | BOOST_TEST(d2.state() == 5); |
385 | } |
386 | BOOST_TEST(A::count == 0); |
387 | |
388 | //Unbounded array unique_ptr |
389 | reset_counters(); |
390 | { |
391 | copy_constr_deleter<A[]> d1(5); |
392 | bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s1(new A[2], d1); |
393 | A* p = s1.get(); |
394 | copy_constr_deleter<A[]> d2(6); |
395 | bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s2(new A[2], d2); |
396 | BOOST_TEST(A::count == 4); |
397 | s2 = boost::move(t&: s1); |
398 | BOOST_TEST(s2.get() == p); |
399 | BOOST_TEST(s1.get() == 0); |
400 | BOOST_TEST(A::count == 2); |
401 | BOOST_TEST(d1.state() == 5); |
402 | BOOST_TEST(d2.state() == 5); |
403 | } |
404 | BOOST_TEST(A::count == 0); |
405 | //Bounded array unique_ptr |
406 | reset_counters(); |
407 | { |
408 | copy_constr_deleter<A[2]> d1(5); |
409 | bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s1(new A[2], d1); |
410 | A* p = s1.get(); |
411 | copy_constr_deleter<A[2]> d2(6); |
412 | bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s2(new A[2], d2); |
413 | BOOST_TEST(A::count == 4); |
414 | s2 = boost::move(t&: s1); |
415 | BOOST_TEST(s2.get() == p); |
416 | BOOST_TEST(s1.get() == 0); |
417 | BOOST_TEST(A::count == 2); |
418 | BOOST_TEST(d1.state() == 5); |
419 | BOOST_TEST(d2.state() == 5); |
420 | } |
421 | BOOST_TEST(A::count == 0); |
422 | } |
423 | |
424 | } //unique_ptr_asgn_move_copydelref |
425 | |
426 | //////////////////////////////// |
427 | // main |
428 | //////////////////////////////// |
429 | int main() |
430 | { |
431 | //Assignment |
432 | unique_ptr_asgn_move_convert_defdel::test(); |
433 | unique_ptr_asgn_move_convert_movedel::test(); |
434 | unique_ptr_asgn_move_convert_copydelref::test(); |
435 | unique_ptr_asgn_move_defdel::test(); |
436 | unique_ptr_asgn_move_movedel::test(); |
437 | unique_ptr_asgn_move_copydelref::test(); |
438 | |
439 | //Test results |
440 | return boost::report_errors(); |
441 | } |
442 | |
443 | #include "unique_ptr_test_utils_end.hpp" |
444 | |