1 #include <boost/config.hpp>
3 #if defined(BOOST_MSVC)
5 #pragma warning(disable: 4786) // identifier truncated in debug info
6 #pragma warning(disable: 4710) // function not inlined
7 #pragma warning(disable: 4711) // function selected for automatic inline expansion
8 #pragma warning(disable: 4514) // unreferenced inline removed
9 #pragma warning(disable: 4355) // 'this' : used in base member initializer list
11 #if (BOOST_MSVC >= 1310)
12 #pragma warning(disable: 4675) // resolved overload found with Koenig lookup
18 // shared_ptr_test.cpp
20 // Copyright (c) 2002, 2003 Peter Dimov
22 // Distributed under the Boost Software License, Version 1.0. (See
23 // accompanying file LICENSE_1_0.txt or copy at
24 // http://www.boost.org/LICENSE_1_0.txt)
27 #include <boost/detail/lightweight_test.hpp>
29 #include <boost/shared_ptr.hpp>
30 #include <boost/weak_ptr.hpp>
37 namespace n_element_type
46 typedef boost::shared_ptr<int>::element_type T;
51 } // namespace n_element_type
53 namespace n_constructors
58 void default_constructor()
61 boost::shared_ptr<int> pi;
62 BOOST_TEST(pi? false: true);
64 BOOST_TEST(pi.get() == 0);
65 BOOST_TEST(pi.use_count() == 0);
69 boost::shared_ptr<void> pv;
70 BOOST_TEST(pv? false: true);
72 BOOST_TEST(pv.get() == 0);
73 BOOST_TEST(pv.use_count() == 0);
77 boost::shared_ptr<incomplete> px;
78 BOOST_TEST(px? false: true);
80 BOOST_TEST(px.get() == 0);
81 BOOST_TEST(px.use_count() == 0);
92 static long instances;
107 X & operator= (X const &);
110 long X::instances = 0;
112 // virtual inheritance stresses the implementation
114 struct Y: public A, public virtual X
116 static long instances;
131 Y & operator= (Y const &);
134 long Y::instances = 0;
136 template<class T> void pc0_test(T * p)
139 boost::shared_ptr<T> pt(p);
140 BOOST_TEST(pt? false: true);
142 BOOST_TEST(pt.get() == 0);
143 BOOST_TEST(pt.use_count() == 1);
144 BOOST_TEST(pt.unique());
147 void pointer_constructor()
149 pc0_test(static_cast<int*>(0));
151 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
153 pc0_test(static_cast<int const*>(0));
154 pc0_test(static_cast<int volatile*>(0));
155 pc0_test(static_cast<int const volatile*>(0));
160 boost::shared_ptr<int const> pi(static_cast<int*>(0));
161 BOOST_TEST(pi? false: true);
163 BOOST_TEST(pi.get() == 0);
164 BOOST_TEST(pi.use_count() == 1);
165 BOOST_TEST(pi.unique());
169 boost::shared_ptr<int volatile> pi(static_cast<int*>(0));
170 BOOST_TEST(pi? false: true);
172 BOOST_TEST(pi.get() == 0);
173 BOOST_TEST(pi.use_count() == 1);
174 BOOST_TEST(pi.unique());
178 boost::shared_ptr<void> pv(static_cast<int*>(0));
179 BOOST_TEST(pv? false: true);
181 BOOST_TEST(pv.get() == 0);
182 BOOST_TEST(pv.use_count() == 1);
183 BOOST_TEST(pv.unique());
187 boost::shared_ptr<void const> pv(static_cast<int*>(0));
188 BOOST_TEST(pv? false: true);
190 BOOST_TEST(pv.get() == 0);
191 BOOST_TEST(pv.use_count() == 1);
192 BOOST_TEST(pv.unique());
195 pc0_test(static_cast<X*>(0));
196 pc0_test(static_cast<X const*>(0));
197 pc0_test(static_cast<X volatile*>(0));
198 pc0_test(static_cast<X const volatile*>(0));
201 boost::shared_ptr<X const> px(static_cast<X*>(0));
202 BOOST_TEST(px? false: true);
204 BOOST_TEST(px.get() == 0);
205 BOOST_TEST(px.use_count() == 1);
206 BOOST_TEST(px.unique());
210 boost::shared_ptr<X> px(static_cast<Y*>(0));
211 BOOST_TEST(px? false: true);
213 BOOST_TEST(px.get() == 0);
214 BOOST_TEST(px.use_count() == 1);
215 BOOST_TEST(px.unique());
219 boost::shared_ptr<X const> px(static_cast<Y*>(0));
220 BOOST_TEST(px? false: true);
222 BOOST_TEST(px.get() == 0);
223 BOOST_TEST(px.use_count() == 1);
224 BOOST_TEST(px.unique());
228 boost::shared_ptr<void> pv(static_cast<X*>(0));
229 BOOST_TEST(pv? false: true);
231 BOOST_TEST(pv.get() == 0);
232 BOOST_TEST(pv.use_count() == 1);
233 BOOST_TEST(pv.unique());
237 boost::shared_ptr<void const> pv(static_cast<X*>(0));
238 BOOST_TEST(pv? false: true);
240 BOOST_TEST(pv.get() == 0);
241 BOOST_TEST(pv.use_count() == 1);
242 BOOST_TEST(pv.unique());
246 int * p = new int(7);
247 boost::shared_ptr<int> pi(p);
248 BOOST_TEST(pi? true: false);
250 BOOST_TEST(pi.get() == p);
251 BOOST_TEST(pi.use_count() == 1);
252 BOOST_TEST(pi.unique());
253 BOOST_TEST(*pi == 7);
257 int * p = new int(7);
258 boost::shared_ptr<int const> pi(p);
259 BOOST_TEST(pi? true: false);
261 BOOST_TEST(pi.get() == p);
262 BOOST_TEST(pi.use_count() == 1);
263 BOOST_TEST(pi.unique());
264 BOOST_TEST(*pi == 7);
268 int * p = new int(7);
269 boost::shared_ptr<void> pv(p);
270 BOOST_TEST(pv? true: false);
272 BOOST_TEST(pv.get() == p);
273 BOOST_TEST(pv.use_count() == 1);
274 BOOST_TEST(pv.unique());
278 int * p = new int(7);
279 boost::shared_ptr<void const> pv(p);
280 BOOST_TEST(pv? true: false);
282 BOOST_TEST(pv.get() == p);
283 BOOST_TEST(pv.use_count() == 1);
284 BOOST_TEST(pv.unique());
287 BOOST_TEST(X::instances == 0);
291 boost::shared_ptr<X> px(p);
292 BOOST_TEST(px? true: false);
294 BOOST_TEST(px.get() == p);
295 BOOST_TEST(px.use_count() == 1);
296 BOOST_TEST(px.unique());
297 BOOST_TEST(X::instances == 1);
300 BOOST_TEST(X::instances == 0);
304 boost::shared_ptr<X const> px(p);
305 BOOST_TEST(px? true: false);
307 BOOST_TEST(px.get() == p);
308 BOOST_TEST(px.use_count() == 1);
309 BOOST_TEST(px.unique());
310 BOOST_TEST(X::instances == 1);
313 BOOST_TEST(X::instances == 0);
317 boost::shared_ptr<void> pv(p);
318 BOOST_TEST(pv? true: false);
320 BOOST_TEST(pv.get() == p);
321 BOOST_TEST(pv.use_count() == 1);
322 BOOST_TEST(pv.unique());
323 BOOST_TEST(X::instances == 1);
326 BOOST_TEST(X::instances == 0);
330 boost::shared_ptr<void const> pv(p);
331 BOOST_TEST(pv? true: false);
333 BOOST_TEST(pv.get() == p);
334 BOOST_TEST(pv.use_count() == 1);
335 BOOST_TEST(pv.unique());
336 BOOST_TEST(X::instances == 1);
339 BOOST_TEST(X::instances == 0);
340 BOOST_TEST(Y::instances == 0);
344 boost::shared_ptr<X> px(p);
345 BOOST_TEST(px? true: false);
347 BOOST_TEST(px.get() == p);
348 BOOST_TEST(px.use_count() == 1);
349 BOOST_TEST(px.unique());
350 BOOST_TEST(X::instances == 1);
351 BOOST_TEST(Y::instances == 1);
354 BOOST_TEST(X::instances == 0);
355 BOOST_TEST(Y::instances == 0);
359 boost::shared_ptr<X const> px(p);
360 BOOST_TEST(px? true: false);
362 BOOST_TEST(px.get() == p);
363 BOOST_TEST(px.use_count() == 1);
364 BOOST_TEST(px.unique());
365 BOOST_TEST(X::instances == 1);
366 BOOST_TEST(Y::instances == 1);
369 BOOST_TEST(X::instances == 0);
370 BOOST_TEST(Y::instances == 0);
375 void deleter(int * p)
380 void deleter2(int * p)
388 void operator()(incomplete * p)
394 // Borland C++ 5.5.1 fails on static_cast<incomplete*>(0)
398 void deleter_constructor()
401 boost::shared_ptr<int> pi(static_cast<int*>(0), deleter);
402 BOOST_TEST(pi? false: true);
404 BOOST_TEST(pi.get() == 0);
405 BOOST_TEST(pi.use_count() == 1);
406 BOOST_TEST(pi.unique());
410 boost::shared_ptr<void> pv(static_cast<int*>(0), &deleter);
411 BOOST_TEST(pv? false: true);
413 BOOST_TEST(pv.get() == 0);
414 BOOST_TEST(pv.use_count() == 1);
415 BOOST_TEST(pv.unique());
419 boost::shared_ptr<void const> pv(static_cast<int*>(0), deleter);
420 BOOST_TEST(pv? false: true);
422 BOOST_TEST(pv.get() == 0);
423 BOOST_TEST(pv.use_count() == 1);
424 BOOST_TEST(pv.unique());
428 boost::shared_ptr<incomplete> px(p0, deleter3());
429 BOOST_TEST(px? false: true);
431 BOOST_TEST(px.get() == 0);
432 BOOST_TEST(px.use_count() == 1);
433 BOOST_TEST(px.unique());
437 boost::shared_ptr<void> pv(p0, deleter3());
438 BOOST_TEST(pv? false: true);
440 BOOST_TEST(pv.get() == 0);
441 BOOST_TEST(pv.use_count() == 1);
442 BOOST_TEST(pv.unique());
446 boost::shared_ptr<void const> pv(p0, deleter3());
447 BOOST_TEST(pv? false: true);
449 BOOST_TEST(pv.get() == 0);
450 BOOST_TEST(pv.use_count() == 1);
451 BOOST_TEST(pv.unique());
457 boost::shared_ptr<int> pi(&m, deleter2);
458 BOOST_TEST(pi? true: false);
460 BOOST_TEST(pi.get() == &m);
461 BOOST_TEST(pi.use_count() == 1);
462 BOOST_TEST(pi.unique());
468 boost::shared_ptr<int const> pi(&m, &deleter2);
469 BOOST_TEST(pi? true: false);
471 BOOST_TEST(pi.get() == &m);
472 BOOST_TEST(pi.use_count() == 1);
473 BOOST_TEST(pi.unique());
479 boost::shared_ptr<void> pv(&m, deleter2);
480 BOOST_TEST(pv? true: false);
482 BOOST_TEST(pv.get() == &m);
483 BOOST_TEST(pv.use_count() == 1);
484 BOOST_TEST(pv.unique());
490 boost::shared_ptr<void const> pv(&m, &deleter2);
491 BOOST_TEST(pv? true: false);
493 BOOST_TEST(pv.get() == &m);
494 BOOST_TEST(pv.use_count() == 1);
495 BOOST_TEST(pv.unique());
501 void copy_constructor()
504 boost::shared_ptr<int> pi;
506 boost::shared_ptr<int> pi2(pi);
507 BOOST_TEST(pi2 == pi);
508 BOOST_TEST(pi2? false: true);
510 BOOST_TEST(pi2.get() == 0);
511 BOOST_TEST(pi2.use_count() == pi.use_count());
513 boost::shared_ptr<void> pi3(pi);
514 BOOST_TEST(pi3 == pi);
515 BOOST_TEST(pi3? false: true);
517 BOOST_TEST(pi3.get() == 0);
518 BOOST_TEST(pi3.use_count() == pi.use_count());
520 boost::shared_ptr<void> pi4(pi3);
521 BOOST_TEST(pi4 == pi3);
522 BOOST_TEST(pi4? false: true);
524 BOOST_TEST(pi4.get() == 0);
525 BOOST_TEST(pi4.use_count() == pi3.use_count());
529 boost::shared_ptr<void> pv;
531 boost::shared_ptr<void> pv2(pv);
532 BOOST_TEST(pv2 == pv);
533 BOOST_TEST(pv2? false: true);
535 BOOST_TEST(pv2.get() == 0);
536 BOOST_TEST(pv2.use_count() == pv.use_count());
540 boost::shared_ptr<incomplete> px;
542 boost::shared_ptr<incomplete> px2(px);
543 BOOST_TEST(px2 == px);
544 BOOST_TEST(px2? false: true);
546 BOOST_TEST(px2.get() == 0);
547 BOOST_TEST(px2.use_count() == px.use_count());
549 boost::shared_ptr<void> px3(px);
550 BOOST_TEST(px3 == px);
551 BOOST_TEST(px3? false: true);
553 BOOST_TEST(px3.get() == 0);
554 BOOST_TEST(px3.use_count() == px.use_count());
558 boost::shared_ptr<int> pi(static_cast<int*>(0));
560 boost::shared_ptr<int> pi2(pi);
561 BOOST_TEST(pi2 == pi);
562 BOOST_TEST(pi2? false: true);
564 BOOST_TEST(pi2.get() == 0);
565 BOOST_TEST(pi2.use_count() == 2);
566 BOOST_TEST(!pi2.unique());
567 BOOST_TEST(pi2.use_count() == pi.use_count());
568 BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
570 boost::shared_ptr<void> pi3(pi);
571 BOOST_TEST(pi3 == pi);
572 BOOST_TEST(pi3? false: true);
574 BOOST_TEST(pi3.get() == 0);
575 BOOST_TEST(pi3.use_count() == 3);
576 BOOST_TEST(!pi3.unique());
577 BOOST_TEST(pi3.use_count() == pi.use_count());
578 BOOST_TEST(!(pi < pi3 || pi3 < pi)); // shared ownership test
580 boost::shared_ptr<void> pi4(pi2);
581 BOOST_TEST(pi4 == pi2);
582 BOOST_TEST(pi4? false: true);
584 BOOST_TEST(pi4.get() == 0);
585 BOOST_TEST(pi4.use_count() == 4);
586 BOOST_TEST(!pi4.unique());
587 BOOST_TEST(pi4.use_count() == pi2.use_count());
588 BOOST_TEST(!(pi2 < pi4 || pi4 < pi2)); // shared ownership test
590 BOOST_TEST(pi3.use_count() == pi4.use_count());
591 BOOST_TEST(!(pi3 < pi4 || pi4 < pi3)); // shared ownership test
595 boost::shared_ptr<X> px(static_cast<X*>(0));
597 boost::shared_ptr<X> px2(px);
598 BOOST_TEST(px2 == px);
599 BOOST_TEST(px2? false: true);
601 BOOST_TEST(px2.get() == 0);
602 BOOST_TEST(px2.use_count() == 2);
603 BOOST_TEST(!px2.unique());
604 BOOST_TEST(px2.use_count() == px.use_count());
605 BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
607 boost::shared_ptr<void> px3(px);
608 BOOST_TEST(px3 == px);
609 BOOST_TEST(px3? false: true);
611 BOOST_TEST(px3.get() == 0);
612 BOOST_TEST(px3.use_count() == 3);
613 BOOST_TEST(!px3.unique());
614 BOOST_TEST(px3.use_count() == px.use_count());
615 BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
617 boost::shared_ptr<void> px4(px2);
618 BOOST_TEST(px4 == px2);
619 BOOST_TEST(px4? false: true);
621 BOOST_TEST(px4.get() == 0);
622 BOOST_TEST(px4.use_count() == 4);
623 BOOST_TEST(!px4.unique());
624 BOOST_TEST(px4.use_count() == px2.use_count());
625 BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
627 BOOST_TEST(px3.use_count() == px4.use_count());
628 BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
632 int * p = new int(7);
633 boost::shared_ptr<int> pi(p);
635 boost::shared_ptr<int> pi2(pi);
636 BOOST_TEST(pi2 == pi);
637 BOOST_TEST(pi2? true: false);
639 BOOST_TEST(pi2.get() == p);
640 BOOST_TEST(pi2.use_count() == 2);
641 BOOST_TEST(!pi2.unique());
642 BOOST_TEST(*pi2 == 7);
643 BOOST_TEST(pi2.use_count() == pi.use_count());
644 BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
648 int * p = new int(7);
649 boost::shared_ptr<void> pv(p);
650 BOOST_TEST(pv.get() == p);
652 boost::shared_ptr<void> pv2(pv);
653 BOOST_TEST(pv2 == pv);
654 BOOST_TEST(pv2? true: false);
656 BOOST_TEST(pv2.get() == p);
657 BOOST_TEST(pv2.use_count() == 2);
658 BOOST_TEST(!pv2.unique());
659 BOOST_TEST(pv2.use_count() == pv.use_count());
660 BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
663 BOOST_TEST(X::instances == 0);
667 boost::shared_ptr<X> px(p);
668 BOOST_TEST(px.get() == p);
670 boost::shared_ptr<X> px2(px);
671 BOOST_TEST(px2 == px);
672 BOOST_TEST(px2? true: false);
674 BOOST_TEST(px2.get() == p);
675 BOOST_TEST(px2.use_count() == 2);
676 BOOST_TEST(!px2.unique());
678 BOOST_TEST(X::instances == 1);
680 BOOST_TEST(px2.use_count() == px.use_count());
681 BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
683 boost::shared_ptr<void> px3(px);
684 BOOST_TEST(px3 == px);
685 BOOST_TEST(px3? true: false);
687 BOOST_TEST(px3.get() == p);
688 BOOST_TEST(px3.use_count() == 3);
689 BOOST_TEST(!px3.unique());
690 BOOST_TEST(px3.use_count() == px.use_count());
691 BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
693 boost::shared_ptr<void> px4(px2);
694 BOOST_TEST(px4 == px2);
695 BOOST_TEST(px4? true: false);
697 BOOST_TEST(px4.get() == p);
698 BOOST_TEST(px4.use_count() == 4);
699 BOOST_TEST(!px4.unique());
700 BOOST_TEST(px4.use_count() == px2.use_count());
701 BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
703 BOOST_TEST(px3.use_count() == px4.use_count());
704 BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
707 BOOST_TEST(X::instances == 0);
708 BOOST_TEST(Y::instances == 0);
712 boost::shared_ptr<Y> py(p);
713 BOOST_TEST(py.get() == p);
715 boost::shared_ptr<X> px(py);
716 BOOST_TEST(px == py);
717 BOOST_TEST(px? true: false);
719 BOOST_TEST(px.get() == p);
720 BOOST_TEST(px.use_count() == 2);
721 BOOST_TEST(!px.unique());
722 BOOST_TEST(px.use_count() == py.use_count());
723 BOOST_TEST(!(px < py || py < px)); // shared ownership test
725 BOOST_TEST(X::instances == 1);
726 BOOST_TEST(Y::instances == 1);
728 boost::shared_ptr<void const> pv(px);
729 BOOST_TEST(pv == px);
730 BOOST_TEST(pv? true: false);
732 BOOST_TEST(pv.get() == px.get());
733 BOOST_TEST(pv.use_count() == 3);
734 BOOST_TEST(!pv.unique());
735 BOOST_TEST(pv.use_count() == px.use_count());
736 BOOST_TEST(!(px < pv || pv < px)); // shared ownership test
738 boost::shared_ptr<void const> pv2(py);
739 BOOST_TEST(pv2 == py);
740 BOOST_TEST(pv2? true: false);
742 BOOST_TEST(pv2.get() == py.get());
743 BOOST_TEST(pv2.use_count() == 4);
744 BOOST_TEST(!pv2.unique());
745 BOOST_TEST(pv2.use_count() == py.use_count());
746 BOOST_TEST(!(py < pv2 || pv2 < py)); // shared ownership test
748 BOOST_TEST(pv.use_count() == pv2.use_count());
749 BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
752 BOOST_TEST(X::instances == 0);
753 BOOST_TEST(Y::instances == 0);
756 void weak_ptr_constructor()
759 boost::weak_ptr<Y> wp;
760 BOOST_TEST(wp.use_count() == 0);
764 boost::shared_ptr<Y> p2(wp);
765 BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
767 catch(boost::bad_weak_ptr)
773 boost::shared_ptr<X> p3(wp);
774 BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
776 catch(boost::bad_weak_ptr)
782 boost::shared_ptr<Y> p;
783 boost::weak_ptr<Y> wp(p);
785 if(wp.use_count() != 0) // 0 allowed but not required
787 boost::shared_ptr<Y> p2(wp);
788 BOOST_TEST(p2.use_count() == wp.use_count());
789 BOOST_TEST(p2.get() == 0);
791 boost::shared_ptr<X> p3(wp);
792 BOOST_TEST(p3.use_count() == wp.use_count());
793 BOOST_TEST(p3.get() == 0);
798 boost::shared_ptr<Y> p(new Y);
799 boost::weak_ptr<Y> wp(p);
802 boost::shared_ptr<Y> p2(wp);
803 BOOST_TEST(p2? true: false);
805 BOOST_TEST(p2.get() == p.get());
806 BOOST_TEST(p2.use_count() == 2);
807 BOOST_TEST(!p2.unique());
808 BOOST_TEST(p2.use_count() == wp.use_count());
810 BOOST_TEST(p.use_count() == p2.use_count());
811 BOOST_TEST(!(p < p2 || p2 < p)); // shared ownership test
813 boost::shared_ptr<X> p3(wp);
814 BOOST_TEST(p3? true: false);
816 BOOST_TEST(p3.get() == p.get());
817 BOOST_TEST(p3.use_count() == 3);
818 BOOST_TEST(!p3.unique());
819 BOOST_TEST(p3.use_count() == wp.use_count());
821 BOOST_TEST(p.use_count() == p3.use_count());
825 BOOST_TEST(wp.use_count() == 0);
829 boost::shared_ptr<Y> p2(wp);
830 BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
832 catch(boost::bad_weak_ptr)
838 boost::shared_ptr<X> p3(wp);
839 BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
841 catch(boost::bad_weak_ptr)
847 #if defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB < 306)
848 # define BOOST_OLD_AUTO_PTR
851 void auto_ptr_constructor()
854 std::auto_ptr<int> p;
855 boost::shared_ptr<int> pi(p);
856 BOOST_TEST(pi? false: true);
858 BOOST_TEST(pi.get() == 0);
859 BOOST_TEST(pi.use_count() == 1);
860 BOOST_TEST(pi.unique());
861 BOOST_TEST(p.get() == 0);
865 std::auto_ptr<int> p;
866 boost::shared_ptr<int const> pi(p);
867 BOOST_TEST(pi? false: true);
869 BOOST_TEST(pi.get() == 0);
870 BOOST_TEST(pi.use_count() == 1);
871 BOOST_TEST(pi.unique());
872 BOOST_TEST(p.get() == 0);
876 std::auto_ptr<int> p;
877 boost::shared_ptr<void> pv(p);
878 BOOST_TEST(pv? false: true);
880 BOOST_TEST(pv.get() == 0);
881 BOOST_TEST(pv.use_count() == 1);
882 BOOST_TEST(pv.unique());
883 BOOST_TEST(p.get() == 0);
887 std::auto_ptr<int> p;
888 boost::shared_ptr<void const> pv(p);
889 BOOST_TEST(pv? false: true);
891 BOOST_TEST(pv.get() == 0);
892 BOOST_TEST(pv.use_count() == 1);
893 BOOST_TEST(pv.unique());
894 BOOST_TEST(p.get() == 0);
899 boost::shared_ptr<X> px(p);
900 BOOST_TEST(px? false: true);
902 BOOST_TEST(px.get() == 0);
903 BOOST_TEST(px.use_count() == 1);
904 BOOST_TEST(px.unique());
905 BOOST_TEST(p.get() == 0);
910 boost::shared_ptr<X const> px(p);
911 BOOST_TEST(px? false: true);
913 BOOST_TEST(px.get() == 0);
914 BOOST_TEST(px.use_count() == 1);
915 BOOST_TEST(px.unique());
916 BOOST_TEST(p.get() == 0);
921 boost::shared_ptr<X> px(p);
922 BOOST_TEST(px? false: true);
924 BOOST_TEST(px.get() == 0);
925 BOOST_TEST(px.use_count() == 1);
926 BOOST_TEST(px.unique());
927 BOOST_TEST(p.get() == 0);
932 boost::shared_ptr<X const> px(p);
933 BOOST_TEST(px? false: true);
935 BOOST_TEST(px.get() == 0);
936 BOOST_TEST(px.use_count() == 1);
937 BOOST_TEST(px.unique());
938 BOOST_TEST(p.get() == 0);
943 boost::shared_ptr<void> pv(p);
944 BOOST_TEST(pv? false: true);
946 BOOST_TEST(pv.get() == 0);
947 BOOST_TEST(pv.use_count() == 1);
948 BOOST_TEST(pv.unique());
949 BOOST_TEST(p.get() == 0);
954 boost::shared_ptr<void const> pv(p);
955 BOOST_TEST(pv? false: true);
957 BOOST_TEST(pv.get() == 0);
958 BOOST_TEST(pv.use_count() == 1);
959 BOOST_TEST(pv.unique());
960 BOOST_TEST(p.get() == 0);
964 std::auto_ptr<int> p(new int(7));
966 boost::shared_ptr<int> pi(p);
967 BOOST_TEST(pi? true: false);
969 BOOST_TEST(pi.get() == q);
970 BOOST_TEST(pi.use_count() == 1);
971 BOOST_TEST(pi.unique());
972 BOOST_TEST(*pi == 7);
974 #if !defined(BOOST_OLD_AUTO_PTR)
975 BOOST_TEST(p.get() == 0);
980 std::auto_ptr<int> p(new int(7));
982 boost::shared_ptr<int const> pi(p);
983 BOOST_TEST(pi? true: false);
985 BOOST_TEST(pi.get() == q);
986 BOOST_TEST(pi.use_count() == 1);
987 BOOST_TEST(pi.unique());
988 BOOST_TEST(*pi == 7);
990 #if !defined(BOOST_OLD_AUTO_PTR)
991 BOOST_TEST(p.get() == 0);
996 std::auto_ptr<int> p(new int(7));
998 boost::shared_ptr<void> pv(p);
999 BOOST_TEST(pv? true: false);
1001 BOOST_TEST(pv.get() == q);
1002 BOOST_TEST(pv.use_count() == 1);
1003 BOOST_TEST(pv.unique());
1005 #if !defined(BOOST_OLD_AUTO_PTR)
1006 BOOST_TEST(p.get() == 0);
1011 std::auto_ptr<int> p(new int(7));
1013 boost::shared_ptr<void const> pv(p);
1014 BOOST_TEST(pv? true: false);
1016 BOOST_TEST(pv.get() == q);
1017 BOOST_TEST(pv.use_count() == 1);
1018 BOOST_TEST(pv.unique());
1020 #if !defined(BOOST_OLD_AUTO_PTR)
1021 BOOST_TEST(p.get() == 0);
1025 BOOST_TEST(X::instances == 0);
1028 std::auto_ptr<X> p(new X);
1030 boost::shared_ptr<X> px(p);
1031 BOOST_TEST(px? true: false);
1033 BOOST_TEST(px.get() == q);
1034 BOOST_TEST(px.use_count() == 1);
1035 BOOST_TEST(px.unique());
1036 BOOST_TEST(X::instances == 1);
1038 #if !defined(BOOST_OLD_AUTO_PTR)
1039 BOOST_TEST(p.get() == 0);
1043 BOOST_TEST(X::instances == 0);
1046 std::auto_ptr<X> p(new X);
1048 boost::shared_ptr<X const> px(p);
1049 BOOST_TEST(px? true: false);
1051 BOOST_TEST(px.get() == q);
1052 BOOST_TEST(px.use_count() == 1);
1053 BOOST_TEST(px.unique());
1054 BOOST_TEST(X::instances == 1);
1056 #if !defined(BOOST_OLD_AUTO_PTR)
1057 BOOST_TEST(p.get() == 0);
1061 BOOST_TEST(X::instances == 0);
1064 std::auto_ptr<X> p(new X);
1066 boost::shared_ptr<void> pv(p);
1067 BOOST_TEST(pv? true: false);
1069 BOOST_TEST(pv.get() == q);
1070 BOOST_TEST(pv.use_count() == 1);
1071 BOOST_TEST(pv.unique());
1072 BOOST_TEST(X::instances == 1);
1074 #if !defined(BOOST_OLD_AUTO_PTR)
1075 BOOST_TEST(p.get() == 0);
1079 BOOST_TEST(X::instances == 0);
1082 std::auto_ptr<X> p(new X);
1084 boost::shared_ptr<void const> pv(p);
1085 BOOST_TEST(pv? true: false);
1087 BOOST_TEST(pv.get() == q);
1088 BOOST_TEST(pv.use_count() == 1);
1089 BOOST_TEST(pv.unique());
1090 BOOST_TEST(X::instances == 1);
1092 #if !defined(BOOST_OLD_AUTO_PTR)
1093 BOOST_TEST(p.get() == 0);
1097 BOOST_TEST(X::instances == 0);
1098 BOOST_TEST(Y::instances == 0);
1101 std::auto_ptr<Y> p(new Y);
1103 boost::shared_ptr<X> px(p);
1104 BOOST_TEST(px? true: false);
1106 BOOST_TEST(px.get() == q);
1107 BOOST_TEST(px.use_count() == 1);
1108 BOOST_TEST(px.unique());
1109 BOOST_TEST(X::instances == 1);
1110 BOOST_TEST(Y::instances == 1);
1112 #if !defined(BOOST_OLD_AUTO_PTR)
1113 BOOST_TEST(p.get() == 0);
1117 BOOST_TEST(X::instances == 0);
1118 BOOST_TEST(Y::instances == 0);
1121 std::auto_ptr<Y> p(new Y);
1123 boost::shared_ptr<X const> px(p);
1124 BOOST_TEST(px? true: false);
1126 BOOST_TEST(px.get() == q);
1127 BOOST_TEST(px.use_count() == 1);
1128 BOOST_TEST(px.unique());
1129 BOOST_TEST(X::instances == 1);
1130 BOOST_TEST(Y::instances == 1);
1132 #if !defined(BOOST_OLD_AUTO_PTR)
1133 BOOST_TEST(p.get() == 0);
1137 BOOST_TEST(X::instances == 0);
1138 BOOST_TEST(Y::instances == 0);
1143 default_constructor();
1144 pointer_constructor();
1145 deleter_constructor();
1147 weak_ptr_constructor();
1148 auto_ptr_constructor();
1151 } // namespace n_constructors
1153 namespace n_assignment
1165 static long instances;
1180 X & operator= (X const &);
1183 long X::instances = 0;
1185 struct Y: public A, public virtual X
1187 static long instances;
1202 Y & operator= (Y const &);
1205 long Y::instances = 0;
1207 void copy_assignment()
1210 boost::shared_ptr<incomplete> p1;
1214 BOOST_TEST(p1 == p1);
1215 BOOST_TEST(p1? false: true);
1217 BOOST_TEST(p1.get() == 0);
1219 boost::shared_ptr<incomplete> p2;
1223 BOOST_TEST(p1 == p2);
1224 BOOST_TEST(p1? false: true);
1226 BOOST_TEST(p1.get() == 0);
1228 boost::shared_ptr<incomplete> p3(p1);
1232 BOOST_TEST(p1 == p3);
1233 BOOST_TEST(p1? false: true);
1235 BOOST_TEST(p1.get() == 0);
1239 boost::shared_ptr<void> p1;
1243 BOOST_TEST(p1 == p1);
1244 BOOST_TEST(p1? false: true);
1246 BOOST_TEST(p1.get() == 0);
1248 boost::shared_ptr<void> p2;
1252 BOOST_TEST(p1 == p2);
1253 BOOST_TEST(p1? false: true);
1255 BOOST_TEST(p1.get() == 0);
1257 boost::shared_ptr<void> p3(p1);
1261 BOOST_TEST(p1 == p3);
1262 BOOST_TEST(p1? false: true);
1264 BOOST_TEST(p1.get() == 0);
1266 boost::shared_ptr<void> p4(new int);
1267 BOOST_TEST(p4.use_count() == 1);
1271 BOOST_TEST(p1 == p4);
1272 BOOST_TEST(!(p1 < p4 || p4 < p1));
1273 BOOST_TEST(p1.use_count() == 2);
1274 BOOST_TEST(p4.use_count() == 2);
1278 BOOST_TEST(p1 == p3);
1279 BOOST_TEST(p4.use_count() == 1);
1283 boost::shared_ptr<X> p1;
1287 BOOST_TEST(p1 == p1);
1288 BOOST_TEST(p1? false: true);
1290 BOOST_TEST(p1.get() == 0);
1292 boost::shared_ptr<X> p2;
1296 BOOST_TEST(p1 == p2);
1297 BOOST_TEST(p1? false: true);
1299 BOOST_TEST(p1.get() == 0);
1301 boost::shared_ptr<X> p3(p1);
1305 BOOST_TEST(p1 == p3);
1306 BOOST_TEST(p1? false: true);
1308 BOOST_TEST(p1.get() == 0);
1310 BOOST_TEST(X::instances == 0);
1312 boost::shared_ptr<X> p4(new X);
1314 BOOST_TEST(X::instances == 1);
1318 BOOST_TEST(X::instances == 1);
1320 BOOST_TEST(p1 == p4);
1321 BOOST_TEST(!(p1 < p4 || p4 < p1));
1323 BOOST_TEST(p1.use_count() == 2);
1327 BOOST_TEST(p1 == p2);
1328 BOOST_TEST(X::instances == 1);
1332 BOOST_TEST(p4 == p3);
1333 BOOST_TEST(X::instances == 0);
1337 void conversion_assignment()
1340 boost::shared_ptr<void> p1;
1342 boost::shared_ptr<incomplete> p2;
1346 BOOST_TEST(p1 == p2);
1347 BOOST_TEST(p1? false: true);
1349 BOOST_TEST(p1.get() == 0);
1351 boost::shared_ptr<int> p4(new int);
1352 BOOST_TEST(p4.use_count() == 1);
1354 boost::shared_ptr<void> p5(p4);
1355 BOOST_TEST(p4.use_count() == 2);
1359 BOOST_TEST(p1 == p4);
1360 BOOST_TEST(!(p1 < p5 || p5 < p1));
1361 BOOST_TEST(p1.use_count() == 3);
1362 BOOST_TEST(p4.use_count() == 3);
1366 BOOST_TEST(p1 == p2);
1367 BOOST_TEST(p4.use_count() == 2);
1371 boost::shared_ptr<X> p1;
1373 boost::shared_ptr<Y> p2;
1377 BOOST_TEST(p1 == p2);
1378 BOOST_TEST(p1? false: true);
1380 BOOST_TEST(p1.get() == 0);
1382 BOOST_TEST(X::instances == 0);
1383 BOOST_TEST(Y::instances == 0);
1385 boost::shared_ptr<Y> p4(new Y);
1387 BOOST_TEST(X::instances == 1);
1388 BOOST_TEST(Y::instances == 1);
1389 BOOST_TEST(p4.use_count() == 1);
1391 boost::shared_ptr<X> p5(p4);
1392 BOOST_TEST(p4.use_count() == 2);
1396 BOOST_TEST(X::instances == 1);
1397 BOOST_TEST(Y::instances == 1);
1399 BOOST_TEST(p1 == p4);
1400 BOOST_TEST(!(p1 < p5 || p5 < p1));
1402 BOOST_TEST(p1.use_count() == 3);
1403 BOOST_TEST(p4.use_count() == 3);
1407 BOOST_TEST(p1 == p2);
1408 BOOST_TEST(X::instances == 1);
1409 BOOST_TEST(Y::instances == 1);
1410 BOOST_TEST(p4.use_count() == 2);
1415 BOOST_TEST(p4 == p2);
1416 BOOST_TEST(X::instances == 0);
1417 BOOST_TEST(Y::instances == 0);
1421 void auto_ptr_assignment()
1424 boost::shared_ptr<int> p1;
1426 std::auto_ptr<int> p2;
1429 BOOST_TEST(p1? false: true);
1431 BOOST_TEST(p1.get() == 0);
1432 BOOST_TEST(p1.use_count() == 1);
1435 std::auto_ptr<int> p3(p);
1438 BOOST_TEST(p1.get() == p);
1439 BOOST_TEST(p1.use_count() == 1);
1441 #if !defined(BOOST_OLD_AUTO_PTR)
1442 BOOST_TEST(p3.get() == 0);
1446 BOOST_TEST(p1? false: true);
1448 BOOST_TEST(p1.get() == 0);
1449 BOOST_TEST(p1.use_count() == 1);
1453 boost::shared_ptr<void> p1;
1455 std::auto_ptr<int> p2;
1458 BOOST_TEST(p1? false: true);
1460 BOOST_TEST(p1.get() == 0);
1461 BOOST_TEST(p1.use_count() == 1);
1464 std::auto_ptr<int> p3(p);
1467 BOOST_TEST(p1.get() == p);
1468 BOOST_TEST(p1.use_count() == 1);
1470 #if !defined(BOOST_OLD_AUTO_PTR)
1471 BOOST_TEST(p3.get() == 0);
1475 BOOST_TEST(p1? false: true);
1477 BOOST_TEST(p1.get() == 0);
1478 BOOST_TEST(p1.use_count() == 1);
1483 boost::shared_ptr<X> p1;
1485 std::auto_ptr<Y> p2;
1488 BOOST_TEST(p1? false: true);
1490 BOOST_TEST(p1.get() == 0);
1491 BOOST_TEST(p1.use_count() == 1);
1492 BOOST_TEST(X::instances == 0);
1493 BOOST_TEST(Y::instances == 0);
1496 std::auto_ptr<Y> p3(p);
1498 BOOST_TEST(X::instances == 1);
1499 BOOST_TEST(Y::instances == 1);
1502 BOOST_TEST(p1.get() == p);
1503 BOOST_TEST(p1.use_count() == 1);
1504 BOOST_TEST(X::instances == 1);
1505 BOOST_TEST(Y::instances == 1);
1507 #if !defined(BOOST_OLD_AUTO_PTR)
1508 BOOST_TEST(p3.get() == 0);
1512 BOOST_TEST(p1? false: true);
1514 BOOST_TEST(p1.get() == 0);
1515 BOOST_TEST(p1.use_count() == 1);
1516 BOOST_TEST(X::instances == 0);
1517 BOOST_TEST(Y::instances == 0);
1524 conversion_assignment();
1525 auto_ptr_assignment();
1528 } // namespace n_assignment
1535 incomplete * p0 = 0;
1537 void deleter(incomplete *)
1543 static long instances;
1558 X & operator= (X const &);
1561 long X::instances = 0;
1566 boost::shared_ptr<int> pi;
1568 BOOST_TEST(pi? false: true);
1570 BOOST_TEST(pi.get() == 0);
1571 BOOST_TEST(pi.use_count() == 0);
1575 boost::shared_ptr<int> pi(static_cast<int*>(0));
1577 BOOST_TEST(pi? false: true);
1579 BOOST_TEST(pi.get() == 0);
1580 BOOST_TEST(pi.use_count() == 0);
1584 boost::shared_ptr<int> pi(new int);
1586 BOOST_TEST(pi? false: true);
1588 BOOST_TEST(pi.get() == 0);
1589 BOOST_TEST(pi.use_count() == 0);
1593 boost::shared_ptr<incomplete> px;
1595 BOOST_TEST(px? false: true);
1597 BOOST_TEST(px.get() == 0);
1598 BOOST_TEST(px.use_count() == 0);
1602 boost::shared_ptr<incomplete> px(p0, deleter);
1604 BOOST_TEST(px? false: true);
1606 BOOST_TEST(px.get() == 0);
1607 BOOST_TEST(px.use_count() == 0);
1611 boost::shared_ptr<X> px;
1613 BOOST_TEST(px? false: true);
1615 BOOST_TEST(px.get() == 0);
1616 BOOST_TEST(px.use_count() == 0);
1620 BOOST_TEST(X::instances == 0);
1621 boost::shared_ptr<X> px(new X);
1622 BOOST_TEST(X::instances == 1);
1624 BOOST_TEST(px? false: true);
1626 BOOST_TEST(px.get() == 0);
1627 BOOST_TEST(px.use_count() == 0);
1628 BOOST_TEST(X::instances == 0);
1632 boost::shared_ptr<void> pv;
1634 BOOST_TEST(pv? false: true);
1636 BOOST_TEST(pv.get() == 0);
1637 BOOST_TEST(pv.use_count() == 0);
1641 BOOST_TEST(X::instances == 0);
1642 boost::shared_ptr<void> pv(new X);
1643 BOOST_TEST(X::instances == 1);
1645 BOOST_TEST(pv? false: true);
1647 BOOST_TEST(pv.get() == 0);
1648 BOOST_TEST(pv.use_count() == 0);
1649 BOOST_TEST(X::instances == 0);
1658 struct Y: public A, public virtual X
1660 static long instances;
1675 Y & operator= (Y const &);
1678 long Y::instances = 0;
1680 void pointer_reset()
1683 boost::shared_ptr<int> pi;
1685 pi.reset(static_cast<int*>(0));
1686 BOOST_TEST(pi? false: true);
1688 BOOST_TEST(pi.get() == 0);
1689 BOOST_TEST(pi.use_count() == 1);
1690 BOOST_TEST(pi.unique());
1694 BOOST_TEST(pi? true: false);
1696 BOOST_TEST(pi.get() == p);
1697 BOOST_TEST(pi.use_count() == 1);
1698 BOOST_TEST(pi.unique());
1700 pi.reset(static_cast<int*>(0));
1701 BOOST_TEST(pi? false: true);
1703 BOOST_TEST(pi.get() == 0);
1704 BOOST_TEST(pi.use_count() == 1);
1705 BOOST_TEST(pi.unique());
1709 boost::shared_ptr<X> px;
1711 px.reset(static_cast<X*>(0));
1712 BOOST_TEST(px? false: true);
1714 BOOST_TEST(px.get() == 0);
1715 BOOST_TEST(px.use_count() == 1);
1716 BOOST_TEST(px.unique());
1717 BOOST_TEST(X::instances == 0);
1721 BOOST_TEST(px? true: false);
1723 BOOST_TEST(px.get() == p);
1724 BOOST_TEST(px.use_count() == 1);
1725 BOOST_TEST(px.unique());
1726 BOOST_TEST(X::instances == 1);
1728 px.reset(static_cast<X*>(0));
1729 BOOST_TEST(px? false: true);
1731 BOOST_TEST(px.get() == 0);
1732 BOOST_TEST(px.use_count() == 1);
1733 BOOST_TEST(px.unique());
1734 BOOST_TEST(X::instances == 0);
1735 BOOST_TEST(Y::instances == 0);
1739 BOOST_TEST(px? true: false);
1741 BOOST_TEST(px.get() == q);
1742 BOOST_TEST(px.use_count() == 1);
1743 BOOST_TEST(px.unique());
1744 BOOST_TEST(X::instances == 1);
1745 BOOST_TEST(Y::instances == 1);
1747 px.reset(static_cast<Y*>(0));
1748 BOOST_TEST(px? false: true);
1750 BOOST_TEST(px.get() == 0);
1751 BOOST_TEST(px.use_count() == 1);
1752 BOOST_TEST(px.unique());
1753 BOOST_TEST(X::instances == 0);
1754 BOOST_TEST(Y::instances == 0);
1758 boost::shared_ptr<void> pv;
1760 pv.reset(static_cast<X*>(0));
1761 BOOST_TEST(pv? false: true);
1763 BOOST_TEST(pv.get() == 0);
1764 BOOST_TEST(pv.use_count() == 1);
1765 BOOST_TEST(pv.unique());
1766 BOOST_TEST(X::instances == 0);
1770 BOOST_TEST(pv? true: false);
1772 BOOST_TEST(pv.get() == p);
1773 BOOST_TEST(pv.use_count() == 1);
1774 BOOST_TEST(pv.unique());
1775 BOOST_TEST(X::instances == 1);
1777 pv.reset(static_cast<X*>(0));
1778 BOOST_TEST(pv? false: true);
1780 BOOST_TEST(pv.get() == 0);
1781 BOOST_TEST(pv.use_count() == 1);
1782 BOOST_TEST(pv.unique());
1783 BOOST_TEST(X::instances == 0);
1784 BOOST_TEST(Y::instances == 0);
1788 BOOST_TEST(pv? true: false);
1790 BOOST_TEST(pv.get() == q);
1791 BOOST_TEST(pv.use_count() == 1);
1792 BOOST_TEST(pv.unique());
1793 BOOST_TEST(X::instances == 1);
1794 BOOST_TEST(Y::instances == 1);
1796 pv.reset(static_cast<Y*>(0));
1797 BOOST_TEST(pv? false: true);
1799 BOOST_TEST(pv.get() == 0);
1800 BOOST_TEST(pv.use_count() == 1);
1801 BOOST_TEST(pv.unique());
1802 BOOST_TEST(X::instances == 0);
1803 BOOST_TEST(Y::instances == 0);
1809 void deleter2(void * p)
1814 void deleter_reset()
1817 boost::shared_ptr<int> pi;
1819 pi.reset(static_cast<int*>(0), deleter2);
1820 BOOST_TEST(pi? false: true);
1822 BOOST_TEST(pi.get() == 0);
1823 BOOST_TEST(pi.use_count() == 1);
1824 BOOST_TEST(pi.unique());
1829 pi.reset(&m, deleter2);
1830 BOOST_TEST(deleted == 0);
1831 BOOST_TEST(pi? true: false);
1833 BOOST_TEST(pi.get() == &m);
1834 BOOST_TEST(pi.use_count() == 1);
1835 BOOST_TEST(pi.unique());
1837 pi.reset(static_cast<int*>(0), deleter2);
1838 BOOST_TEST(deleted == &m);
1839 BOOST_TEST(pi? false: true);
1841 BOOST_TEST(pi.get() == 0);
1842 BOOST_TEST(pi.use_count() == 1);
1843 BOOST_TEST(pi.unique());
1846 BOOST_TEST(deleted == 0);
1850 boost::shared_ptr<X> px;
1852 px.reset(static_cast<X*>(0), deleter2);
1853 BOOST_TEST(px? false: true);
1855 BOOST_TEST(px.get() == 0);
1856 BOOST_TEST(px.use_count() == 1);
1857 BOOST_TEST(px.unique());
1862 px.reset(&x, deleter2);
1863 BOOST_TEST(deleted == 0);
1864 BOOST_TEST(px? true: false);
1866 BOOST_TEST(px.get() == &x);
1867 BOOST_TEST(px.use_count() == 1);
1868 BOOST_TEST(px.unique());
1870 px.reset(static_cast<X*>(0), deleter2);
1871 BOOST_TEST(deleted == &x);
1872 BOOST_TEST(px? false: true);
1874 BOOST_TEST(px.get() == 0);
1875 BOOST_TEST(px.use_count() == 1);
1876 BOOST_TEST(px.unique());
1879 px.reset(&y, deleter2);
1880 BOOST_TEST(deleted == 0);
1881 BOOST_TEST(px? true: false);
1883 BOOST_TEST(px.get() == &y);
1884 BOOST_TEST(px.use_count() == 1);
1885 BOOST_TEST(px.unique());
1887 px.reset(static_cast<Y*>(0), deleter2);
1888 BOOST_TEST(deleted == &y);
1889 BOOST_TEST(px? false: true);
1891 BOOST_TEST(px.get() == 0);
1892 BOOST_TEST(px.use_count() == 1);
1893 BOOST_TEST(px.unique());
1896 BOOST_TEST(deleted == 0);
1900 boost::shared_ptr<void> pv;
1902 pv.reset(static_cast<X*>(0), deleter2);
1903 BOOST_TEST(pv? false: true);
1905 BOOST_TEST(pv.get() == 0);
1906 BOOST_TEST(pv.use_count() == 1);
1907 BOOST_TEST(pv.unique());
1912 pv.reset(&x, deleter2);
1913 BOOST_TEST(deleted == 0);
1914 BOOST_TEST(pv? true: false);
1916 BOOST_TEST(pv.get() == &x);
1917 BOOST_TEST(pv.use_count() == 1);
1918 BOOST_TEST(pv.unique());
1920 pv.reset(static_cast<X*>(0), deleter2);
1921 BOOST_TEST(deleted == &x);
1922 BOOST_TEST(pv? false: true);
1924 BOOST_TEST(pv.get() == 0);
1925 BOOST_TEST(pv.use_count() == 1);
1926 BOOST_TEST(pv.unique());
1929 pv.reset(&y, deleter2);
1930 BOOST_TEST(deleted == 0);
1931 BOOST_TEST(pv? true: false);
1933 BOOST_TEST(pv.get() == &y);
1934 BOOST_TEST(pv.use_count() == 1);
1935 BOOST_TEST(pv.unique());
1937 pv.reset(static_cast<Y*>(0), deleter2);
1938 BOOST_TEST(deleted == &y);
1939 BOOST_TEST(pv? false: true);
1941 BOOST_TEST(pv.get() == 0);
1942 BOOST_TEST(pv.use_count() == 1);
1943 BOOST_TEST(pv.unique());
1946 BOOST_TEST(deleted == 0);
1950 boost::shared_ptr<incomplete> px;
1952 px.reset(p0, deleter2);
1953 BOOST_TEST(px? false: true);
1955 BOOST_TEST(px.get() == 0);
1956 BOOST_TEST(px.use_count() == 1);
1957 BOOST_TEST(px.unique());
1960 px.reset(p0, deleter2);
1961 BOOST_TEST(deleted == 0);
1972 } // namespace n_reset
1984 boost::shared_ptr<X> px;
1985 BOOST_TEST(px.get() == 0);
1986 BOOST_TEST(px? false: true);
1989 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1990 using boost::get_pointer;
1993 BOOST_TEST(get_pointer(px) == px.get());
1997 boost::shared_ptr<X> px(static_cast<X*>(0));
1998 BOOST_TEST(px.get() == 0);
1999 BOOST_TEST(px? false: true);
2002 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2003 using boost::get_pointer;
2006 BOOST_TEST(get_pointer(px) == px.get());
2010 boost::shared_ptr<X> px(static_cast<X*>(0), boost::checked_deleter<X>());
2011 BOOST_TEST(px.get() == 0);
2012 BOOST_TEST(px? false: true);
2015 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2016 using boost::get_pointer;
2019 BOOST_TEST(get_pointer(px) == px.get());
2024 boost::shared_ptr<X> px(p);
2025 BOOST_TEST(px.get() == p);
2026 BOOST_TEST(px? true: false);
2028 BOOST_TEST(&*px == px.get());
2029 BOOST_TEST(px.operator ->() == px.get());
2031 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2032 using boost::get_pointer;
2035 BOOST_TEST(get_pointer(px) == px.get());
2040 boost::shared_ptr<X> px(p, boost::checked_deleter<X>());
2041 BOOST_TEST(px.get() == p);
2042 BOOST_TEST(px? true: false);
2044 BOOST_TEST(&*px == px.get());
2045 BOOST_TEST(px.operator ->() == px.get());
2047 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2048 using boost::get_pointer;
2051 BOOST_TEST(get_pointer(px) == px.get());
2055 } // namespace n_access
2057 namespace n_use_count
2067 boost::shared_ptr<X> px(static_cast<X*>(0));
2068 BOOST_TEST(px.use_count() == 1);
2069 BOOST_TEST(px.unique());
2071 boost::shared_ptr<X> px2(px);
2072 BOOST_TEST(px2.use_count() == 2);
2073 BOOST_TEST(!px2.unique());
2074 BOOST_TEST(px.use_count() == 2);
2075 BOOST_TEST(!px.unique());
2079 boost::shared_ptr<X> px(new X);
2080 BOOST_TEST(px.use_count() == 1);
2081 BOOST_TEST(px.unique());
2083 boost::shared_ptr<X> px2(px);
2084 BOOST_TEST(px2.use_count() == 2);
2085 BOOST_TEST(!px2.unique());
2086 BOOST_TEST(px.use_count() == 2);
2087 BOOST_TEST(!px.unique());
2091 boost::shared_ptr<X> px(new X, boost::checked_deleter<X>());
2092 BOOST_TEST(px.use_count() == 1);
2093 BOOST_TEST(px.unique());
2095 boost::shared_ptr<X> px2(px);
2096 BOOST_TEST(px2.use_count() == 2);
2097 BOOST_TEST(!px2.unique());
2098 BOOST_TEST(px.use_count() == 2);
2099 BOOST_TEST(!px.unique());
2103 } // namespace n_use_count
2115 boost::shared_ptr<X> px;
2116 boost::shared_ptr<X> px2;
2120 BOOST_TEST(px.get() == 0);
2121 BOOST_TEST(px2.get() == 0);
2126 BOOST_TEST(px.get() == 0);
2127 BOOST_TEST(px2.get() == 0);
2132 boost::shared_ptr<X> px;
2133 boost::shared_ptr<X> px2(p);
2134 boost::shared_ptr<X> px3(px2);
2138 BOOST_TEST(px.get() == p);
2139 BOOST_TEST(px.use_count() == 2);
2140 BOOST_TEST(px2.get() == 0);
2141 BOOST_TEST(px3.get() == p);
2142 BOOST_TEST(px3.use_count() == 2);
2147 BOOST_TEST(px.get() == 0);
2148 BOOST_TEST(px2.get() == p);
2149 BOOST_TEST(px2.use_count() == 2);
2150 BOOST_TEST(px3.get() == p);
2151 BOOST_TEST(px3.use_count() == 2);
2157 boost::shared_ptr<X> px(p1);
2158 boost::shared_ptr<X> px2(p2);
2159 boost::shared_ptr<X> px3(px2);
2163 BOOST_TEST(px.get() == p2);
2164 BOOST_TEST(px.use_count() == 2);
2165 BOOST_TEST(px2.get() == p1);
2166 BOOST_TEST(px2.use_count() == 1);
2167 BOOST_TEST(px3.get() == p2);
2168 BOOST_TEST(px3.use_count() == 2);
2173 BOOST_TEST(px.get() == p1);
2174 BOOST_TEST(px.use_count() == 1);
2175 BOOST_TEST(px2.get() == p2);
2176 BOOST_TEST(px2.use_count() == 2);
2177 BOOST_TEST(px3.get() == p2);
2178 BOOST_TEST(px3.use_count() == 2);
2182 } // namespace n_swap
2184 namespace n_comparison
2197 struct Z: public X, public virtual Y
2204 boost::shared_ptr<X> px;
2205 BOOST_TEST(px == px);
2206 BOOST_TEST(!(px != px));
2207 BOOST_TEST(!(px < px));
2209 boost::shared_ptr<X> px2;
2211 BOOST_TEST(px.get() == px2.get());
2212 BOOST_TEST(px == px2);
2213 BOOST_TEST(!(px != px2));
2214 BOOST_TEST(!(px < px2 && px2 < px));
2218 boost::shared_ptr<X> px;
2219 boost::shared_ptr<X> px2(px);
2221 BOOST_TEST(px2 == px2);
2222 BOOST_TEST(!(px2 != px2));
2223 BOOST_TEST(!(px2 < px2));
2225 BOOST_TEST(px.get() == px2.get());
2226 BOOST_TEST(px == px2);
2227 BOOST_TEST(!(px != px2));
2228 BOOST_TEST(!(px < px2 && px2 < px));
2232 boost::shared_ptr<X> px;
2233 boost::shared_ptr<X> px2(new X);
2235 BOOST_TEST(px2 == px2);
2236 BOOST_TEST(!(px2 != px2));
2237 BOOST_TEST(!(px2 < px2));
2239 BOOST_TEST(px.get() != px2.get());
2240 BOOST_TEST(px != px2);
2241 BOOST_TEST(!(px == px2));
2242 BOOST_TEST(px < px2 || px2 < px);
2243 BOOST_TEST(!(px < px2 && px2 < px));
2247 boost::shared_ptr<X> px(new X);
2248 boost::shared_ptr<X> px2(new X);
2250 BOOST_TEST(px.get() != px2.get());
2251 BOOST_TEST(px != px2);
2252 BOOST_TEST(!(px == px2));
2253 BOOST_TEST(px < px2 || px2 < px);
2254 BOOST_TEST(!(px < px2 && px2 < px));
2258 boost::shared_ptr<X> px(new X);
2259 boost::shared_ptr<X> px2(px);
2261 BOOST_TEST(px2 == px2);
2262 BOOST_TEST(!(px2 != px2));
2263 BOOST_TEST(!(px2 < px2));
2265 BOOST_TEST(px.get() == px2.get());
2266 BOOST_TEST(px == px2);
2267 BOOST_TEST(!(px != px2));
2268 BOOST_TEST(!(px < px2 || px2 < px));
2272 boost::shared_ptr<X> px(new X);
2273 boost::shared_ptr<Y> py(new Y);
2274 boost::shared_ptr<Z> pz(new Z);
2276 BOOST_TEST(px.get() != pz.get());
2277 BOOST_TEST(px != pz);
2278 BOOST_TEST(!(px == pz));
2280 BOOST_TEST(py.get() != pz.get());
2281 BOOST_TEST(py != pz);
2282 BOOST_TEST(!(py == pz));
2284 BOOST_TEST(px < py || py < px);
2285 BOOST_TEST(px < pz || pz < px);
2286 BOOST_TEST(py < pz || pz < py);
2288 BOOST_TEST(!(px < py && py < px));
2289 BOOST_TEST(!(px < pz && pz < px));
2290 BOOST_TEST(!(py < pz && pz < py));
2292 boost::shared_ptr<void> pvx(px);
2294 BOOST_TEST(pvx == pvx);
2295 BOOST_TEST(!(pvx != pvx));
2296 BOOST_TEST(!(pvx < pvx));
2298 boost::shared_ptr<void> pvy(py);
2299 boost::shared_ptr<void> pvz(pz);
2301 BOOST_TEST(pvx < pvy || pvy < pvx);
2302 BOOST_TEST(pvx < pvz || pvz < pvx);
2303 BOOST_TEST(pvy < pvz || pvz < pvy);
2305 BOOST_TEST(!(pvx < pvy && pvy < pvx));
2306 BOOST_TEST(!(pvx < pvz && pvz < pvx));
2307 BOOST_TEST(!(pvy < pvz && pvz < pvy));
2311 boost::shared_ptr<Z> pz(new Z);
2312 boost::shared_ptr<X> px(pz);
2314 BOOST_TEST(px == px);
2315 BOOST_TEST(!(px != px));
2316 BOOST_TEST(!(px < px));
2318 boost::shared_ptr<Y> py(pz);
2320 BOOST_TEST(px.get() == pz.get());
2321 BOOST_TEST(px == pz);
2322 BOOST_TEST(!(px != pz));
2324 BOOST_TEST(py.get() == pz.get());
2325 BOOST_TEST(py == pz);
2326 BOOST_TEST(!(py != pz));
2328 BOOST_TEST(!(px < py || py < px));
2329 BOOST_TEST(!(px < pz || pz < px));
2330 BOOST_TEST(!(py < pz || pz < py));
2332 boost::shared_ptr<void> pvx(px);
2333 boost::shared_ptr<void> pvy(py);
2334 boost::shared_ptr<void> pvz(pz);
2336 // pvx and pvy aren't equal...
2337 BOOST_TEST(pvx.get() != pvy.get());
2338 BOOST_TEST(pvx != pvy);
2339 BOOST_TEST(!(pvx == pvy));
2341 // ... but they share ownership ...
2342 BOOST_TEST(!(pvx < pvy || pvy < pvx));
2345 BOOST_TEST(!(pvx < pvz || pvz < pvx));
2346 BOOST_TEST(!(pvy < pvz || pvz < pvy));
2350 } // namespace n_comparison
2352 namespace n_static_cast
2366 boost::shared_ptr<void> pv;
2368 boost::shared_ptr<int> pi = boost::static_pointer_cast<int>(pv);
2369 BOOST_TEST(pi.get() == 0);
2371 boost::shared_ptr<X> px = boost::static_pointer_cast<X>(pv);
2372 BOOST_TEST(px.get() == 0);
2376 boost::shared_ptr<int> pi(new int);
2377 boost::shared_ptr<void> pv(pi);
2379 boost::shared_ptr<int> pi2 = boost::static_pointer_cast<int>(pv);
2380 BOOST_TEST(pi.get() == pi2.get());
2381 BOOST_TEST(!(pi < pi2 || pi2 < pi));
2382 BOOST_TEST(pi.use_count() == 3);
2383 BOOST_TEST(pv.use_count() == 3);
2384 BOOST_TEST(pi2.use_count() == 3);
2388 boost::shared_ptr<X> px(new X);
2389 boost::shared_ptr<void> pv(px);
2391 boost::shared_ptr<X> px2 = boost::static_pointer_cast<X>(pv);
2392 BOOST_TEST(px.get() == px2.get());
2393 BOOST_TEST(!(px < px2 || px2 < px));
2394 BOOST_TEST(px.use_count() == 3);
2395 BOOST_TEST(pv.use_count() == 3);
2396 BOOST_TEST(px2.use_count() == 3);
2400 boost::shared_ptr<X> px(new Y);
2402 boost::shared_ptr<Y> py = boost::static_pointer_cast<Y>(px);
2403 BOOST_TEST(px.get() == py.get());
2404 BOOST_TEST(px.use_count() == 2);
2405 BOOST_TEST(py.use_count() == 2);
2407 boost::shared_ptr<X> px2(py);
2408 BOOST_TEST(!(px < px2 || px2 < px));
2412 } // namespace n_static_cast
2414 namespace n_const_cast
2422 boost::shared_ptr<void const volatile> px;
2424 boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
2425 BOOST_TEST(px2.get() == 0);
2429 boost::shared_ptr<int const volatile> px;
2431 boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
2432 BOOST_TEST(px2.get() == 0);
2436 boost::shared_ptr<X const volatile> px;
2438 boost::shared_ptr<X> px2 = boost::const_pointer_cast<X>(px);
2439 BOOST_TEST(px2.get() == 0);
2443 boost::shared_ptr<void const volatile> px(new int);
2445 boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
2446 BOOST_TEST(px.get() == px2.get());
2447 BOOST_TEST(!(px < px2 || px2 < px));
2448 BOOST_TEST(px.use_count() == 2);
2449 BOOST_TEST(px2.use_count() == 2);
2453 boost::shared_ptr<int const volatile> px(new int);
2455 boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
2456 BOOST_TEST(px.get() == px2.get());
2457 BOOST_TEST(!(px < px2 || px2 < px));
2458 BOOST_TEST(px.use_count() == 2);
2459 BOOST_TEST(px2.use_count() == 2);
2463 } // namespace n_const_cast
2465 #if !defined( BOOST_NO_RTTI )
2467 namespace n_dynamic_cast
2482 boost::shared_ptr<V> pv;
2483 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2484 BOOST_TEST(pw.get() == 0);
2488 boost::shared_ptr<V> pv(static_cast<V*>(0));
2490 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2491 BOOST_TEST(pw.get() == 0);
2493 boost::shared_ptr<V> pv2(pw);
2494 BOOST_TEST(pv < pv2 || pv2 < pv);
2498 boost::shared_ptr<V> pv(static_cast<W*>(0));
2500 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2501 BOOST_TEST(pw.get() == 0);
2503 boost::shared_ptr<V> pv2(pw);
2504 BOOST_TEST(pv < pv2 || pv2 < pv);
2508 boost::shared_ptr<V> pv(new V);
2510 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2511 BOOST_TEST(pw.get() == 0);
2513 boost::shared_ptr<V> pv2(pw);
2514 BOOST_TEST(pv < pv2 || pv2 < pv);
2518 boost::shared_ptr<V> pv(new W);
2520 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2521 BOOST_TEST(pw.get() == pv.get());
2522 BOOST_TEST(pv.use_count() == 2);
2523 BOOST_TEST(pw.use_count() == 2);
2525 boost::shared_ptr<V> pv2(pw);
2526 BOOST_TEST(!(pv < pv2 || pv2 < pv));
2530 } // namespace n_dynamic_cast
2543 std::vector< boost::shared_ptr<int> > vi;
2546 boost::shared_ptr<int> pi1(new int);
2547 boost::shared_ptr<int> pi2(new int);
2548 boost::shared_ptr<int> pi3(new int);
2563 std::vector< boost::shared_ptr<X> > vx;
2566 boost::shared_ptr<X> px1(new X);
2567 boost::shared_ptr<X> px2(new X);
2568 boost::shared_ptr<X> px3(new X);
2583 std::map< boost::shared_ptr<void>, long > m;
2586 for(std::vector< boost::shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i)
2593 for(std::vector< boost::shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i)
2600 for(std::map< boost::shared_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
2602 BOOST_TEST(i->first.use_count() == i->second + 1);
2607 } // namespace n_map
2609 namespace n_transitive
2615 boost::shared_ptr<X> next;
2620 boost::shared_ptr<X> p(new X);
2621 p->next = boost::shared_ptr<X>(new X);
2622 BOOST_TEST(!p->next->next);
2624 BOOST_TEST(!p->next);
2627 } // namespace n_transitive
2629 namespace n_report_1
2647 boost::shared_ptr<foo> m_self;
2652 foo * foo_ptr = new foo;
2656 } // namespace n_report_1
2658 // Test case by Per Kristensen
2659 namespace n_report_2
2666 void setWeak(boost::shared_ptr<foo> s)
2673 boost::weak_ptr<foo> w;
2686 BOOST_TEST(lock == 0);
2689 void operator() (foo * p)
2703 boost::shared_ptr<foo> s(new foo, deleter());
2708 } // namespace n_report_2
2710 namespace n_spt_incomplete
2715 boost::shared_ptr<file> fopen(char const * name, char const * mode);
2716 void fread(boost::shared_ptr<file> f, void * data, long size);
2718 int file_instances = 0;
2722 BOOST_TEST(file_instances == 0);
2725 boost::shared_ptr<file> pf = fopen("name", "mode");
2726 BOOST_TEST(file_instances == 1);
2727 fread(pf, 0, 17041);
2730 BOOST_TEST(file_instances == 0);
2733 } // namespace n_spt_incomplete
2735 namespace n_spt_pimpl
2743 boost::shared_ptr<impl> pimpl_;
2747 file(char const * name, char const * mode);
2749 // compiler generated members are fine and useful
2751 void read(void * data, long size);
2753 long total_size() const;
2756 int file_instances = 0;
2760 BOOST_TEST(file_instances == 0);
2763 file f("name", "mode");
2764 BOOST_TEST(file_instances == 1);
2768 BOOST_TEST(file_instances == 1);
2771 BOOST_TEST(f.total_size() == 152+894);
2774 file f3("name2", "mode2");
2775 BOOST_TEST(file_instances == 2);
2778 BOOST_TEST(file_instances == 1);
2781 BOOST_TEST(file_instances == 0);
2784 } // namespace n_spt_pimpl
2786 namespace n_spt_abstract
2793 virtual void f(int) = 0;
2794 virtual int g() = 0;
2801 boost::shared_ptr<X> createX();
2803 int X_instances = 0;
2807 BOOST_TEST(X_instances == 0);
2810 boost::shared_ptr<X> px = createX();
2812 BOOST_TEST(X_instances == 1);
2817 BOOST_TEST(px->g() == 170);
2820 BOOST_TEST(X_instances == 0);
2823 } // namespace n_spt_abstract
2825 namespace n_spt_preventing_delete
2828 int X_instances = 0;
2845 friend class deleter;
2851 void operator()(X * p) { delete p; }
2856 static boost::shared_ptr<X> create()
2858 boost::shared_ptr<X> px(new X, X::deleter());
2865 BOOST_TEST(X_instances == 0);
2868 boost::shared_ptr<X> px = X::create();
2869 BOOST_TEST(X_instances == 1);
2872 BOOST_TEST(X_instances == 0);
2875 } // namespace n_spt_preventing_delete
2877 namespace n_spt_array
2880 int X_instances = 0;
2897 BOOST_TEST(X_instances == 0);
2900 boost::shared_ptr<X> px(new X[4], boost::checked_array_deleter<X>());
2901 BOOST_TEST(X_instances == 4);
2904 BOOST_TEST(X_instances == 0);
2907 } // namespace n_spt_array
2909 namespace n_spt_static
2922 void operator delete(void *)
2924 // Comeau 4.3.0.1 wants a definition
2925 BOOST_ERROR("n_spt_static::X::operator delete() called.");
2931 void operator()(void const *) const
2940 boost::shared_ptr<X> px(&x, null_deleter());
2943 } // namespace n_spt_static
2945 namespace n_spt_intrusive
2948 int X_instances = 0;
2965 void intrusive_ptr_add_ref(X * p)
2970 void intrusive_ptr_release(X * p)
2972 if(--p->count == 0) delete p;
2975 template<class T> struct intrusive_deleter
2977 void operator()(T * p)
2979 if(p != 0) intrusive_ptr_release(p);
2983 boost::shared_ptr<X> make_shared_from_intrusive(X * p)
2985 if(p != 0) intrusive_ptr_add_ref(p);
2986 boost::shared_ptr<X> px(p, intrusive_deleter<X>());
2992 BOOST_TEST(X_instances == 0);
2996 BOOST_TEST(X_instances == 1);
2997 BOOST_TEST(p->count == 0);
2998 boost::shared_ptr<X> px = make_shared_from_intrusive(p);
2999 BOOST_TEST(px.get() == p);
3000 BOOST_TEST(p->count == 1);
3001 boost::shared_ptr<X> px2(px);
3002 BOOST_TEST(px2.get() == p);
3003 BOOST_TEST(p->count == 1);
3006 BOOST_TEST(X_instances == 0);
3009 } // namespace n_spt_intrusive
3011 namespace n_spt_another_sp
3014 template<class T> class another_ptr: private boost::shared_ptr<T>
3018 typedef boost::shared_ptr<T> base_type;
3022 explicit another_ptr(T * p = 0): base_type(p)
3033 return base_type::get();
3041 virtual ~event_handler() {}
3042 virtual void begin() = 0;
3043 virtual void handle(int event) = 0;
3044 virtual void end() = 0;
3047 int begin_called = 0;
3048 int handle_called = 0;
3051 class event_handler_impl: public event_handler
3055 virtual void begin()
3060 virtual void handle(int event)
3062 handle_called = event;
3071 another_ptr<event_handler> get_event_handler()
3073 another_ptr<event_handler> p(new event_handler_impl);
3077 boost::shared_ptr<event_handler> current_handler;
3079 void install_event_handler(boost::shared_ptr<event_handler> p)
3082 current_handler = p;
3085 void handle_event(int event)
3087 current_handler->handle(event);
3090 void remove_event_handler()
3092 current_handler->end();
3093 current_handler.reset();
3096 template<class P> class smart_pointer_deleter
3104 smart_pointer_deleter(P const & p): p_(p)
3108 void operator()(void const *)
3116 another_ptr<event_handler> p = get_event_handler();
3118 boost::shared_ptr<event_handler> q(p.get(), smart_pointer_deleter< another_ptr<event_handler> >(p));
3122 BOOST_TEST(begin_called == 0);
3124 install_event_handler(q);
3126 BOOST_TEST(begin_called == 1);
3128 BOOST_TEST(handle_called == 0);
3130 handle_event(17041);
3132 BOOST_TEST(handle_called == 17041);
3134 BOOST_TEST(end_called == 0);
3136 remove_event_handler();
3138 BOOST_TEST(end_called == 1);
3141 } // namespace n_spt_another_sp
3143 namespace n_spt_shared_from_this
3150 virtual void f() = 0;
3161 virtual boost::shared_ptr<X> getX() = 0;
3168 class impl: public X, public Y
3172 boost::weak_ptr<impl> weak_this;
3175 impl & operator=(impl const &);
3181 static boost::shared_ptr<impl> create()
3183 boost::shared_ptr<impl> pi(new impl);
3190 virtual boost::shared_ptr<X> getX()
3192 boost::shared_ptr<X> px = weak_this.lock();
3199 boost::shared_ptr<Y> py = impl::create();
3200 BOOST_TEST(py.get() != 0);
3201 BOOST_TEST(py.use_count() == 1);
3203 boost::shared_ptr<X> px = py->getX();
3204 BOOST_TEST(px.get() != 0);
3205 BOOST_TEST(py.use_count() == 2);
3207 #if !defined( BOOST_NO_RTTI )
3208 boost::shared_ptr<Y> py2 = boost::dynamic_pointer_cast<Y>(px);
3209 BOOST_TEST(py.get() == py2.get());
3210 BOOST_TEST(!(py < py2 || py2 < py));
3211 BOOST_TEST(py.use_count() == 3);
3215 } // namespace n_spt_shared_from_this
3217 namespace n_spt_wrap
3224 } // namespace n_spt_wrap
3228 n_element_type::test();
3229 n_constructors::test();
3230 n_assignment::test();
3233 n_use_count::test();
3235 n_comparison::test();
3236 n_static_cast::test();
3237 n_const_cast::test();
3238 #if !defined( BOOST_NO_RTTI )
3239 n_dynamic_cast::test();
3244 n_transitive::test();
3248 n_spt_incomplete::test();
3249 n_spt_pimpl::test();
3250 n_spt_abstract::test();
3251 n_spt_preventing_delete::test();
3252 n_spt_array::test();
3253 n_spt_static::test();
3254 n_spt_intrusive::test();
3255 n_spt_another_sp::test();
3256 n_spt_shared_from_this::test();
3259 return boost::report_errors();
3262 namespace n_spt_incomplete
3269 file(): fread_called(false)
3276 BOOST_TEST(fread_called);
3283 boost::shared_ptr<file> fopen(char const *, char const *)
3285 boost::shared_ptr<file> pf(new file);
3289 void fread(boost::shared_ptr<file> pf, void *, long)
3291 pf->fread_called = true;
3294 } // namespace n_spt_incomplete
3296 namespace n_spt_pimpl
3304 impl & operator=(impl const &);
3310 impl(char const *, char const *): total_size_(0)
3320 void read(void *, long size)
3322 total_size_ += size;
3325 long total_size() const
3331 file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
3335 void file::read(void * data, long size)
3337 pimpl_->read(data, size);
3340 long file::total_size() const
3342 return pimpl_->total_size();
3345 } // namespace n_spt_pimpl
3347 namespace n_spt_abstract
3350 class X_impl: public X
3354 X_impl(X_impl const &);
3355 X_impl & operator=(X_impl const &);
3371 virtual void f(int n)
3382 boost::shared_ptr<X> createX()
3384 boost::shared_ptr<X> px(new X_impl);
3388 } // namespace n_spt_abstract