4 // Copyright 2002, 2003, 2017 Peter Dimov
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
11 #include <boost/smart_ptr/local_shared_ptr.hpp>
12 #include <boost/smart_ptr/shared_ptr.hpp>
13 #include <boost/smart_ptr/weak_ptr.hpp>
14 #include <boost/core/lightweight_test.hpp>
18 static long instances
;
33 X
& operator=( X
const & );
36 long X::instances
= 0;
40 // default constructor
42 static void default_constructor()
45 boost::local_shared_ptr
<int> p
;
47 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
48 BOOST_TEST_EQ( p
.local_use_count(), 0 );
52 boost::local_shared_ptr
<void> p
;
54 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
55 BOOST_TEST_EQ( p
.local_use_count(), 0 );
59 boost::local_shared_ptr
<incomplete
> p
;
61 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
62 BOOST_TEST_EQ( p
.local_use_count(), 0 );
65 BOOST_TEST( X::instances
== 0 );
68 boost::local_shared_ptr
<X
> p
;
70 BOOST_TEST( X::instances
== 0 );
72 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
73 BOOST_TEST_EQ( p
.local_use_count(), 0 );
77 // nullptr_constructor
79 static void nullptr_constructor()
81 #if !defined( BOOST_NO_CXX11_NULLPTR )
84 boost::local_shared_ptr
<int> p( nullptr );
86 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
87 BOOST_TEST_EQ( p
.local_use_count(), 0 );
91 boost::local_shared_ptr
<void> p( nullptr );
93 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
94 BOOST_TEST_EQ( p
.local_use_count(), 0 );
98 boost::local_shared_ptr
<incomplete
> p( nullptr );
100 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
101 BOOST_TEST_EQ( p
.local_use_count(), 0 );
104 BOOST_TEST( X::instances
== 0 );
107 boost::local_shared_ptr
<X
> p( nullptr );
109 BOOST_TEST( X::instances
== 0 );
112 BOOST_TEST_EQ( p
.get(), static_cast<void*>(0) );
113 BOOST_TEST_EQ( p
.local_use_count(), 0 );
119 // pointer constructor
121 template<class T
, class U
> static void pc0_test_()
123 boost::local_shared_ptr
<T
> p( static_cast<U
*>( 0 ) );
125 BOOST_TEST( p
? false: true );
127 BOOST_TEST( p
.get() == 0 );
128 BOOST_TEST( p
.local_use_count() == 1 );
131 template<class T
> static void pc0_test()
134 pc0_test_
<T
const, T
const>();
135 pc0_test_
<T
volatile, T
volatile>();
136 pc0_test_
<T
const volatile, T
const volatile>();
138 pc0_test_
<T
const, T
>();
139 pc0_test_
<T
volatile, T
>();
140 pc0_test_
<T
const volatile, T
>();
142 pc0_test_
<void, T
>();
143 pc0_test_
<void const, T
>();
144 pc0_test_
<void volatile, T
>();
145 pc0_test_
<void const volatile, T
>();
148 template<class T
, class U
> static void pc1_test_()
150 boost::local_shared_ptr
<T
> p( new U() );
152 BOOST_TEST( p
? true: false );
154 BOOST_TEST( p
.get() != 0 );
155 BOOST_TEST( p
.local_use_count() == 1 );
158 template<class T
> static void pc1_test()
161 pc1_test_
<T
const, T
const>();
162 pc1_test_
<T
volatile, T
volatile>();
163 pc1_test_
<T
const volatile, T
const volatile>();
165 pc1_test_
<T
const, T
>();
166 pc1_test_
<T
volatile, T
>();
167 pc1_test_
<T
const volatile, T
>();
169 pc1_test_
<void, T
>();
170 pc1_test_
<void const, T
>();
171 pc1_test_
<void volatile, T
>();
172 pc1_test_
<void const volatile, T
>();
175 static void pointer_constructor()
182 BOOST_TEST( X::instances
== 0 );
186 BOOST_TEST( X::instances
== 0 );
189 // deleter constructor
193 void deleter2( int * p
)
195 BOOST_TEST( p
== &m
);
199 template<class T
> static void deleter2_test_()
203 boost::local_shared_ptr
<T
> p( &m
, deleter2
);
205 BOOST_TEST( p
? true: false );
207 BOOST_TEST( p
.get() == &m
);
208 BOOST_TEST( p
.local_use_count() == 1 );
211 BOOST_TEST( m
== 1 );
214 static void deleter_constructor()
216 deleter2_test_
<int>();
217 deleter2_test_
<int const>();
218 deleter2_test_
<int volatile>();
219 deleter2_test_
<int const volatile>();
221 deleter2_test_
<void>();
222 deleter2_test_
<void const>();
223 deleter2_test_
<void volatile>();
224 deleter2_test_
<void const volatile>();
227 // nullptr_deleter_constructor
229 #if !defined( BOOST_NO_CXX11_NULLPTR )
231 void deleter3( boost::detail::sp_nullptr_t
)
236 template<class T
> static void deleter3_test_()
240 boost::local_shared_ptr
<T
> p( nullptr, deleter3
);
243 BOOST_TEST( p
.get() == 0 );
244 BOOST_TEST( p
.local_use_count() == 1 );
247 BOOST_TEST( m
== 1 );
250 static void nullptr_deleter_constructor()
252 deleter3_test_
<int>();
253 deleter3_test_
<int const>();
254 deleter3_test_
<int volatile>();
255 deleter3_test_
<int const volatile>();
257 deleter3_test_
<void>();
258 deleter3_test_
<void const>();
259 deleter3_test_
<void volatile>();
260 deleter3_test_
<void const volatile>();
265 static void nullptr_deleter_constructor()
271 // allocator constructor
273 template<class T
> static void allocator_test_()
277 boost::local_shared_ptr
<T
> p( &m
, deleter2
, std::allocator
<void>() );
279 BOOST_TEST( p
? true: false );
281 BOOST_TEST( p
.get() == &m
);
282 BOOST_TEST( p
.local_use_count() == 1 );
285 BOOST_TEST( m
== 1 );
288 static void allocator_constructor()
290 allocator_test_
<int>();
291 allocator_test_
<int const>();
292 allocator_test_
<int volatile>();
293 allocator_test_
<int const volatile>();
295 allocator_test_
<void>();
296 allocator_test_
<void const>();
297 allocator_test_
<void volatile>();
298 allocator_test_
<void const volatile>();
301 // nullptr_allocator_constructor
303 #if !defined( BOOST_NO_CXX11_NULLPTR )
305 template<class T
> static void allocator3_test_()
309 boost::local_shared_ptr
<T
> p( nullptr, deleter3
, std::allocator
<void>() );
312 BOOST_TEST( p
.get() == 0 );
313 BOOST_TEST( p
.local_use_count() == 1 );
316 BOOST_TEST( m
== 1 );
319 static void nullptr_allocator_constructor()
321 allocator3_test_
<int>();
322 allocator3_test_
<int const>();
323 allocator3_test_
<int volatile>();
324 allocator3_test_
<int const volatile>();
326 allocator3_test_
<void>();
327 allocator3_test_
<void const>();
328 allocator3_test_
<void volatile>();
329 allocator3_test_
<void const volatile>();
334 static void nullptr_allocator_constructor()
342 template<class T
> static void empty_copy_test()
344 boost::local_shared_ptr
<T
> p1
;
346 BOOST_TEST_EQ( p1
.get(), static_cast<void*>(0) );
347 BOOST_TEST_EQ( p1
.local_use_count(), 0 );
349 boost::local_shared_ptr
<T
> p2( p1
);
351 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
352 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
354 boost::local_shared_ptr
<T
const> p3( p1
);
356 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
357 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
359 boost::local_shared_ptr
<void> p4( p1
);
361 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
362 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
364 boost::local_shared_ptr
<void const> p5( p3
);
366 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
367 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
370 template<class T
, class U
> static void test_nonempty_copy( boost::local_shared_ptr
<U
> const & p1
)
372 long k
= p1
.local_use_count();
375 boost::local_shared_ptr
<T
> p2( p1
);
377 BOOST_TEST( p2
.get() == p1
.get() );
378 BOOST_TEST( p2
.local_use_count() == p1
.local_use_count() );
379 BOOST_TEST( p2
.local_use_count() == k
+ 1 );
382 BOOST_TEST( p1
.local_use_count() == k
);
385 template<class T
> static void null_copy_test()
387 boost::local_shared_ptr
<T
> p1( static_cast<T
*>(0) );
389 test_nonempty_copy
<T
>( p1
);
390 test_nonempty_copy
<T
const>( p1
);
391 test_nonempty_copy
<T
volatile>( p1
);
392 test_nonempty_copy
<T
const volatile>( p1
);
393 test_nonempty_copy
<void>( p1
);
394 test_nonempty_copy
<void const>( p1
);
395 test_nonempty_copy
<void volatile>( p1
);
396 test_nonempty_copy
<void const volatile>( p1
);
399 template<class T
> static void new_copy_test()
401 boost::local_shared_ptr
<T
> p1( new T() );
403 test_nonempty_copy
<T
>( p1
);
404 test_nonempty_copy
<T
const>( p1
);
405 test_nonempty_copy
<T
volatile>( p1
);
406 test_nonempty_copy
<T
const volatile>( p1
);
407 test_nonempty_copy
<void>( p1
);
408 test_nonempty_copy
<void const>( p1
);
409 test_nonempty_copy
<void volatile>( p1
);
410 test_nonempty_copy
<void const volatile>( p1
);
413 static void copy_constructor()
415 empty_copy_test
<int>();
416 empty_copy_test
<incomplete
>();
417 empty_copy_test
<X
>();
419 BOOST_TEST( X::instances
== 0 );
421 null_copy_test
<int>();
424 BOOST_TEST( X::instances
== 0 );
426 new_copy_test
<int>();
429 BOOST_TEST( X::instances
== 0 );
434 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
436 template<class T
> static void empty_move_test()
438 boost::local_shared_ptr
<T
> p2(( boost::local_shared_ptr
<T
>() ));
440 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
441 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
443 boost::local_shared_ptr
<T
const> p3(( boost::local_shared_ptr
<T
>() ));
445 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
446 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
448 boost::local_shared_ptr
<void> p4(( boost::local_shared_ptr
<T
>() ));
450 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
451 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
453 boost::local_shared_ptr
<void const> p5( std::move(p3
) );
455 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
456 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
459 template<class T
, class U
> static void test_nonempty_move( boost::local_shared_ptr
<U
> && p1
)
462 long k
= p1
.local_use_count();
464 boost::local_shared_ptr
<T
> p2( std::move(p1
) );
466 BOOST_TEST( p2
.get() == q
);
467 BOOST_TEST( p2
.local_use_count() == k
);
469 BOOST_TEST( p1
.get() == 0 );
470 BOOST_TEST( p1
.local_use_count() == 0 );
473 template<class T
> static void null_move_test()
475 test_nonempty_move
<T
>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
476 test_nonempty_move
<T
const>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
477 test_nonempty_move
<T
volatile>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
478 test_nonempty_move
<T
const volatile>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
479 test_nonempty_move
<void>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
480 test_nonempty_move
<void const>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
481 test_nonempty_move
<void volatile>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
482 test_nonempty_move
<void const volatile>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
485 template<class T
> static void new_move_test()
487 test_nonempty_move
<T
>( boost::local_shared_ptr
<T
>( new T() ) );
488 test_nonempty_move
<T
const>( boost::local_shared_ptr
<T
>( new T() ) );
489 test_nonempty_move
<T
volatile>( boost::local_shared_ptr
<T
>( new T() ) );
490 test_nonempty_move
<T
const volatile>( boost::local_shared_ptr
<T
>( new T() ) );
491 test_nonempty_move
<void>( boost::local_shared_ptr
<T
>( new T() ) );
492 test_nonempty_move
<void const>( boost::local_shared_ptr
<T
>( new T() ) );
493 test_nonempty_move
<void volatile>( boost::local_shared_ptr
<T
>( new T() ) );
494 test_nonempty_move
<void const volatile>( boost::local_shared_ptr
<T
>( new T() ) );
497 static void move_constructor()
499 empty_move_test
<int>();
500 empty_move_test
<incomplete
>();
501 empty_move_test
<X
>();
503 BOOST_TEST( X::instances
== 0 );
505 null_move_test
<int>();
508 BOOST_TEST( X::instances
== 0 );
510 new_move_test
<int>();
513 BOOST_TEST( X::instances
== 0 );
518 static void move_constructor()
524 // aliasing constructor
526 template<class T
, class U
> void test_aliasing_( boost::local_shared_ptr
<T
> const & p1
, U
* p2
)
528 boost::local_shared_ptr
<U
> p3( p1
, p2
);
530 BOOST_TEST( p3
.get() == p2
);
531 BOOST_TEST( p3
.local_use_count() == p1
.local_use_count() );
532 BOOST_TEST( !p3
.owner_before( p1
) && !p1
.owner_before( p3
) );
535 template<class T
, class U
> void test_01_aliasing_()
538 boost::local_shared_ptr
<T
> p1
;
540 test_aliasing_( p1
, &u
);
543 template<class T
, class U
> void test_01_aliasing()
545 test_01_aliasing_
<T
, U
>();
546 test_01_aliasing_
<T
const, U
>();
547 test_01_aliasing_
<T
volatile, U
>();
548 test_01_aliasing_
<T
const volatile, U
>();
550 test_01_aliasing_
<T
, U
volatile>();
551 test_01_aliasing_
<T
const, U
volatile>();
552 test_01_aliasing_
<T
volatile, U
volatile>();
553 test_01_aliasing_
<T
const volatile, U
volatile>();
556 template<class T
, class U
> void test_10_aliasing_()
558 boost::local_shared_ptr
<T
> p1( new T() );
559 test_aliasing_( p1
, static_cast<U
*>(0) );
562 template<class T
, class U
> void test_10_aliasing()
564 test_10_aliasing_
<T
, U
>();
565 test_10_aliasing_
<T
const, U
>();
566 test_10_aliasing_
<T
volatile, U
>();
567 test_10_aliasing_
<T
const volatile, U
>();
569 test_10_aliasing_
<T
, U
const>();
570 test_10_aliasing_
<T
const, U
const>();
571 test_10_aliasing_
<T
volatile, U
const>();
572 test_10_aliasing_
<T
const volatile, U
const>();
574 test_10_aliasing_
<T
, U
volatile>();
575 test_10_aliasing_
<T
const, U
volatile>();
576 test_10_aliasing_
<T
volatile, U
volatile>();
577 test_10_aliasing_
<T
const volatile, U
volatile>();
579 test_10_aliasing_
<T
, U
const volatile>();
580 test_10_aliasing_
<T
const, U
const volatile>();
581 test_10_aliasing_
<T
volatile, U
const volatile>();
582 test_10_aliasing_
<T
const volatile, U
const volatile>();
585 template<class T
, class U
> void test_11_aliasing_()
588 boost::local_shared_ptr
<T
> p1( new T() );
590 test_aliasing_( p1
, &u
);
593 template<class T
, class U
> void test_11_aliasing()
595 test_11_aliasing_
<T
, U
>();
596 test_11_aliasing_
<T
const, U
>();
597 test_11_aliasing_
<T
volatile, U
>();
598 test_11_aliasing_
<T
const volatile, U
>();
600 test_11_aliasing_
<T
, U
volatile>();
601 test_11_aliasing_
<T
const, U
volatile>();
602 test_11_aliasing_
<T
volatile, U
volatile>();
603 test_11_aliasing_
<T
const volatile, U
volatile>();
606 static void aliasing_constructor()
608 test_01_aliasing
<int, int>();
609 test_10_aliasing
<int, int>();
610 test_11_aliasing
<int, int>();
612 test_01_aliasing
<void, int>();
614 test_10_aliasing
<int, void>();
616 test_10_aliasing
<int, incomplete
>();
618 test_01_aliasing
<X
, X
>();
619 BOOST_TEST( X::instances
== 0 );
621 test_10_aliasing
<X
, X
>();
622 BOOST_TEST( X::instances
== 0 );
624 test_11_aliasing
<X
, X
>();
625 BOOST_TEST( X::instances
== 0 );
627 test_01_aliasing
<int, X
>();
628 BOOST_TEST( X::instances
== 0 );
630 test_10_aliasing
<int, X
>();
631 BOOST_TEST( X::instances
== 0 );
633 test_11_aliasing
<int, X
>();
634 BOOST_TEST( X::instances
== 0 );
636 test_01_aliasing
<X
, int>();
637 BOOST_TEST( X::instances
== 0 );
639 test_10_aliasing
<X
, int>();
640 BOOST_TEST( X::instances
== 0 );
642 test_11_aliasing
<X
, int>();
643 BOOST_TEST( X::instances
== 0 );
645 test_01_aliasing
<void, X
>();
646 BOOST_TEST( X::instances
== 0 );
648 test_10_aliasing
<X
, void>();
649 BOOST_TEST( X::instances
== 0 );
651 test_10_aliasing
<X
, incomplete
>();
652 BOOST_TEST( X::instances
== 0 );
655 // shared_ptr copy constructor
657 template<class T
> static void empty_shared_ptr_copy_test()
659 boost::shared_ptr
<T
> p1
;
661 boost::local_shared_ptr
<T
> p2( p1
);
663 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
664 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
666 boost::local_shared_ptr
<T
const> p3( p1
);
668 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
669 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
671 boost::local_shared_ptr
<void> p4( p1
);
673 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
674 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
676 boost::local_shared_ptr
<void const> p5( p3
);
678 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
679 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
682 template<class T
, class U
> static void test_nonempty_shared_ptr_copy( boost::shared_ptr
<U
> const & p1
)
684 long k
= p1
.use_count();
687 boost::local_shared_ptr
<T
> p2( p1
);
689 BOOST_TEST( p2
.get() == p1
.get() );
690 BOOST_TEST( p2
.local_use_count() == 1 );
692 BOOST_TEST( p1
.use_count() == k
+ 1 );
695 BOOST_TEST( p1
.use_count() == k
);
698 template<class T
> static void null_shared_ptr_copy_test()
700 boost::shared_ptr
<T
> p1( static_cast<T
*>(0) );
702 test_nonempty_shared_ptr_copy
<T
>( p1
);
703 test_nonempty_shared_ptr_copy
<T
const>( p1
);
704 test_nonempty_shared_ptr_copy
<T
volatile>( p1
);
705 test_nonempty_shared_ptr_copy
<T
const volatile>( p1
);
706 test_nonempty_shared_ptr_copy
<void>( p1
);
707 test_nonempty_shared_ptr_copy
<void const>( p1
);
708 test_nonempty_shared_ptr_copy
<void volatile>( p1
);
709 test_nonempty_shared_ptr_copy
<void const volatile>( p1
);
712 template<class T
> static void new_shared_ptr_copy_test()
714 boost::shared_ptr
<T
> p1( new T() );
716 test_nonempty_shared_ptr_copy
<T
>( p1
);
717 test_nonempty_shared_ptr_copy
<T
const>( p1
);
718 test_nonempty_shared_ptr_copy
<T
volatile>( p1
);
719 test_nonempty_shared_ptr_copy
<T
const volatile>( p1
);
720 test_nonempty_shared_ptr_copy
<void>( p1
);
721 test_nonempty_shared_ptr_copy
<void const>( p1
);
722 test_nonempty_shared_ptr_copy
<void volatile>( p1
);
723 test_nonempty_shared_ptr_copy
<void const volatile>( p1
);
726 static void shared_ptr_copy_constructor()
728 empty_shared_ptr_copy_test
<int>();
729 empty_shared_ptr_copy_test
<incomplete
>();
730 empty_shared_ptr_copy_test
<X
>();
732 BOOST_TEST( X::instances
== 0 );
734 null_shared_ptr_copy_test
<int>();
735 null_shared_ptr_copy_test
<X
>();
737 BOOST_TEST( X::instances
== 0 );
739 new_shared_ptr_copy_test
<int>();
740 new_shared_ptr_copy_test
<X
>();
742 BOOST_TEST( X::instances
== 0 );
745 // shared_ptr_move constructor
747 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
749 template<class T
> static void empty_shared_ptr_move_test()
751 boost::local_shared_ptr
<T
> p2(( boost::shared_ptr
<T
>() ));
753 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
754 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
756 boost::local_shared_ptr
<T
const> p3(( boost::shared_ptr
<T
>() ));
758 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
759 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
761 boost::local_shared_ptr
<void> p4(( boost::shared_ptr
<T
>() ));
763 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
764 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
766 boost::local_shared_ptr
<void const> p5( std::move(p3
) );
768 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
769 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
772 template<class T
, class U
> static void test_nonempty_shared_ptr_move( boost::shared_ptr
<U
> && p1
)
776 boost::local_shared_ptr
<T
> p2( std::move(p1
) );
778 BOOST_TEST( p2
.get() == q
);
779 BOOST_TEST( p2
.local_use_count() == 1 );
781 BOOST_TEST( p1
.get() == 0 );
782 BOOST_TEST( p1
.use_count() == 0 );
785 template<class T
> static void null_shared_ptr_move_test()
787 test_nonempty_shared_ptr_move
<T
>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
788 test_nonempty_shared_ptr_move
<T
const>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
789 test_nonempty_shared_ptr_move
<T
volatile>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
790 test_nonempty_shared_ptr_move
<T
const volatile>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
791 test_nonempty_shared_ptr_move
<void>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
792 test_nonempty_shared_ptr_move
<void const>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
793 test_nonempty_shared_ptr_move
<void volatile>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
794 test_nonempty_shared_ptr_move
<void const volatile>( boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
797 template<class T
> static void new_shared_ptr_move_test()
799 test_nonempty_shared_ptr_move
<T
>( boost::shared_ptr
<T
>( new T() ) );
800 test_nonempty_shared_ptr_move
<T
const>( boost::shared_ptr
<T
>( new T() ) );
801 test_nonempty_shared_ptr_move
<T
volatile>( boost::shared_ptr
<T
>( new T() ) );
802 test_nonempty_shared_ptr_move
<T
const volatile>( boost::shared_ptr
<T
>( new T() ) );
803 test_nonempty_shared_ptr_move
<void>( boost::shared_ptr
<T
>( new T() ) );
804 test_nonempty_shared_ptr_move
<void const>( boost::shared_ptr
<T
>( new T() ) );
805 test_nonempty_shared_ptr_move
<void volatile>( boost::shared_ptr
<T
>( new T() ) );
806 test_nonempty_shared_ptr_move
<void const volatile>( boost::shared_ptr
<T
>( new T() ) );
809 static void shared_ptr_move_constructor()
811 empty_shared_ptr_move_test
<int>();
812 empty_shared_ptr_move_test
<incomplete
>();
813 empty_shared_ptr_move_test
<X
>();
815 BOOST_TEST( X::instances
== 0 );
817 null_shared_ptr_move_test
<int>();
818 null_shared_ptr_move_test
<X
>();
820 BOOST_TEST( X::instances
== 0 );
822 new_shared_ptr_move_test
<int>();
823 new_shared_ptr_move_test
<X
>();
825 BOOST_TEST( X::instances
== 0 );
830 static void shared_ptr_move_constructor()
836 // unique_ptr_constructor
838 #if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
840 template<class T
, class U
> static void test_null_unique_ptr( std::unique_ptr
<U
> && p1
)
842 boost::local_shared_ptr
<T
> p2( std::move( p1
) );
844 BOOST_TEST( p1
.get() == 0 );
846 BOOST_TEST( p2
.get() == 0 );
847 BOOST_TEST( p2
.local_use_count() == 0 );
850 template<class T
> static void null_unique_ptr_test()
852 test_null_unique_ptr
<T
>( std::unique_ptr
<T
>() );
854 test_null_unique_ptr
<T
const>( std::unique_ptr
<T
>() );
855 test_null_unique_ptr
<T
volatile>( std::unique_ptr
<T
>() );
856 test_null_unique_ptr
<T
const volatile>( std::unique_ptr
<T
>() );
858 test_null_unique_ptr
<T
const>( std::unique_ptr
<T
const>() );
859 test_null_unique_ptr
<T
volatile>( std::unique_ptr
<T
volatile>() );
860 test_null_unique_ptr
<T
const volatile>( std::unique_ptr
<T
const volatile>() );
862 test_null_unique_ptr
<void>( std::unique_ptr
<T
>() );
864 test_null_unique_ptr
<void const>( std::unique_ptr
<T
>() );
865 test_null_unique_ptr
<void volatile>( std::unique_ptr
<T
>() );
866 test_null_unique_ptr
<void const volatile>( std::unique_ptr
<T
>() );
868 test_null_unique_ptr
<void const>( std::unique_ptr
<T
const>() );
869 test_null_unique_ptr
<void volatile>( std::unique_ptr
<T
volatile>() );
870 test_null_unique_ptr
<void const volatile>( std::unique_ptr
<T
const volatile>() );
873 template<class T
, class U
, class D
> static void test_nonempty_unique_ptr( std::unique_ptr
<U
, D
> && p1
)
877 boost::local_shared_ptr
<T
> p2( std::move(p1
) );
879 BOOST_TEST( p2
.get() == q
);
880 BOOST_TEST( p2
.local_use_count() == 1 );
882 BOOST_TEST( p1
.get() == 0 );
885 template<class T
> static void new_unique_ptr_test()
887 test_nonempty_unique_ptr
<T
>( std::unique_ptr
<T
>( new T() ) );
889 test_nonempty_unique_ptr
<T
const>( std::unique_ptr
<T
>( new T() ) );
890 test_nonempty_unique_ptr
<T
volatile>( std::unique_ptr
<T
>( new T() ) );
891 test_nonempty_unique_ptr
<T
const volatile>( std::unique_ptr
<T
>( new T() ) );
893 test_nonempty_unique_ptr
<T
const>( std::unique_ptr
<T
const>( new T() ) );
894 test_nonempty_unique_ptr
<T
volatile>( std::unique_ptr
<T
volatile>( new T() ) );
895 test_nonempty_unique_ptr
<T
const volatile>( std::unique_ptr
<T
const volatile>( new T() ) );
897 test_nonempty_unique_ptr
<void>( std::unique_ptr
<T
>( new T() ) );
899 test_nonempty_unique_ptr
<void const>( std::unique_ptr
<T
>( new T() ) );
900 test_nonempty_unique_ptr
<void volatile>( std::unique_ptr
<T
>( new T() ) );
901 test_nonempty_unique_ptr
<void const volatile>( std::unique_ptr
<T
>( new T() ) );
903 test_nonempty_unique_ptr
<void const>( std::unique_ptr
<T
const>( new T() ) );
904 test_nonempty_unique_ptr
<void volatile>( std::unique_ptr
<T
volatile>( new T() ) );
905 test_nonempty_unique_ptr
<void const volatile>( std::unique_ptr
<T
const volatile>( new T() ) );
908 template<class T
> static void test_deleter_unique_ptr()
912 test_nonempty_unique_ptr
<T
>( std::unique_ptr
<int, void(*)(int*)>( &m
, deleter2
) );
914 BOOST_TEST( m
== 1 );
917 template<class T
> static void deleter_unique_ptr_test()
919 test_deleter_unique_ptr
<T
>();
920 test_deleter_unique_ptr
<T
const>();
921 test_deleter_unique_ptr
<T
volatile>();
922 test_deleter_unique_ptr
<T
const volatile>();
925 static void unique_ptr_constructor()
927 null_unique_ptr_test
<int>();
928 null_unique_ptr_test
<X
>();
930 BOOST_TEST( X::instances
== 0 );
932 new_unique_ptr_test
<int>();
933 new_unique_ptr_test
<X
>();
935 BOOST_TEST( X::instances
== 0 );
937 deleter_unique_ptr_test
<int>();
938 deleter_unique_ptr_test
<void>();
943 static void unique_ptr_constructor()
951 template<class T
> static void empty_copy_assign_test()
953 boost::local_shared_ptr
<T
> p1
;
955 BOOST_TEST_EQ( p1
.get(), static_cast<void*>(0) );
956 BOOST_TEST_EQ( p1
.local_use_count(), 0 );
958 boost::local_shared_ptr
<T
> p2
;
962 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
963 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
965 boost::local_shared_ptr
<T
const> p3
;
969 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
970 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
972 boost::local_shared_ptr
<void> p4
;
976 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
977 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
979 boost::local_shared_ptr
<void const> p5
;
983 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
984 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
987 template<class T
> static void empty_copy_assign_test_()
989 boost::local_shared_ptr
<T
> p1
;
991 BOOST_TEST_EQ( p1
.get(), static_cast<void*>(0) );
992 BOOST_TEST_EQ( p1
.local_use_count(), 0 );
994 boost::local_shared_ptr
<T
> p2( static_cast<T
*>(0) );
998 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
999 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1001 boost::local_shared_ptr
<T
const> p3( static_cast<T
const*>(0) );
1005 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1006 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1008 boost::local_shared_ptr
<void> p4( static_cast<T
*>(0) );
1012 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1013 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1015 boost::local_shared_ptr
<void const> p5( static_cast<T
const*>(0) );
1019 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1020 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1023 template<class T
, class U
> static void test_nonempty_copy_assign( boost::local_shared_ptr
<T
> p2
, boost::local_shared_ptr
<U
> const & p1
)
1025 long k
= p1
.local_use_count();
1029 BOOST_TEST( p2
.get() == p1
.get() );
1030 BOOST_TEST( p2
.local_use_count() == p1
.local_use_count() );
1031 BOOST_TEST( p2
.local_use_count() == k
+ 1 );
1035 BOOST_TEST( p1
.local_use_count() == k
);
1038 template<class T
> static void null_copy_assign_test()
1040 boost::local_shared_ptr
<T
> p1( static_cast<T
*>(0) );
1042 test_nonempty_copy_assign( boost::local_shared_ptr
<T
>(), p1
);
1043 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const>(), p1
);
1044 test_nonempty_copy_assign( boost::local_shared_ptr
<T
volatile>(), p1
);
1045 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const volatile>(), p1
);
1047 test_nonempty_copy_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), p1
);
1048 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), p1
);
1049 test_nonempty_copy_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), p1
);
1050 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), p1
);
1052 test_nonempty_copy_assign( boost::local_shared_ptr
<void>(), p1
);
1053 test_nonempty_copy_assign( boost::local_shared_ptr
<void const>(), p1
);
1054 test_nonempty_copy_assign( boost::local_shared_ptr
<void volatile>(), p1
);
1055 test_nonempty_copy_assign( boost::local_shared_ptr
<void const volatile>(), p1
);
1058 template<class T
> static void new_copy_assign_test()
1060 boost::local_shared_ptr
<T
> p1( new T() );
1062 test_nonempty_copy_assign( boost::local_shared_ptr
<T
>(), p1
);
1063 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const>(), p1
);
1064 test_nonempty_copy_assign( boost::local_shared_ptr
<T
volatile>(), p1
);
1065 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const volatile>(), p1
);
1067 test_nonempty_copy_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), p1
);
1068 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), p1
);
1069 test_nonempty_copy_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), p1
);
1070 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), p1
);
1072 test_nonempty_copy_assign( boost::local_shared_ptr
<T
>( new T() ), p1
);
1073 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const>( new T
const() ), p1
);
1074 test_nonempty_copy_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), p1
);
1075 test_nonempty_copy_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), p1
);
1077 test_nonempty_copy_assign( boost::local_shared_ptr
<void>(), p1
);
1078 test_nonempty_copy_assign( boost::local_shared_ptr
<void const>(), p1
);
1079 test_nonempty_copy_assign( boost::local_shared_ptr
<void volatile>(), p1
);
1080 test_nonempty_copy_assign( boost::local_shared_ptr
<void const volatile>(), p1
);
1083 static void copy_assignment()
1085 empty_copy_assign_test
<incomplete
>();
1086 empty_copy_assign_test
<int>();
1087 empty_copy_assign_test_
<int>();
1088 empty_copy_assign_test
<X
>();
1089 empty_copy_assign_test_
<X
>();
1091 BOOST_TEST( X::instances
== 0 );
1093 null_copy_assign_test
<int>();
1094 null_copy_assign_test
<X
>();
1096 BOOST_TEST( X::instances
== 0 );
1098 new_copy_assign_test
<int>();
1099 new_copy_assign_test
<X
>();
1101 BOOST_TEST( X::instances
== 0 );
1106 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
1108 template<class T
> static void empty_move_assign_test()
1110 boost::local_shared_ptr
<T
> p2
;
1112 p2
= boost::local_shared_ptr
<T
>();
1114 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1115 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1117 boost::local_shared_ptr
<T
const> p3
;
1119 p3
= boost::local_shared_ptr
<T
>();
1121 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1122 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1124 boost::local_shared_ptr
<void> p4
;
1126 p4
= boost::local_shared_ptr
<T
>();
1128 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1129 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1131 boost::local_shared_ptr
<void const> p5
;
1133 p5
= std::move( p3
);
1135 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1136 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1139 template<class T
> static void empty_move_assign_test_()
1141 boost::local_shared_ptr
<T
> p2( static_cast<T
*>(0) );
1143 p2
= boost::local_shared_ptr
<T
>();
1145 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1146 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1148 boost::local_shared_ptr
<T
const> p3( static_cast<T
const*>(0) );
1150 p3
= boost::local_shared_ptr
<T
>();
1152 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1153 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1155 boost::local_shared_ptr
<void> p4( static_cast<T
*>(0) );
1157 p4
= boost::local_shared_ptr
<T
>();
1159 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1160 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1162 boost::local_shared_ptr
<void const> p5( static_cast<T
const*>(0) );
1164 p5
= std::move( p3
);
1166 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1167 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1170 template<class T
, class U
> static void test_nonempty_move_assign( boost::local_shared_ptr
<T
> p2
, boost::local_shared_ptr
<U
> && p1
)
1173 long k
= p1
.local_use_count();
1175 p2
= std::move( p1
);
1177 BOOST_TEST( p2
.get() == q
);
1178 BOOST_TEST( p2
.local_use_count() == k
);
1180 BOOST_TEST( p1
.get() == 0 );
1181 BOOST_TEST( p1
.local_use_count() == 0 );
1184 template<class T
> static void null_move_assign_test()
1186 test_nonempty_move_assign( boost::local_shared_ptr
<T
>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1187 test_nonempty_move_assign( boost::local_shared_ptr
<T
const>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1188 test_nonempty_move_assign( boost::local_shared_ptr
<T
volatile>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1189 test_nonempty_move_assign( boost::local_shared_ptr
<T
const volatile>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1191 test_nonempty_move_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1192 test_nonempty_move_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1193 test_nonempty_move_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1194 test_nonempty_move_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1196 test_nonempty_move_assign( boost::local_shared_ptr
<void>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1197 test_nonempty_move_assign( boost::local_shared_ptr
<void const>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1198 test_nonempty_move_assign( boost::local_shared_ptr
<void volatile>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1199 test_nonempty_move_assign( boost::local_shared_ptr
<void const volatile>(), boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1202 template<class T
> static void new_move_assign_test()
1204 test_nonempty_move_assign( boost::local_shared_ptr
<T
>(), boost::local_shared_ptr
<T
>( new T() ) );
1205 test_nonempty_move_assign( boost::local_shared_ptr
<T
const>(), boost::local_shared_ptr
<T
>( new T() ) );
1206 test_nonempty_move_assign( boost::local_shared_ptr
<T
volatile>(), boost::local_shared_ptr
<T
>( new T() ) );
1207 test_nonempty_move_assign( boost::local_shared_ptr
<T
const volatile>(), boost::local_shared_ptr
<T
>( new T() ) );
1209 test_nonempty_move_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), boost::local_shared_ptr
<T
>( new T() ) );
1210 test_nonempty_move_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), boost::local_shared_ptr
<T
>( new T() ) );
1211 test_nonempty_move_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), boost::local_shared_ptr
<T
>( new T() ) );
1212 test_nonempty_move_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), boost::local_shared_ptr
<T
>( new T() ) );
1214 test_nonempty_move_assign( boost::local_shared_ptr
<T
>( new T() ), boost::local_shared_ptr
<T
>( new T() ) );
1215 test_nonempty_move_assign( boost::local_shared_ptr
<T
const>( new T
const() ), boost::local_shared_ptr
<T
>( new T() ) );
1216 test_nonempty_move_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), boost::local_shared_ptr
<T
>( new T() ) );
1217 test_nonempty_move_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), boost::local_shared_ptr
<T
>( new T() ) );
1219 test_nonempty_move_assign( boost::local_shared_ptr
<void>(), boost::local_shared_ptr
<T
>( new T() ) );
1220 test_nonempty_move_assign( boost::local_shared_ptr
<void const>(), boost::local_shared_ptr
<T
>( new T() ) );
1221 test_nonempty_move_assign( boost::local_shared_ptr
<void volatile>(), boost::local_shared_ptr
<T
>( new T() ) );
1222 test_nonempty_move_assign( boost::local_shared_ptr
<void const volatile>(), boost::local_shared_ptr
<T
>( new T() ) );
1225 static void move_assignment()
1227 empty_move_assign_test
<incomplete
>();
1228 empty_move_assign_test
<int>();
1229 empty_move_assign_test_
<int>();
1230 empty_move_assign_test
<X
>();
1231 empty_move_assign_test_
<X
>();
1233 BOOST_TEST( X::instances
== 0 );
1235 null_move_assign_test
<int>();
1236 null_move_assign_test
<X
>();
1238 BOOST_TEST( X::instances
== 0 );
1240 new_move_assign_test
<int>();
1241 new_move_assign_test
<X
>();
1243 BOOST_TEST( X::instances
== 0 );
1248 static void move_assignment()
1254 // nullptr assignment
1256 #if !defined( BOOST_NO_CXX11_NULLPTR )
1258 template<class T
> static void test_nullptr_assign( boost::local_shared_ptr
<T
> p1
)
1262 BOOST_TEST( p1
.get() == 0 );
1263 BOOST_TEST( p1
.local_use_count() == 0 );
1266 template<class T
> static void empty_nullptr_assign_test()
1268 test_nullptr_assign( boost::local_shared_ptr
<T
>() );
1269 test_nullptr_assign( boost::local_shared_ptr
<T
const>() );
1270 test_nullptr_assign( boost::local_shared_ptr
<T
volatile>() );
1271 test_nullptr_assign( boost::local_shared_ptr
<T
const volatile>() );
1274 template<class T
> static void null_nullptr_assign_test()
1276 test_nullptr_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1277 test_nullptr_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ) );
1278 test_nullptr_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ) );
1279 test_nullptr_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ) );
1282 template<class T
> static void new_nullptr_assign_test()
1284 test_nullptr_assign( boost::local_shared_ptr
<T
>( new T() ) );
1285 test_nullptr_assign( boost::local_shared_ptr
<T
const>( new T
const() ) );
1286 test_nullptr_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ) );
1287 test_nullptr_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ) );
1290 static void nullptr_assignment()
1292 empty_nullptr_assign_test
<incomplete
>();
1293 empty_nullptr_assign_test
<void>();
1294 empty_nullptr_assign_test
<int>();
1295 empty_nullptr_assign_test
<X
>();
1297 BOOST_TEST( X::instances
== 0 );
1299 null_nullptr_assign_test
<int>();
1300 null_nullptr_assign_test
<X
>();
1302 BOOST_TEST( X::instances
== 0 );
1304 new_nullptr_assign_test
<int>();
1305 new_nullptr_assign_test
<X
>();
1307 BOOST_TEST( X::instances
== 0 );
1312 static void nullptr_assignment()
1320 template<class T
> static void test_default_reset( boost::local_shared_ptr
<T
> p1
)
1324 BOOST_TEST( p1
.get() == 0 );
1325 BOOST_TEST( p1
.local_use_count() == 0 );
1328 template<class T
> static void empty_default_reset_test()
1330 test_default_reset( boost::local_shared_ptr
<T
>() );
1331 test_default_reset( boost::local_shared_ptr
<T
const>() );
1332 test_default_reset( boost::local_shared_ptr
<T
volatile>() );
1333 test_default_reset( boost::local_shared_ptr
<T
const volatile>() );
1336 template<class T
> static void null_default_reset_test()
1338 test_default_reset( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1339 test_default_reset( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ) );
1340 test_default_reset( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ) );
1341 test_default_reset( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ) );
1344 template<class T
> static void new_default_reset_test()
1346 test_default_reset( boost::local_shared_ptr
<T
>( new T() ) );
1347 test_default_reset( boost::local_shared_ptr
<T
const>( new T
const() ) );
1348 test_default_reset( boost::local_shared_ptr
<T
volatile>( new T
volatile() ) );
1349 test_default_reset( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ) );
1352 static void default_reset()
1354 empty_default_reset_test
<incomplete
>();
1355 empty_default_reset_test
<void>();
1356 empty_default_reset_test
<int>();
1357 empty_default_reset_test
<X
>();
1359 BOOST_TEST( X::instances
== 0 );
1361 null_default_reset_test
<int>();
1362 null_default_reset_test
<X
>();
1364 BOOST_TEST( X::instances
== 0 );
1366 new_default_reset_test
<int>();
1367 new_default_reset_test
<X
>();
1369 BOOST_TEST( X::instances
== 0 );
1372 // shared_ptr copy assignment
1374 template<class T
> static void empty_shared_ptr_copy_assign_test()
1376 boost::shared_ptr
<T
> sp1
;
1378 BOOST_TEST_EQ( sp1
.get(), static_cast<void*>(0) );
1379 BOOST_TEST_EQ( sp1
.use_count(), 0 );
1381 boost::local_shared_ptr
<T
> p2
;
1385 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1386 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1388 boost::local_shared_ptr
<T
const> p3
;
1392 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1393 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1395 boost::local_shared_ptr
<void> p4
;
1399 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1400 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1402 boost::shared_ptr
<T
const> sp2( sp1
);
1403 boost::local_shared_ptr
<void const> p5
;
1407 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1408 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1411 template<class T
> static void empty_shared_ptr_copy_assign_test_()
1413 boost::shared_ptr
<T
> sp1
;
1415 BOOST_TEST_EQ( sp1
.get(), static_cast<void*>(0) );
1416 BOOST_TEST_EQ( sp1
.use_count(), 0 );
1418 boost::local_shared_ptr
<T
> p2( static_cast<T
*>(0) );
1422 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1423 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1425 boost::local_shared_ptr
<T
const> p3( static_cast<T
const*>(0) );
1429 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1430 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1432 boost::local_shared_ptr
<void> p4( static_cast<T
*>(0) );
1436 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1437 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1439 boost::shared_ptr
<T
const> sp2( sp1
);
1440 boost::local_shared_ptr
<void const> p5( static_cast<T
const*>(0) );
1444 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1445 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1448 template<class T
, class U
> static void test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
> p2
, boost::shared_ptr
<U
> const & p1
)
1450 long k
= p1
.use_count();
1454 BOOST_TEST( p2
.get() == p1
.get() );
1455 BOOST_TEST( p2
.local_use_count() == 1 );
1456 BOOST_TEST( p1
.use_count() == k
+ 1 );
1460 BOOST_TEST( p1
.use_count() == k
);
1463 template<class T
> static void null_shared_ptr_copy_assign_test()
1465 boost::shared_ptr
<T
> p1( static_cast<T
*>(0) );
1467 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
>(), p1
);
1468 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const>(), p1
);
1469 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
volatile>(), p1
);
1470 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const volatile>(), p1
);
1472 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), p1
);
1473 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), p1
);
1474 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), p1
);
1475 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), p1
);
1477 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void>(), p1
);
1478 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void const>(), p1
);
1479 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void volatile>(), p1
);
1480 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void const volatile>(), p1
);
1483 template<class T
> static void new_shared_ptr_copy_assign_test()
1485 boost::shared_ptr
<T
> p1( new T() );
1487 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
>(), p1
);
1488 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const>(), p1
);
1489 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
volatile>(), p1
);
1490 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const volatile>(), p1
);
1492 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), p1
);
1493 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), p1
);
1494 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), p1
);
1495 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), p1
);
1497 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
>( new T() ), p1
);
1498 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const>( new T
const() ), p1
);
1499 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), p1
);
1500 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), p1
);
1502 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void>(), p1
);
1503 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void const>(), p1
);
1504 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void volatile>(), p1
);
1505 test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr
<void const volatile>(), p1
);
1508 static void shared_ptr_copy_assignment()
1510 empty_shared_ptr_copy_assign_test
<incomplete
>();
1511 empty_shared_ptr_copy_assign_test
<int>();
1512 empty_shared_ptr_copy_assign_test_
<int>();
1513 empty_shared_ptr_copy_assign_test
<X
>();
1514 empty_shared_ptr_copy_assign_test_
<X
>();
1516 BOOST_TEST( X::instances
== 0 );
1518 null_shared_ptr_copy_assign_test
<int>();
1519 null_shared_ptr_copy_assign_test
<X
>();
1521 BOOST_TEST( X::instances
== 0 );
1523 new_shared_ptr_copy_assign_test
<int>();
1524 new_shared_ptr_copy_assign_test
<X
>();
1526 BOOST_TEST( X::instances
== 0 );
1529 // shared_ptr_move assignment
1531 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
1533 template<class T
> static void empty_shared_ptr_move_assign_test()
1535 boost::local_shared_ptr
<T
> p2
;
1537 p2
= boost::shared_ptr
<T
>();
1539 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1540 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1542 boost::local_shared_ptr
<T
const> p3
;
1544 p3
= boost::shared_ptr
<T
>();
1546 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1547 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1549 boost::local_shared_ptr
<void> p4
;
1551 p4
= boost::shared_ptr
<T
>();
1553 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1554 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1556 boost::local_shared_ptr
<void const> p5
;
1558 p5
= boost::shared_ptr
<T
const>();
1560 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1561 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1564 template<class T
> static void empty_shared_ptr_move_assign_test_()
1566 boost::local_shared_ptr
<T
> p2( static_cast<T
*>(0) );
1568 p2
= boost::shared_ptr
<T
>();
1570 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1571 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1573 boost::local_shared_ptr
<T
const> p3( static_cast<T
const*>(0) );
1575 p3
= boost::shared_ptr
<T
>();
1577 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1578 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1580 boost::local_shared_ptr
<void> p4( static_cast<T
*>(0) );
1582 p4
= boost::shared_ptr
<T
>();
1584 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1585 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1587 boost::local_shared_ptr
<void const> p5( static_cast<T
const*>(0) );
1589 p5
= boost::shared_ptr
<T
const>();
1591 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1592 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1595 template<class T
, class U
> static void test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
> p2
, boost::shared_ptr
<U
> && p1
)
1598 long k
= p1
.use_count();
1600 p2
= std::move( p1
);
1602 BOOST_TEST_EQ( p2
.get(), q
);
1603 BOOST_TEST_EQ( p2
.local_use_count(), 1 );
1605 BOOST_TEST( p1
.get() == 0 );
1606 BOOST_TEST( p1
.use_count() == 0 );
1608 boost::shared_ptr
<T
> p3( p2
);
1610 BOOST_TEST_EQ( p3
.get(), q
);
1611 BOOST_TEST_EQ( p3
.use_count(), k
+ 1 );
1614 template<class T
> static void null_shared_ptr_move_assign_test()
1616 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1617 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1618 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
volatile>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1619 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const volatile>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1621 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1622 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1623 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1624 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1626 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1627 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void const>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1628 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void volatile>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1629 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void const volatile>(), boost::shared_ptr
<T
>( static_cast<T
*>(0) ) );
1632 template<class T
> static void new_shared_ptr_move_assign_test()
1634 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
>(), boost::shared_ptr
<T
>( new T() ) );
1635 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const>(), boost::shared_ptr
<T
>( new T() ) );
1636 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
volatile>(), boost::shared_ptr
<T
>( new T() ) );
1637 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const volatile>(), boost::shared_ptr
<T
>( new T() ) );
1639 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), boost::shared_ptr
<T
>( new T() ) );
1640 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), boost::shared_ptr
<T
>( new T() ) );
1641 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), boost::shared_ptr
<T
>( new T() ) );
1642 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), boost::shared_ptr
<T
>( new T() ) );
1644 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
>( new T() ), boost::shared_ptr
<T
>( new T() ) );
1645 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const>( new T
const() ), boost::shared_ptr
<T
>( new T() ) );
1646 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), boost::shared_ptr
<T
>( new T() ) );
1647 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), boost::shared_ptr
<T
>( new T() ) );
1649 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void>(), boost::shared_ptr
<T
>( new T() ) );
1650 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void const>(), boost::shared_ptr
<T
>( new T() ) );
1651 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void volatile>(), boost::shared_ptr
<T
>( new T() ) );
1652 test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr
<void const volatile>(), boost::shared_ptr
<T
>( new T() ) );
1655 static void shared_ptr_move_assignment()
1657 empty_shared_ptr_move_assign_test
<incomplete
>();
1658 empty_shared_ptr_move_assign_test
<int>();
1659 empty_shared_ptr_move_assign_test_
<int>();
1660 empty_shared_ptr_move_assign_test
<X
>();
1661 empty_shared_ptr_move_assign_test_
<X
>();
1663 BOOST_TEST( X::instances
== 0 );
1665 null_shared_ptr_move_assign_test
<int>();
1666 null_shared_ptr_move_assign_test
<X
>();
1668 BOOST_TEST( X::instances
== 0 );
1670 new_shared_ptr_move_assign_test
<int>();
1671 new_shared_ptr_move_assign_test
<X
>();
1673 BOOST_TEST( X::instances
== 0 );
1678 static void shared_ptr_move_assignment()
1684 // unique_ptr assignment
1686 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) && !defined( BOOST_NO_CXX11_SMART_PTR )
1688 template<class T
> static void empty_unique_ptr_assign_test()
1690 boost::local_shared_ptr
<T
> p2
;
1692 p2
= std::unique_ptr
<T
>();
1694 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1695 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1697 boost::local_shared_ptr
<T
const> p3
;
1699 p3
= std::unique_ptr
<T
>();
1701 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1702 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1704 boost::local_shared_ptr
<void> p4
;
1706 p4
= std::unique_ptr
<T
>();
1708 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1709 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1711 boost::local_shared_ptr
<void const> p5
;
1713 p5
= std::unique_ptr
<T
const>();
1715 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1716 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1719 template<class T
> static void empty_unique_ptr_assign_test_()
1721 boost::local_shared_ptr
<T
> p2( static_cast<T
*>(0) );
1723 p2
= std::unique_ptr
<T
>();
1725 BOOST_TEST_EQ( p2
.get(), static_cast<void*>(0) );
1726 BOOST_TEST_EQ( p2
.local_use_count(), 0 );
1728 boost::local_shared_ptr
<T
const> p3( static_cast<T
const*>(0) );
1730 p3
= std::unique_ptr
<T
>();
1732 BOOST_TEST_EQ( p3
.get(), static_cast<void*>(0) );
1733 BOOST_TEST_EQ( p3
.local_use_count(), 0 );
1735 boost::local_shared_ptr
<void> p4( static_cast<T
*>(0) );
1737 p4
= std::unique_ptr
<T
>();
1739 BOOST_TEST_EQ( p4
.get(), static_cast<void*>(0) );
1740 BOOST_TEST_EQ( p4
.local_use_count(), 0 );
1742 boost::local_shared_ptr
<void const> p5( static_cast<T
const*>(0) );
1744 p5
= std::unique_ptr
<T
const>();
1746 BOOST_TEST_EQ( p5
.get(), static_cast<void*>(0) );
1747 BOOST_TEST_EQ( p5
.local_use_count(), 0 );
1750 template<class T
, class U
, class D
> static void test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
> p2
, std::unique_ptr
<U
, D
> && p1
)
1754 p2
= std::move( p1
);
1756 BOOST_TEST_EQ( p2
.get(), q
);
1757 BOOST_TEST_EQ( p2
.local_use_count(), 1 );
1759 BOOST_TEST( p1
.get() == 0 );
1762 template<class T
> static void new_unique_ptr_assign_test()
1764 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>(), std::unique_ptr
<T
>( new T() ) );
1765 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>(), std::unique_ptr
<T
>( new T() ) );
1766 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>(), std::unique_ptr
<T
>( new T() ) );
1767 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>(), std::unique_ptr
<T
>( new T() ) );
1769 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), std::unique_ptr
<T
>( new T() ) );
1770 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), std::unique_ptr
<T
>( new T() ) );
1771 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), std::unique_ptr
<T
>( new T() ) );
1772 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), std::unique_ptr
<T
>( new T() ) );
1774 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>( new T() ), std::unique_ptr
<T
>( new T() ) );
1775 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>( new T
const() ), std::unique_ptr
<T
>( new T() ) );
1776 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), std::unique_ptr
<T
>( new T() ) );
1777 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), std::unique_ptr
<T
>( new T() ) );
1779 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void>(), std::unique_ptr
<T
>( new T() ) );
1780 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void const>(), std::unique_ptr
<T
>( new T() ) );
1781 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void volatile>(), std::unique_ptr
<T
>( new T() ) );
1782 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void const volatile>(), std::unique_ptr
<T
>( new T() ) );
1785 template<class T
> static void del_unique_ptr_assign_test()
1787 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1788 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1789 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1790 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1792 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1793 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>( static_cast<T
const*>(0) ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1794 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>( static_cast<T
volatile*>(0) ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1795 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>( static_cast<T
const volatile*>(0) ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1797 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
>( new T() ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1798 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const>( new T
const() ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1799 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
volatile>( new T
volatile() ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1800 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<T
const volatile>( new T
const volatile() ), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1802 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1803 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void const>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1804 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void volatile>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1805 test_nonempty_unique_ptr_assign( boost::local_shared_ptr
<void const volatile>(), std::unique_ptr
<T
, boost::checked_deleter
<T
>>( new T() ) );
1808 static void unique_ptr_assignment()
1810 empty_unique_ptr_assign_test
<int>();
1811 empty_unique_ptr_assign_test_
<int>();
1812 empty_unique_ptr_assign_test
<X
>();
1813 empty_unique_ptr_assign_test_
<X
>();
1815 BOOST_TEST( X::instances
== 0 );
1817 new_unique_ptr_assign_test
<int>();
1818 new_unique_ptr_assign_test
<X
>();
1820 BOOST_TEST( X::instances
== 0 );
1822 del_unique_ptr_assign_test
<int>();
1823 del_unique_ptr_assign_test
<X
>();
1825 BOOST_TEST( X::instances
== 0 );
1830 static void unique_ptr_assignment()
1838 template<class T
, class U
> static void test_pointer_reset( boost::local_shared_ptr
<U
> p2
)
1844 BOOST_TEST_EQ( p2
.get(), q
);
1845 BOOST_TEST_EQ( p2
.local_use_count(), 1 );
1848 template<class T
> static void empty_pointer_reset_test()
1850 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
>() );
1851 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const>() );
1852 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
volatile>() );
1853 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const volatile>() );
1855 test_pointer_reset
<T
>( boost::local_shared_ptr
<void>() );
1856 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const>() );
1857 test_pointer_reset
<T
>( boost::local_shared_ptr
<void volatile>() );
1858 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const volatile>() );
1861 template<class T
> static void null_pointer_reset_test()
1863 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1864 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const>( static_cast<T
*>(0) ) );
1865 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
volatile>( static_cast<T
*>(0) ) );
1866 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( static_cast<T
*>(0) ) );
1868 test_pointer_reset
<T
>( boost::local_shared_ptr
<void>( static_cast<T
*>(0) ) );
1869 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const>( static_cast<T
*>(0) ) );
1870 test_pointer_reset
<T
>( boost::local_shared_ptr
<void volatile>( static_cast<T
*>(0) ) );
1871 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const volatile>( static_cast<T
*>(0) ) );
1874 template<class T
> static void new_pointer_reset_test()
1876 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
>( new T() ) );
1877 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const>( new T() ) );
1878 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
volatile>( new T() ) );
1879 test_pointer_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( new T() ) );
1881 test_pointer_reset
<T
>( boost::local_shared_ptr
<void>( new T() ) );
1882 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const>( new T() ) );
1883 test_pointer_reset
<T
>( boost::local_shared_ptr
<void volatile>( new T() ) );
1884 test_pointer_reset
<T
>( boost::local_shared_ptr
<void const volatile>( new T() ) );
1887 static void pointer_reset()
1889 empty_pointer_reset_test
<int>();
1890 empty_pointer_reset_test
<X
>();
1892 BOOST_TEST( X::instances
== 0 );
1894 null_pointer_reset_test
<int>();
1895 null_pointer_reset_test
<X
>();
1897 BOOST_TEST( X::instances
== 0 );
1899 new_pointer_reset_test
<int>();
1900 new_pointer_reset_test
<X
>();
1902 BOOST_TEST( X::instances
== 0 );
1907 template<class T
> class deleter
1915 explicit deleter( bool * called
): called_( called
) {}
1916 void operator()( T
* p
) { *called_
= true; delete p
; }
1919 template<class T
, class U
> static void test_deleter_reset( boost::local_shared_ptr
<U
> p2
)
1923 bool called
= false;
1925 p2
.reset( q
, deleter
<T
>( &called
) );
1927 BOOST_TEST_EQ( p2
.get(), q
);
1928 BOOST_TEST_EQ( p2
.local_use_count(), 1 );
1930 boost::shared_ptr
<U
> p3( p2
);
1932 BOOST_TEST( boost::get_deleter
< deleter
<T
> >( p3
) != 0 );
1935 BOOST_TEST( !called
);
1938 BOOST_TEST( called
);
1941 template<class T
> static void empty_deleter_reset_test()
1943 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
>() );
1944 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const>() );
1945 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
volatile>() );
1946 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const volatile>() );
1948 test_deleter_reset
<T
>( boost::local_shared_ptr
<void>() );
1949 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const>() );
1950 test_deleter_reset
<T
>( boost::local_shared_ptr
<void volatile>() );
1951 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const volatile>() );
1954 template<class T
> static void null_deleter_reset_test()
1956 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
1957 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const>( static_cast<T
*>(0) ) );
1958 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
volatile>( static_cast<T
*>(0) ) );
1959 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( static_cast<T
*>(0) ) );
1961 test_deleter_reset
<T
>( boost::local_shared_ptr
<void>( static_cast<T
*>(0) ) );
1962 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const>( static_cast<T
*>(0) ) );
1963 test_deleter_reset
<T
>( boost::local_shared_ptr
<void volatile>( static_cast<T
*>(0) ) );
1964 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const volatile>( static_cast<T
*>(0) ) );
1967 template<class T
> static void new_deleter_reset_test()
1969 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
>( new T() ) );
1970 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const>( new T() ) );
1971 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
volatile>( new T() ) );
1972 test_deleter_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( new T() ) );
1974 test_deleter_reset
<T
>( boost::local_shared_ptr
<void>( new T() ) );
1975 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const>( new T() ) );
1976 test_deleter_reset
<T
>( boost::local_shared_ptr
<void volatile>( new T() ) );
1977 test_deleter_reset
<T
>( boost::local_shared_ptr
<void const volatile>( new T() ) );
1980 static void deleter_reset()
1982 empty_deleter_reset_test
<int>();
1983 empty_deleter_reset_test
<X
>();
1985 BOOST_TEST( X::instances
== 0 );
1987 null_deleter_reset_test
<int>();
1988 null_deleter_reset_test
<X
>();
1990 BOOST_TEST( X::instances
== 0 );
1992 new_deleter_reset_test
<int>();
1993 new_deleter_reset_test
<X
>();
1995 BOOST_TEST( X::instances
== 0 );
2000 template<class T
, class U
> static void test_allocator_reset( boost::local_shared_ptr
<U
> p2
)
2004 bool called
= false;
2006 p2
.reset( q
, deleter
<T
>( &called
), std::allocator
<T
>() );
2008 BOOST_TEST_EQ( p2
.get(), q
);
2009 BOOST_TEST_EQ( p2
.local_use_count(), 1 );
2011 boost::shared_ptr
<U
> p3( p2
);
2013 BOOST_TEST( boost::get_deleter
< deleter
<T
> >( p3
) != 0 );
2016 BOOST_TEST( !called
);
2019 BOOST_TEST( called
);
2022 template<class T
> static void empty_allocator_reset_test()
2024 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
>() );
2025 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const>() );
2026 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
volatile>() );
2027 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const volatile>() );
2029 test_allocator_reset
<T
>( boost::local_shared_ptr
<void>() );
2030 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const>() );
2031 test_allocator_reset
<T
>( boost::local_shared_ptr
<void volatile>() );
2032 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const volatile>() );
2035 template<class T
> static void null_allocator_reset_test()
2037 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
>( static_cast<T
*>(0) ) );
2038 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const>( static_cast<T
*>(0) ) );
2039 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
volatile>( static_cast<T
*>(0) ) );
2040 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( static_cast<T
*>(0) ) );
2042 test_allocator_reset
<T
>( boost::local_shared_ptr
<void>( static_cast<T
*>(0) ) );
2043 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const>( static_cast<T
*>(0) ) );
2044 test_allocator_reset
<T
>( boost::local_shared_ptr
<void volatile>( static_cast<T
*>(0) ) );
2045 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const volatile>( static_cast<T
*>(0) ) );
2048 template<class T
> static void new_allocator_reset_test()
2050 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
>( new T() ) );
2051 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const>( new T() ) );
2052 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
volatile>( new T() ) );
2053 test_allocator_reset
<T
>( boost::local_shared_ptr
<T
const volatile>( new T() ) );
2055 test_allocator_reset
<T
>( boost::local_shared_ptr
<void>( new T() ) );
2056 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const>( new T() ) );
2057 test_allocator_reset
<T
>( boost::local_shared_ptr
<void volatile>( new T() ) );
2058 test_allocator_reset
<T
>( boost::local_shared_ptr
<void const volatile>( new T() ) );
2061 static void allocator_reset()
2063 empty_allocator_reset_test
<int>();
2064 empty_allocator_reset_test
<X
>();
2066 BOOST_TEST( X::instances
== 0 );
2068 null_allocator_reset_test
<int>();
2069 null_allocator_reset_test
<X
>();
2071 BOOST_TEST( X::instances
== 0 );
2073 new_allocator_reset_test
<int>();
2074 new_allocator_reset_test
<X
>();
2076 BOOST_TEST( X::instances
== 0 );
2083 void operator()( void const volatile* ) {}
2086 template<class T
, class U
> void test_aliasing_reset_( boost::local_shared_ptr
<T
> const & p1
, U
* p2
)
2088 boost::local_shared_ptr
<U
> p3( static_cast<U
*>(0), null_deleter() );
2092 BOOST_TEST( p3
.get() == p2
);
2093 BOOST_TEST( p3
.local_use_count() == p1
.local_use_count() );
2094 BOOST_TEST( !p3
.owner_before( p1
) && !p1
.owner_before( p3
) );
2097 template<class T
, class U
> void test_01_aliasing_reset_()
2100 boost::local_shared_ptr
<T
> p1
;
2102 test_aliasing_reset_( p1
, &u
);
2105 template<class T
, class U
> void test_01_aliasing_reset()
2107 test_01_aliasing_reset_
<T
, U
>();
2108 test_01_aliasing_reset_
<T
const, U
>();
2109 test_01_aliasing_reset_
<T
volatile, U
>();
2110 test_01_aliasing_reset_
<T
const volatile, U
>();
2112 test_01_aliasing_reset_
<T
, U
volatile>();
2113 test_01_aliasing_reset_
<T
const, U
volatile>();
2114 test_01_aliasing_reset_
<T
volatile, U
volatile>();
2115 test_01_aliasing_reset_
<T
const volatile, U
volatile>();
2118 template<class T
, class U
> void test_10_aliasing_reset_()
2120 boost::local_shared_ptr
<T
> p1( new T() );
2121 test_aliasing_reset_( p1
, static_cast<U
*>(0) );
2124 template<class T
, class U
> void test_10_aliasing_reset()
2126 test_10_aliasing_reset_
<T
, U
>();
2127 test_10_aliasing_reset_
<T
const, U
>();
2128 test_10_aliasing_reset_
<T
volatile, U
>();
2129 test_10_aliasing_reset_
<T
const volatile, U
>();
2131 test_10_aliasing_reset_
<T
, U
const>();
2132 test_10_aliasing_reset_
<T
const, U
const>();
2133 test_10_aliasing_reset_
<T
volatile, U
const>();
2134 test_10_aliasing_reset_
<T
const volatile, U
const>();
2136 test_10_aliasing_reset_
<T
, U
volatile>();
2137 test_10_aliasing_reset_
<T
const, U
volatile>();
2138 test_10_aliasing_reset_
<T
volatile, U
volatile>();
2139 test_10_aliasing_reset_
<T
const volatile, U
volatile>();
2141 test_10_aliasing_reset_
<T
, U
const volatile>();
2142 test_10_aliasing_reset_
<T
const, U
const volatile>();
2143 test_10_aliasing_reset_
<T
volatile, U
const volatile>();
2144 test_10_aliasing_reset_
<T
const volatile, U
const volatile>();
2147 template<class T
, class U
> void test_11_aliasing_reset_()
2150 boost::local_shared_ptr
<T
> p1( new T() );
2152 test_aliasing_reset_( p1
, &u
);
2155 template<class T
, class U
> void test_11_aliasing_reset()
2157 test_11_aliasing_reset_
<T
, U
>();
2158 test_11_aliasing_reset_
<T
const, U
>();
2159 test_11_aliasing_reset_
<T
volatile, U
>();
2160 test_11_aliasing_reset_
<T
const volatile, U
>();
2162 test_11_aliasing_reset_
<T
, U
volatile>();
2163 test_11_aliasing_reset_
<T
const, U
volatile>();
2164 test_11_aliasing_reset_
<T
volatile, U
volatile>();
2165 test_11_aliasing_reset_
<T
const volatile, U
volatile>();
2168 static void aliasing_reset()
2170 test_01_aliasing_reset
<int, int>();
2171 test_10_aliasing_reset
<int, int>();
2172 test_11_aliasing_reset
<int, int>();
2174 test_01_aliasing_reset
<void, int>();
2176 test_10_aliasing_reset
<int, void>();
2178 test_10_aliasing_reset
<int, incomplete
>();
2180 test_01_aliasing_reset
<X
, X
>();
2181 BOOST_TEST( X::instances
== 0 );
2183 test_10_aliasing_reset
<X
, X
>();
2184 BOOST_TEST( X::instances
== 0 );
2186 test_11_aliasing_reset
<X
, X
>();
2187 BOOST_TEST( X::instances
== 0 );
2189 test_01_aliasing_reset
<int, X
>();
2190 BOOST_TEST( X::instances
== 0 );
2192 test_10_aliasing_reset
<int, X
>();
2193 BOOST_TEST( X::instances
== 0 );
2195 test_11_aliasing_reset
<int, X
>();
2196 BOOST_TEST( X::instances
== 0 );
2198 test_01_aliasing_reset
<X
, int>();
2199 BOOST_TEST( X::instances
== 0 );
2201 test_10_aliasing_reset
<X
, int>();
2202 BOOST_TEST( X::instances
== 0 );
2204 test_11_aliasing_reset
<X
, int>();
2205 BOOST_TEST( X::instances
== 0 );
2207 test_01_aliasing_reset
<void, X
>();
2208 BOOST_TEST( X::instances
== 0 );
2210 test_10_aliasing_reset
<X
, void>();
2211 BOOST_TEST( X::instances
== 0 );
2213 test_10_aliasing_reset
<X
, incomplete
>();
2214 BOOST_TEST( X::instances
== 0 );
2219 template<class T
> static void empty_element_access_()
2221 boost::local_shared_ptr
<T
> p1
;
2223 BOOST_TEST_EQ( p1
.operator->(), static_cast<T
*>(0) );
2224 BOOST_TEST_EQ( p1
.get(), static_cast<T
*>(0) );
2225 BOOST_TEST( p1
? false: true );
2227 BOOST_TEST_EQ( p1
.local_use_count(), 0 );
2230 template<class T
> static void empty_element_access()
2232 empty_element_access_
<T
>();
2233 empty_element_access_
<T
const>();
2234 empty_element_access_
<T
volatile>();
2235 empty_element_access_
<T
const volatile>();
2238 template<class T
> static void new_element_access_()
2242 boost::local_shared_ptr
<T
> p1( p0
);
2244 BOOST_TEST_EQ( p1
.operator->(), p0
);
2245 BOOST_TEST_EQ( p1
.get(), p0
);
2246 BOOST_TEST_EQ( &*p1
, p0
);
2247 BOOST_TEST( p1
? true: false );
2248 BOOST_TEST_NOT( !p1
);
2249 BOOST_TEST_EQ( p1
.local_use_count(), 1 );
2253 T
* p0
= new T
[3]();
2254 boost::local_shared_ptr
<T
[]> p1( p0
);
2256 BOOST_TEST_EQ( p1
.get(), p0
);
2258 BOOST_TEST_EQ( &p1
[0], &p0
[0] );
2259 BOOST_TEST_EQ( &p1
[1], &p0
[1] );
2260 BOOST_TEST_EQ( &p1
[2], &p0
[2] );
2262 BOOST_TEST( p1
? true: false );
2263 BOOST_TEST_NOT( !p1
);
2264 BOOST_TEST_EQ( p1
.local_use_count(), 1 );
2268 T
* p0
= new T
[3]();
2269 boost::local_shared_ptr
<T
[3]> p1( p0
);
2271 BOOST_TEST_EQ( p1
.get(), p0
);
2273 BOOST_TEST_EQ( &p1
[0], &p0
[0] );
2274 BOOST_TEST_EQ( &p1
[1], &p0
[1] );
2275 BOOST_TEST_EQ( &p1
[2], &p0
[2] );
2277 BOOST_TEST( p1
? true: false );
2278 BOOST_TEST_NOT( !p1
);
2279 BOOST_TEST_EQ( p1
.local_use_count(), 1 );
2283 template<class T
> static void new_element_access()
2285 new_element_access_
<T
>();
2286 new_element_access_
<T
const>();
2287 new_element_access_
<T
volatile>();
2288 new_element_access_
<T
const volatile>();
2291 static void element_access()
2293 empty_element_access
<int>();
2294 empty_element_access
<X
>();
2296 BOOST_TEST( X::instances
== 0 );
2298 empty_element_access
<incomplete
>();
2299 empty_element_access
<void>();
2301 new_element_access
<int>();
2302 new_element_access
<X
>();
2304 BOOST_TEST( X::instances
== 0 );
2307 // shared_ptr conversion
2309 template<class T
, class U
> static void empty_shared_ptr_conversion_()
2311 boost::local_shared_ptr
<T
> p1
;
2312 boost::shared_ptr
<U
> p2( p1
);
2314 BOOST_TEST_EQ( p2
.get(), static_cast<U
*>(0) );
2315 BOOST_TEST_EQ( p2
.use_count(), 0 );
2318 template<class T
> static void empty_shared_ptr_conversion()
2320 empty_shared_ptr_conversion_
<T
, T
>();
2321 empty_shared_ptr_conversion_
<T
, T
const>();
2322 empty_shared_ptr_conversion_
<T
, T
volatile>();
2323 empty_shared_ptr_conversion_
<T
, T
const volatile>();
2325 empty_shared_ptr_conversion_
<T
const, T
const>();
2326 empty_shared_ptr_conversion_
<T
volatile, T
volatile>();
2327 empty_shared_ptr_conversion_
<T
const volatile, T
const volatile>();
2329 empty_shared_ptr_conversion_
<T
, void>();
2330 empty_shared_ptr_conversion_
<T
, void const>();
2331 empty_shared_ptr_conversion_
<T
, void volatile>();
2332 empty_shared_ptr_conversion_
<T
, void const volatile>();
2334 empty_shared_ptr_conversion_
<T
const, void const>();
2335 empty_shared_ptr_conversion_
<T
volatile, void volatile>();
2336 empty_shared_ptr_conversion_
<T
const volatile, void const volatile>();
2339 template<class T
, class U
> static void new_shared_ptr_conversion_()
2341 boost::local_shared_ptr
<T
> p1( new T() );
2342 boost::shared_ptr
<U
> p2( p1
);
2344 BOOST_TEST_EQ( p2
.get(), p1
.get() );
2345 BOOST_TEST_EQ( p2
.use_count(), 2 );
2347 boost::shared_ptr
<U
> p3( p1
);
2349 BOOST_TEST_EQ( p3
.get(), p1
.get() );
2350 BOOST_TEST_EQ( p3
.use_count(), 3 );
2351 BOOST_TEST( !(p2
< p3
) && !(p3
< p2
) );
2353 BOOST_TEST_EQ( p1
.local_use_count(), 1 );
2357 BOOST_TEST_EQ( p2
.use_count(), 2 );
2358 BOOST_TEST_EQ( p3
.use_count(), 2 );
2361 template<class T
> static void new_shared_ptr_conversion()
2363 new_shared_ptr_conversion_
<T
, T
>();
2364 new_shared_ptr_conversion_
<T
, T
const>();
2365 new_shared_ptr_conversion_
<T
, T
volatile>();
2366 new_shared_ptr_conversion_
<T
, T
const volatile>();
2368 new_shared_ptr_conversion_
<T
const, T
const>();
2369 new_shared_ptr_conversion_
<T
volatile, T
volatile>();
2370 new_shared_ptr_conversion_
<T
const volatile, T
const volatile>();
2372 new_shared_ptr_conversion_
<T
, void>();
2373 new_shared_ptr_conversion_
<T
, void const>();
2374 new_shared_ptr_conversion_
<T
, void volatile>();
2375 new_shared_ptr_conversion_
<T
, void const volatile>();
2377 new_shared_ptr_conversion_
<T
const, void const>();
2378 new_shared_ptr_conversion_
<T
volatile, void volatile>();
2379 new_shared_ptr_conversion_
<T
const volatile, void const volatile>();
2382 static void shared_ptr_conversion()
2384 empty_shared_ptr_conversion
<void>();
2385 empty_shared_ptr_conversion
<incomplete
>();
2386 empty_shared_ptr_conversion
<int>();
2387 empty_shared_ptr_conversion
<X
>();
2389 BOOST_TEST( X::instances
== 0 );
2391 new_shared_ptr_conversion
<int>();
2392 new_shared_ptr_conversion
<X
>();
2394 BOOST_TEST( X::instances
== 0 );
2397 // weak_ptr conversion
2399 template<class T
, class U
> static void empty_weak_ptr_conversion_()
2401 boost::local_shared_ptr
<T
> p1
;
2402 boost::weak_ptr
<U
> p2( p1
);
2404 BOOST_TEST_EQ( p2
.lock().get(), static_cast<U
*>(0) );
2405 BOOST_TEST_EQ( p2
.use_count(), 0 );
2408 template<class T
> static void empty_weak_ptr_conversion()
2410 empty_weak_ptr_conversion_
<T
, T
>();
2411 empty_weak_ptr_conversion_
<T
, T
const>();
2412 empty_weak_ptr_conversion_
<T
, T
volatile>();
2413 empty_weak_ptr_conversion_
<T
, T
const volatile>();
2415 empty_weak_ptr_conversion_
<T
const, T
const>();
2416 empty_weak_ptr_conversion_
<T
volatile, T
volatile>();
2417 empty_weak_ptr_conversion_
<T
const volatile, T
const volatile>();
2419 empty_weak_ptr_conversion_
<T
, void>();
2420 empty_weak_ptr_conversion_
<T
, void const>();
2421 empty_weak_ptr_conversion_
<T
, void volatile>();
2422 empty_weak_ptr_conversion_
<T
, void const volatile>();
2424 empty_weak_ptr_conversion_
<T
const, void const>();
2425 empty_weak_ptr_conversion_
<T
volatile, void volatile>();
2426 empty_weak_ptr_conversion_
<T
const volatile, void const volatile>();
2429 template<class T
, class U
> static void new_weak_ptr_conversion_()
2431 boost::local_shared_ptr
<T
> p1( new T() );
2432 boost::weak_ptr
<U
> p2( p1
);
2434 BOOST_TEST_EQ( p2
.lock().get(), p1
.get() );
2435 BOOST_TEST_EQ( p2
.use_count(), 1 );
2437 boost::weak_ptr
<U
> p3( p1
);
2439 BOOST_TEST_EQ( p3
.lock().get(), p1
.get() );
2440 BOOST_TEST_EQ( p3
.use_count(), 1 );
2441 BOOST_TEST( !(p2
< p3
) && !(p3
< p2
) );
2443 BOOST_TEST_EQ( p1
.local_use_count(), 1 );
2447 BOOST_TEST_EQ( p2
.use_count(), 0 );
2448 BOOST_TEST_EQ( p3
.use_count(), 0 );
2451 template<class T
> static void new_weak_ptr_conversion()
2453 new_weak_ptr_conversion_
<T
, T
>();
2454 new_weak_ptr_conversion_
<T
, T
const>();
2455 new_weak_ptr_conversion_
<T
, T
volatile>();
2456 new_weak_ptr_conversion_
<T
, T
const volatile>();
2458 new_weak_ptr_conversion_
<T
const, T
const>();
2459 new_weak_ptr_conversion_
<T
volatile, T
volatile>();
2460 new_weak_ptr_conversion_
<T
const volatile, T
const volatile>();
2462 new_weak_ptr_conversion_
<T
, void>();
2463 new_weak_ptr_conversion_
<T
, void const>();
2464 new_weak_ptr_conversion_
<T
, void volatile>();
2465 new_weak_ptr_conversion_
<T
, void const volatile>();
2467 new_weak_ptr_conversion_
<T
const, void const>();
2468 new_weak_ptr_conversion_
<T
volatile, void volatile>();
2469 new_weak_ptr_conversion_
<T
const volatile, void const volatile>();
2472 static void weak_ptr_conversion()
2474 empty_weak_ptr_conversion
<void>();
2475 empty_weak_ptr_conversion
<incomplete
>();
2476 empty_weak_ptr_conversion
<int>();
2477 empty_weak_ptr_conversion
<X
>();
2479 BOOST_TEST( X::instances
== 0 );
2481 new_weak_ptr_conversion
<int>();
2482 new_weak_ptr_conversion
<X
>();
2484 BOOST_TEST( X::instances
== 0 );
2491 default_constructor();
2492 nullptr_constructor();
2493 pointer_constructor();
2494 deleter_constructor();
2497 aliasing_constructor();
2498 nullptr_deleter_constructor();
2499 allocator_constructor();
2500 nullptr_allocator_constructor();
2501 shared_ptr_copy_constructor();
2502 shared_ptr_move_constructor();
2503 unique_ptr_constructor();
2507 nullptr_assignment();
2508 shared_ptr_copy_assignment();
2509 shared_ptr_move_assignment();
2510 unique_ptr_assignment();
2519 shared_ptr_conversion();
2520 weak_ptr_conversion();
2522 // owner_before_test();
2530 return boost::report_errors();