]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/move/test/unique_ptr_ctordtor.cpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add subtree-ish sources for 12.0.3
[ceph.git] / ceph / src / boost / libs / move / test / unique_ptr_ctordtor.cpp
CommitLineData
7c673cae
FG		 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/static_assert.hpp>
16#include <boost/core/lightweight_test.hpp>
17
18//////////////////////////////////////////////
19//
20// The initial implementation of these tests
21// was written by Howard Hinnant.
22//
23// These test were later refactored grouping
24// and porting them to Boost.Move.
25//
26// Many thanks to Howard for releasing his C++03
27// unique_ptr implementation with such detailed
28// test cases.
29//
30//////////////////////////////////////////////
31
32#include "unique_ptr_test_utils_beg.hpp"
33
34namespace bml = ::boost::movelib;
35
36////////////////////////////////
37// unique_ptr_dtor_null
38////////////////////////////////
39
40namespace unique_ptr_dtor_null{
41
42// The deleter is not called if get() == 0
43
44void test()
45{
46 //Single unique_ptr
47 {
48 def_constr_deleter<int> d;
49 BOOST_TEST(d.state() == 5);
50 {
51 bml::unique_ptr<int, def_constr_deleter<int>&> p(0, d);
52 BOOST_TEST(p.get() == 0);
53 BOOST_TEST(&p.get_deleter() == &d);
54 }
55 BOOST_TEST(d.state() == 5);
56 }
57 {
58 //Unbounded array unique_ptr
59 def_constr_deleter<int[]> d;
60 BOOST_TEST(d.state() == 5);
61 {
62 bml::unique_ptr<int[], def_constr_deleter<int[]>&> p(0, d);
63 BOOST_TEST(p.get() == 0);
64 BOOST_TEST(&p.get_deleter() == &d);
65 }
66 BOOST_TEST(d.state() == 5);
67 }
68 {
69 //Bounded array unique_ptr
70 def_constr_deleter<int[2]> d;
71 BOOST_TEST(d.state() == 5);
72 {
73 bml::unique_ptr<int[2], def_constr_deleter<int[2]>&> p(0, d);
74 BOOST_TEST(p.get() == 0);
75 BOOST_TEST(&p.get_deleter() == &d);
76 }
77 BOOST_TEST(d.state() == 5);
78 }
79}
80
81} //namespace unique_ptr_dtor_null{
82
83////////////////////////////////
84// unique_ptr_ctor_default_delreq
85////////////////////////////////
86
87namespace unique_ptr_ctor_default_delreq{
88
89// default unique_ptr ctor should only require default deleter ctor
90
91void test()
92{
93 //Single unique_ptr
94 {
95 bml::unique_ptr<int> p;
96 BOOST_TEST(p.get() == 0);
97 }
98 {
99 bml::unique_ptr<int, def_constr_deleter<int> > p;
100 BOOST_TEST(p.get() == 0);
101 BOOST_TEST(p.get_deleter().state() == 5);
102 }
103 //Unbounded array unique_ptr
104 {
105 bml::unique_ptr<int[]> p;
106 BOOST_TEST(p.get() == 0);
107 }
108 {
109 bml::unique_ptr<int[], def_constr_deleter<int[]> > p;
110 BOOST_TEST(p.get() == 0);
111 BOOST_TEST(p.get_deleter().state() == 5);
112 }
113
114 //Unbounded array unique_ptr
115 {
116 bml::unique_ptr<int[]> p;
117 BOOST_TEST(p.get() == 0);
118 }
119 {
120 bml::unique_ptr<int[], def_constr_deleter<int[]> > p;
121 BOOST_TEST(p.get() == 0);
122 BOOST_TEST(p.get_deleter().state() == 5);
123 }
124
125 //Unbounded array unique_ptr
126 {
127 bml::unique_ptr<int[2]> p;
128 BOOST_TEST(p.get() == 0);
129 }
130 {
131 bml::unique_ptr<int[2], def_constr_deleter<int[2]> > p;
132 BOOST_TEST(p.get() == 0);
133 BOOST_TEST(p.get_deleter().state() == 5);
134 }
135}
136
137} //namespace unique_ptr_ctor_default_delreq{
138
139////////////////////////////////
140// unique_ptr_ctor_default_nocomplete
141////////////////////////////////
142
143namespace unique_ptr_ctor_default_nocomplete{
144
145// default unique_ptr ctor shouldn't require complete type
146
147void test()
148{
149 //Single unique_ptr
150 reset_counters();
151 {
152 J<I> s;
153 BOOST_TEST(s.get() == 0);
154 }
155 check(0);
156 {
157 J<I, def_constr_deleter<I> > s;
158 BOOST_TEST(s.get() == 0);
159 BOOST_TEST(s.get_deleter().state() == 5);
160 }
161 check(0);
162 //Unbounded array unique_ptr
163 reset_counters();
164 {
165 J<I[]> s;
166 BOOST_TEST(s.get() == 0);
167 }
168 check(0);
169 {
170 J<I[], def_constr_deleter<I[]> > s;
171 BOOST_TEST(s.get() == 0);
172 BOOST_TEST(s.get_deleter().state() == 5);
173 }
174 check(0);
175
176 //Bounded array unique_ptr
177 reset_counters();
178 {
179 J<I[2]> s;
180 BOOST_TEST(s.get() == 0);
181 }
182 check(0);
183 {
184 J<I[2], def_constr_deleter<I[2]> > s;
185 BOOST_TEST(s.get() == 0);
186 BOOST_TEST(s.get_deleter().state() == 5);
187 }
188 check(0);
189}
190
191} //namespace unique_ptr_ctor_default_nocomplete{
192
193////////////////////////////////
194// unique_ptr_ctor_pointer_delreq
195////////////////////////////////
196
197namespace unique_ptr_ctor_pointer_delreq{
198
199// unique_ptr(pointer) ctor should only require default deleter ctor
200
201void test()
202{
203 //Single unique_ptr
204 reset_counters();
205 {
206 A* p = new A;
207 BOOST_TEST(A::count == 1);
208 bml::unique_ptr<A> s(p);
209 BOOST_TEST(s.get() == p);
210 }
211 BOOST_TEST(A::count == 0);
212 {
213 A* p = new A;
214 BOOST_TEST(A::count == 1);
215 bml::unique_ptr<A, def_constr_deleter<A> > s(p);
216 BOOST_TEST(s.get() == p);
217 BOOST_TEST(s.get_deleter().state() == 5);
218 }
219 BOOST_TEST(A::count == 0);
220 //Unbounded array unique_ptr
221 reset_counters();
222 {
223 A* p = new A[2];
224 BOOST_TEST(A::count == 2);
225 bml::unique_ptr<A[]> s(p);
226 BOOST_TEST(s.get() == p);
227 }
228 BOOST_TEST(A::count == 0);
229 {
230 A* p = new A[2];
231 BOOST_TEST(A::count == 2);
232 bml::unique_ptr<A[], def_constr_deleter<A[]> > s(p);
233 BOOST_TEST(s.get() == p);
234 BOOST_TEST(s.get_deleter().state() == 5);
235 }
236 BOOST_TEST(A::count == 0);
237 //Bounded array unique_ptr
238 reset_counters();
239 {
240 A* p = new A[2];
241 BOOST_TEST(A::count == 2);
242 bml::unique_ptr<A[2]> s(p);
243 BOOST_TEST(s.get() == p);
244 }
245 BOOST_TEST(A::count == 0);
246 {
247 A* p = new A[2];
248 BOOST_TEST(A::count == 2);
249 bml::unique_ptr<A[2], def_constr_deleter<A[2]> > s(p);
250 BOOST_TEST(s.get() == p);
251 BOOST_TEST(s.get_deleter().state() == 5);
252 }
253 BOOST_TEST(A::count == 0);
254}
255
256} //namespace unique_ptr_ctor_pointer_delreq{
257
258////////////////////////////////
259// unique_ptr_ctor_pointer_nocomplete
260////////////////////////////////
261
262namespace unique_ptr_ctor_pointer_nocomplete{
263
264// unique_ptr(pointer) ctor shouldn't require complete type
265
266void test()
267{
268 //Single unique_ptr
269 reset_counters();
270 {
271 I* p = get();
272 check(1);
273 J<I> s(p);
274 BOOST_TEST(s.get() == p);
275 }
276 check(0);
277 {
278 I* p = get();
279 check(1);
280 J<I, def_constr_deleter<I> > s(p);
281 BOOST_TEST(s.get() == p);
282 BOOST_TEST(s.get_deleter().state() == 5);
283 }
284 check(0);
285 //Unbounded array unique_ptr
286 reset_counters();
287 {
288 I* p = get_array(2);
289 check(2);
290 J<I[]> s(p);
291 BOOST_TEST(s.get() == p);
292 }
293 check(0);
294 {
295 I* p = get_array(2);
296 check(2);
297 J<I[], def_constr_deleter<I[]> > s(p);
298 BOOST_TEST(s.get() == p);
299 BOOST_TEST(s.get_deleter().state() == 5);
300 }
301 check(0);
302 //Bounded array unique_ptr
303 reset_counters();
304 {
305 I* p = get_array(2);
306 check(2);
307 J<I[]> s(p);
308 BOOST_TEST(s.get() == p);
309 }
310 check(0);
311 {
312 I* p = get_array(2);
313 check(2);
314 J<I[2], def_constr_deleter<I[2]> > s(p);
315 BOOST_TEST(s.get() == p);
316 BOOST_TEST(s.get_deleter().state() == 5);
317 }
318 check(0);
319}
320
321} //namespace unique_ptr_ctor_pointer_nocomplete{
322
323////////////////////////////////
324// unique_ptr_ctor_pointer_convert
325////////////////////////////////
326
327namespace unique_ptr_ctor_pointer_convert{
328
329// unique_ptr(pointer) ctor should work with derived pointers
330// or same types (cv aside) for unique_ptr<arrays>
331
332void test()
333{
334 //Single unique_ptr
335 reset_counters();
336 {
337 B* p = new B;
338 BOOST_TEST(A::count == 1);
339 BOOST_TEST(B::count == 1);
340 bml::unique_ptr<A> s(p);
341 BOOST_TEST(s.get() == p);
342 }
343 BOOST_TEST(A::count == 0);
344 BOOST_TEST(B::count == 0);
345 {
346 B* p = new B;
347 BOOST_TEST(A::count == 1);
348 BOOST_TEST(B::count == 1);
349 bml::unique_ptr<A, def_constr_deleter<A> > s(p);
350 BOOST_TEST(s.get() == p);
351 BOOST_TEST(s.get_deleter().state() == 5);
352 }
353 BOOST_TEST(A::count == 0);
354 BOOST_TEST(B::count == 0);
355 //Unbounded array unique_ptr
356 reset_counters();
357 {
358 A* p = new A[2];
359 BOOST_TEST(A::count == 2);
360 bml::unique_ptr<const A[]> s(p);
361 BOOST_TEST(s.get() == p);
362 }
363 BOOST_TEST(A::count == 0);
364 {
365 const A* p = new const A[2];
366 BOOST_TEST(A::count == 2);
367 bml::unique_ptr<const volatile A[], def_constr_deleter<const volatile A[]> > s(p);
368 BOOST_TEST(s.get() == p);
369 BOOST_TEST(s.get_deleter().state() == 5);
370 }
371 BOOST_TEST(A::count == 0);
372 //Bounded array unique_ptr
373 reset_counters();
374 {
375 A* p = new A[2];
376 BOOST_TEST(A::count == 2);
377 bml::unique_ptr<const A[2]> s(p);
378 BOOST_TEST(s.get() == p);
379 }
380 BOOST_TEST(A::count == 0);
381 {
382 const A* p = new const A[2];
383 BOOST_TEST(A::count == 2);
384 bml::unique_ptr<const volatile A[2], def_constr_deleter<const volatile A[2]> > s(p);
385 BOOST_TEST(s.get() == p);
386 BOOST_TEST(s.get_deleter().state() == 5);
387 }
388 BOOST_TEST(A::count == 0);
389}
390
391} //namespace unique_ptr_ctor_pointer_convert{
392
393////////////////////////////////
394// unique_ptr_ctor_pointer_deleter_movedel
395////////////////////////////////
396
397namespace unique_ptr_ctor_pointer_deleter_movedel{
398
399// test move ctor. Should only require a MoveConstructible deleter, or if
400// deleter is a reference, not even that.
401
402// unique_ptr(pointer, deleter()) only requires MoveConstructible deleter
403
404void test()
405{
406 //Single unique_ptr
407 reset_counters();
408 {
409 A* p = new A;
410 BOOST_TEST(A::count == 1);
411 move_constr_deleter<A> d;
412 bml::unique_ptr<A, move_constr_deleter<A> > s(p, ::boost::move(d));
413 BOOST_TEST(s.get() == p);
414 BOOST_TEST(s.get_deleter().state() == 5);
415 bml::unique_ptr<A, move_constr_deleter<A> > s2(s.release(), move_constr_deleter<A>(6));
416 BOOST_TEST(s2.get() == p);
417 BOOST_TEST(s2.get_deleter().state() == 6);
418 }
419 BOOST_TEST(A::count == 0);
420 //Unbounded array unique_ptr
421 reset_counters();
422 {
423 A* p = new A[2];
424 BOOST_TEST(A::count == 2);
425 move_constr_deleter<A[]> d;
426 bml::unique_ptr<A[], move_constr_deleter<A[]> > s(p, ::boost::move(d));
427 BOOST_TEST(s.get() == p);
428 BOOST_TEST(s.get_deleter().state() == 5);
429 bml::unique_ptr<A[], move_constr_deleter<A[]> > s2(s.release(), move_constr_deleter<A[]>(6));
430 BOOST_TEST(s2.get() == p);
431 BOOST_TEST(s2.get_deleter().state() == 6);
432 }
433 BOOST_TEST(A::count == 0);
434 //Bounded array unique_ptr
435 reset_counters();
436 {
437 A* p = new A[2];
438 BOOST_TEST(A::count == 2);
439 move_constr_deleter<A[2]> d;
440 bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s(p, ::boost::move(d));
441 BOOST_TEST(s.get() == p);
442 BOOST_TEST(s.get_deleter().state() == 5);
443 bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s2(s.release(), move_constr_deleter<A[2]>(6));
444 BOOST_TEST(s2.get() == p);
445 BOOST_TEST(s2.get_deleter().state() == 6);
446 }
447 BOOST_TEST(A::count == 0);
448}
449
450} //namespace unique_ptr_ctor_pointer_deleter_movedel{
451
452////////////////////////////////
453// unique_ptr_ctor_pointer_deleter_copydel
454////////////////////////////////
455
456namespace unique_ptr_ctor_pointer_deleter_copydel{
457
458// unique_ptr(pointer, d) requires CopyConstructible deleter
459
460void test()
461{
462 //Single unique_ptr
463 reset_counters();
464 {
465 A* p = new A;
466 BOOST_TEST(A::count == 1);
467 copy_constr_deleter<A> d;
468 bml::unique_ptr<A, copy_constr_deleter<A> > s(p, d);
469 BOOST_TEST(s.get() == p);
470 BOOST_TEST(s.get_deleter().state() == 5);
471 d.set_state(6);
472 BOOST_TEST(s.get_deleter().state() == 5);
473 }
474 BOOST_TEST(A::count == 0);
475 //Unbounded array unique_ptr
476 reset_counters();
477 {
478 A* p = new A[2];
479 BOOST_TEST(A::count == 2);
480 copy_constr_deleter<A[]> d;
481 bml::unique_ptr<A[], copy_constr_deleter<A[]> > s(p, d);
482 BOOST_TEST(s.get() == p);
483 BOOST_TEST(s.get_deleter().state() == 5);
484 d.set_state(6);
485 BOOST_TEST(s.get_deleter().state() == 5);
486 }
487 BOOST_TEST(A::count == 0);
488 //Bounded array unique_ptr
489 reset_counters();
490 {
491 A* p = new A[2];
492 BOOST_TEST(A::count == 2);
493 copy_constr_deleter<A[2]> d;
494 bml::unique_ptr<A[2], copy_constr_deleter<A[2]> > s(p, d);
495 BOOST_TEST(s.get() == p);
496 BOOST_TEST(s.get_deleter().state() == 5);
497 d.set_state(6);
498 BOOST_TEST(s.get_deleter().state() == 5);
499 }
500 BOOST_TEST(A::count == 0);
501}
502
503} //namespace unique_ptr_ctor_pointer_deleter_copydel{
504
505////////////////////////////////
506// unique_ptr_ctor_pointer_deleter_dfctrdelref
507////////////////////////////////
508
509namespace unique_ptr_ctor_pointer_deleter_dfctrdelref{
510
511// unique_ptr<T, D&>(pointer, d) does not requires CopyConstructible deleter
512
513void test()
514{
515 //Single unique_ptr
516 reset_counters();
517 {
518 A* p = new A;
519 BOOST_TEST(A::count == 1);
520 def_constr_deleter<A> d;
521 bml::unique_ptr<A, def_constr_deleter<A>&> s(p, d);
522 BOOST_TEST(s.get() == p);
523 BOOST_TEST(s.get_deleter().state() == 5);
524 d.set_state(6);
525 BOOST_TEST(s.get_deleter().state() == 6);
526 }
527 BOOST_TEST(A::count == 0);
528 //Unbounded array unique_ptr
529 reset_counters();
530 {
531 A* p = new A[2];
532 BOOST_TEST(A::count == 2);
533 def_constr_deleter<A[]> d;
534 bml::unique_ptr<A[], def_constr_deleter<A[]>&> s(p, d);
535 BOOST_TEST(s.get() == p);
536 BOOST_TEST(s.get_deleter().state() == 5);
537 d.set_state(6);
538 BOOST_TEST(s.get_deleter().state() == 6);
539 }
540 BOOST_TEST(A::count == 0);
541 //Bounded array unique_ptr
542 reset_counters();
543 {
544 A* p = new A[2];
545 BOOST_TEST(A::count == 2);
546 def_constr_deleter<A[2]> d;
547 bml::unique_ptr<A[2], def_constr_deleter<A[2]>&> s(p, d);
548 BOOST_TEST(s.get() == p);
549 BOOST_TEST(s.get_deleter().state() == 5);
550 d.set_state(6);
551 BOOST_TEST(s.get_deleter().state() == 6);
552 }
553 BOOST_TEST(A::count == 0);
554}
555
556} //namespace unique_ptr_ctor_pointer_deleter_dfctrdelref{
557
558////////////////////////////////
559// unique_ptr_ctor_pointer_deleter_dfctrdelconstref
560////////////////////////////////
561
562namespace unique_ptr_ctor_pointer_deleter_dfctrdelconstref{
563
564// unique_ptr<T, const D&>(pointer, d) does not requires CopyConstructible deleter
565
566void test()
567{
568 //Single unique_ptr
569 reset_counters();
570 {
571 A* p = new A;
572 BOOST_TEST(A::count == 1);
573 def_constr_deleter<A> d;
574 bml::unique_ptr<A, const def_constr_deleter<A>&> s(p, d);
575 BOOST_TEST(s.get() == p);
576 BOOST_TEST(s.get_deleter().state() == 5);
577 }
578 BOOST_TEST(A::count == 0);
579 //Unbounded array unique_ptr
580 reset_counters();
581 {
582 A* p = new A[2];
583 BOOST_TEST(A::count == 2);
584 def_constr_deleter<A[]> d;
585 bml::unique_ptr<A[], const def_constr_deleter<A[]>&> s(p, d);
586 BOOST_TEST(s.get() == p);
587 BOOST_TEST(s.get_deleter().state() == 5);
588 }
589 BOOST_TEST(A::count == 0);
590 //Bounded array unique_ptr
591 reset_counters();
592 {
593 A* p = new A[2];
594 BOOST_TEST(A::count == 2);
595 def_constr_deleter<A[2]> d;
596 bml::unique_ptr<A[2], const def_constr_deleter<A[2]>&> s(p, d);
597 BOOST_TEST(s.get() == p);
598 BOOST_TEST(s.get_deleter().state() == 5);
599 }
600 BOOST_TEST(A::count == 0);
601}
602
603} //namespace unique_ptr_ctor_pointer_deleter_dfctrdelconstref{
604
605////////////////////////////////
606// unique_ptr_ctor_pointer_deleter_convert
607////////////////////////////////
608
609namespace unique_ptr_ctor_pointer_deleter_convert{
610
611// unique_ptr(pointer, deleter) should work with derived pointers
612// or same (cv aside) types for array unique_ptrs
613
614void test()
615{
616 //Single unique_ptr
617 reset_counters();
618 {
619 B* p = new B;
620 BOOST_TEST(A::count == 1);
621 BOOST_TEST(B::count == 1);
622 bml::unique_ptr<A, copy_constr_deleter<A> > s(p, copy_constr_deleter<A>());
623 BOOST_TEST(s.get() == p);
624 BOOST_TEST(s.get_deleter().state() == 5);
625 }
626 BOOST_TEST(A::count == 0);
627 BOOST_TEST(B::count == 0);
628 //Unbounded array unique_ptr
629 reset_counters();
630 {
631 A* p = new A[2];
632 BOOST_TEST(A::count == 2);
633 bml::unique_ptr<const A[], copy_constr_deleter<const A[]> > s(p, copy_constr_deleter<const A[]>());
634 BOOST_TEST(s.get() == p);
635 BOOST_TEST(s.get_deleter().state() == 5);
636 }
637 BOOST_TEST(A::count == 0);
638 BOOST_TEST(B::count == 0);
639 //Bounded array unique_ptr
640 reset_counters();
641 {
642 A* p = new A[2];
643 BOOST_TEST(A::count == 2);
644 bml::unique_ptr<const A[2], copy_constr_deleter<const A[2]> > s(p, copy_constr_deleter<const A[2]>());
645 BOOST_TEST(s.get() == p);
646 BOOST_TEST(s.get_deleter().state() == 5);
647 }
648 BOOST_TEST(A::count == 0);
649 BOOST_TEST(B::count == 0);
650}
651
652} //namespace unique_ptr_ctor_pointer_deleter_convert{
653
654////////////////////////////////
655// unique_ptr_ctor_pointer_deleter_void
656////////////////////////////////
657
658namespace unique_ptr_ctor_pointer_deleter_void{
659
660// unique_ptr(pointer, deleter) should work with function pointers
661// unique_ptr<void> should work
662
663bool my_free_called = false;
664
665void my_free(void*)
666{
667 my_free_called = true;
668}
669
670void test()
671{
672 {
673 int i = 0;
674 bml::unique_ptr<void, void (*)(void*)> s(&i, my_free);
675 BOOST_TEST(s.get() == &i);
676 BOOST_TEST(s.get_deleter() == my_free);
677 BOOST_TEST(!my_free_called);
678 }
679 BOOST_TEST(my_free_called);
680}
681
682} //namespace unique_ptr_ctor_pointer_deleter_void{
683
684////////////////////////////////
685// return_unique_single_conversion
686////////////////////////////////
687
688namespace return_unique_single_conversion{
689
690template<class T>
691bml::unique_ptr<T> make_unique_ptr_of_t()
692{
693 return bml::unique_ptr<T>(new T);
694}
695
696template<class T>
697bml::unique_ptr<T const> return_const_unique_of_t()
698{
699 return bml::unique_ptr<T const> (make_unique_ptr_of_t<T>());
700}
701
702void test()
703{
704 reset_counters();
705 BOOST_TEST(A::count == 0);
706 {
707 bml::unique_ptr<const A> p(return_const_unique_of_t<A>());
708 BOOST_TEST(A::count == 1);
709 BOOST_TEST(B::count == 0);
710 }
711 BOOST_TEST(A::count == 0);
712 {
713 bml::unique_ptr<const A> p(return_const_unique_of_t<B>());
714 BOOST_TEST(A::count == 1);
715 BOOST_TEST(B::count == 1);
716 }
717 BOOST_TEST(A::count == 0);
718}
719
720} //namespace return_unique_single_conversion{
721
722
723////////////////////////////////
724// return_unique_array_conversion
725////////////////////////////////
726
727namespace return_unique_array_conversion{
728
729template<class T>
730bml::unique_ptr<T[]> return_unique_array_of_t(std::size_t n)
731{
732 return bml::unique_ptr<T[]>(new T[n]);
733}
734
735template<class T>
736bml::unique_ptr<const T[]> return_const_array_of_t(std::size_t n)
737{
738 return bml::unique_ptr<const T[]>(return_unique_array_of_t<T>(n));
739}
740
741template<class T>
742bml::unique_ptr<T[2]> return_unique_array_of_t_2()
743{
744 return bml::unique_ptr<T[2]>(new T[2]);
745}
746
747template<class T>
748bml::unique_ptr<const T[2]> return_const_array_of_t_2()
749{
750 return bml::unique_ptr<const T[2]>(return_unique_array_of_t_2<T>());
751}
752
753void test()
754{
755 reset_counters();
756 BOOST_TEST(A::count == 0);
757 {
758 bml::unique_ptr<const A[]> p(return_unique_array_of_t<A>(2));
759 BOOST_TEST(A::count == 2);
760 BOOST_TEST(B::count == 0);
761 }
762 BOOST_TEST(A::count == 0);
763 {
764 bml::unique_ptr<const volatile A[]> p(return_unique_array_of_t<volatile A>(2));
765 BOOST_TEST(A::count == 2);
766 BOOST_TEST(B::count == 0);
767 }
768 BOOST_TEST(A::count == 0);
769 {
770 bml::unique_ptr<const volatile A[2]> p(return_const_array_of_t_2<A>());
771 BOOST_TEST(A::count == 2);
772 BOOST_TEST(B::count == 0);
773 }
774 BOOST_TEST(A::count == 0);
775 {
776 bml::unique_ptr<const volatile A[]> p(return_const_array_of_t_2<A>());
777 BOOST_TEST(A::count == 2);
778 BOOST_TEST(B::count == 0);
779 }
780 BOOST_TEST(A::count == 0);
781}
782
783} //namespace return_unique_array_conversion{
784
785////////////////////////////////
786// main
787////////////////////////////////
788int main()
789{
790 //Constructors/Destructor
791 unique_ptr_dtor_null::test();
792 unique_ptr_ctor_default_delreq::test();
793 unique_ptr_ctor_default_nocomplete::test();
794 unique_ptr_ctor_pointer_delreq::test();
795 unique_ptr_ctor_pointer_nocomplete::test();
796 unique_ptr_ctor_pointer_convert::test();
797 unique_ptr_ctor_pointer_deleter_movedel::test();
798 unique_ptr_ctor_pointer_deleter_copydel::test();
799 unique_ptr_ctor_pointer_deleter_dfctrdelref::test();
800 unique_ptr_ctor_pointer_deleter_dfctrdelconstref::test();
801 unique_ptr_ctor_pointer_deleter_convert::test();
802 unique_ptr_ctor_pointer_deleter_void::test();
803 return_unique_single_conversion::test();
804 return_unique_array_conversion::test();
805
806 //Test results
807 return boost::report_errors();
808
809}
810
811#include "unique_ptr_test_utils_end.hpp"
Ceph