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
17 #if defined(__GNUC__) && __GNUC__ > 4
18 # pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
22 // shared_ptr_test.cpp
24 // Copyright (c) 2002, 2003 Peter Dimov
26 // Distributed under the Boost Software License, Version 1.0. (See
27 // accompanying file LICENSE_1_0.txt or copy at
28 // http://www.boost.org/LICENSE_1_0.txt)
31 #include <boost/detail/lightweight_test.hpp>
33 #include <boost/shared_ptr.hpp>
34 #include <boost/weak_ptr.hpp>
41 namespace n_element_type
50 typedef boost::shared_ptr<int>::element_type T;
55 } // namespace n_element_type
57 namespace n_constructors
62 void default_constructor()
65 boost::shared_ptr<int> pi;
66 BOOST_TEST(pi? false: true);
68 BOOST_TEST(pi.get() == 0);
69 BOOST_TEST(pi.use_count() == 0);
73 boost::shared_ptr<void> pv;
74 BOOST_TEST(pv? false: true);
76 BOOST_TEST(pv.get() == 0);
77 BOOST_TEST(pv.use_count() == 0);
81 boost::shared_ptr<incomplete> px;
82 BOOST_TEST(px? false: true);
84 BOOST_TEST(px.get() == 0);
85 BOOST_TEST(px.use_count() == 0);
96 static long instances;
111 X & operator= (X const &);
114 long X::instances = 0;
116 // virtual inheritance stresses the implementation
118 struct Y: public A, public virtual X
120 static long instances;
135 Y & operator= (Y const &);
138 long Y::instances = 0;
140 template<class T> void pc0_test(T * p)
143 boost::shared_ptr<T> pt(p);
144 BOOST_TEST(pt? false: true);
146 BOOST_TEST(pt.get() == 0);
147 BOOST_TEST(pt.use_count() == 1);
148 BOOST_TEST(pt.unique());
151 void pointer_constructor()
153 pc0_test(static_cast<int*>(0));
155 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
157 pc0_test(static_cast<int const*>(0));
158 pc0_test(static_cast<int volatile*>(0));
159 pc0_test(static_cast<int const volatile*>(0));
164 boost::shared_ptr<int const> pi(static_cast<int*>(0));
165 BOOST_TEST(pi? false: true);
167 BOOST_TEST(pi.get() == 0);
168 BOOST_TEST(pi.use_count() == 1);
169 BOOST_TEST(pi.unique());
173 boost::shared_ptr<int volatile> pi(static_cast<int*>(0));
174 BOOST_TEST(pi? false: true);
176 BOOST_TEST(pi.get() == 0);
177 BOOST_TEST(pi.use_count() == 1);
178 BOOST_TEST(pi.unique());
182 boost::shared_ptr<void> pv(static_cast<int*>(0));
183 BOOST_TEST(pv? false: true);
185 BOOST_TEST(pv.get() == 0);
186 BOOST_TEST(pv.use_count() == 1);
187 BOOST_TEST(pv.unique());
191 boost::shared_ptr<void const> pv(static_cast<int*>(0));
192 BOOST_TEST(pv? false: true);
194 BOOST_TEST(pv.get() == 0);
195 BOOST_TEST(pv.use_count() == 1);
196 BOOST_TEST(pv.unique());
199 pc0_test(static_cast<X*>(0));
200 pc0_test(static_cast<X const*>(0));
201 pc0_test(static_cast<X volatile*>(0));
202 pc0_test(static_cast<X const volatile*>(0));
205 boost::shared_ptr<X const> px(static_cast<X*>(0));
206 BOOST_TEST(px? false: true);
208 BOOST_TEST(px.get() == 0);
209 BOOST_TEST(px.use_count() == 1);
210 BOOST_TEST(px.unique());
214 boost::shared_ptr<X> px(static_cast<Y*>(0));
215 BOOST_TEST(px? false: true);
217 BOOST_TEST(px.get() == 0);
218 BOOST_TEST(px.use_count() == 1);
219 BOOST_TEST(px.unique());
223 boost::shared_ptr<X const> px(static_cast<Y*>(0));
224 BOOST_TEST(px? false: true);
226 BOOST_TEST(px.get() == 0);
227 BOOST_TEST(px.use_count() == 1);
228 BOOST_TEST(px.unique());
232 boost::shared_ptr<void> pv(static_cast<X*>(0));
233 BOOST_TEST(pv? false: true);
235 BOOST_TEST(pv.get() == 0);
236 BOOST_TEST(pv.use_count() == 1);
237 BOOST_TEST(pv.unique());
241 boost::shared_ptr<void const> pv(static_cast<X*>(0));
242 BOOST_TEST(pv? false: true);
244 BOOST_TEST(pv.get() == 0);
245 BOOST_TEST(pv.use_count() == 1);
246 BOOST_TEST(pv.unique());
250 int * p = new int(7);
251 boost::shared_ptr<int> pi(p);
252 BOOST_TEST(pi? true: false);
254 BOOST_TEST(pi.get() == p);
255 BOOST_TEST(pi.use_count() == 1);
256 BOOST_TEST(pi.unique());
257 BOOST_TEST(*pi == 7);
261 int * p = new int(7);
262 boost::shared_ptr<int const> pi(p);
263 BOOST_TEST(pi? true: false);
265 BOOST_TEST(pi.get() == p);
266 BOOST_TEST(pi.use_count() == 1);
267 BOOST_TEST(pi.unique());
268 BOOST_TEST(*pi == 7);
272 int * p = new int(7);
273 boost::shared_ptr<void> pv(p);
274 BOOST_TEST(pv? true: false);
276 BOOST_TEST(pv.get() == p);
277 BOOST_TEST(pv.use_count() == 1);
278 BOOST_TEST(pv.unique());
282 int * p = new int(7);
283 boost::shared_ptr<void const> pv(p);
284 BOOST_TEST(pv? true: false);
286 BOOST_TEST(pv.get() == p);
287 BOOST_TEST(pv.use_count() == 1);
288 BOOST_TEST(pv.unique());
291 BOOST_TEST(X::instances == 0);
295 boost::shared_ptr<X> px(p);
296 BOOST_TEST(px? true: false);
298 BOOST_TEST(px.get() == p);
299 BOOST_TEST(px.use_count() == 1);
300 BOOST_TEST(px.unique());
301 BOOST_TEST(X::instances == 1);
304 BOOST_TEST(X::instances == 0);
308 boost::shared_ptr<X const> px(p);
309 BOOST_TEST(px? true: false);
311 BOOST_TEST(px.get() == p);
312 BOOST_TEST(px.use_count() == 1);
313 BOOST_TEST(px.unique());
314 BOOST_TEST(X::instances == 1);
317 BOOST_TEST(X::instances == 0);
321 boost::shared_ptr<void> pv(p);
322 BOOST_TEST(pv? true: false);
324 BOOST_TEST(pv.get() == p);
325 BOOST_TEST(pv.use_count() == 1);
326 BOOST_TEST(pv.unique());
327 BOOST_TEST(X::instances == 1);
330 BOOST_TEST(X::instances == 0);
334 boost::shared_ptr<void const> pv(p);
335 BOOST_TEST(pv? true: false);
337 BOOST_TEST(pv.get() == p);
338 BOOST_TEST(pv.use_count() == 1);
339 BOOST_TEST(pv.unique());
340 BOOST_TEST(X::instances == 1);
343 BOOST_TEST(X::instances == 0);
344 BOOST_TEST(Y::instances == 0);
348 boost::shared_ptr<X> px(p);
349 BOOST_TEST(px? true: false);
351 BOOST_TEST(px.get() == p);
352 BOOST_TEST(px.use_count() == 1);
353 BOOST_TEST(px.unique());
354 BOOST_TEST(X::instances == 1);
355 BOOST_TEST(Y::instances == 1);
358 BOOST_TEST(X::instances == 0);
359 BOOST_TEST(Y::instances == 0);
363 boost::shared_ptr<X const> px(p);
364 BOOST_TEST(px? true: false);
366 BOOST_TEST(px.get() == p);
367 BOOST_TEST(px.use_count() == 1);
368 BOOST_TEST(px.unique());
369 BOOST_TEST(X::instances == 1);
370 BOOST_TEST(Y::instances == 1);
373 BOOST_TEST(X::instances == 0);
374 BOOST_TEST(Y::instances == 0);
379 void deleter(int * p)
384 void deleter2(int * p)
392 void operator()(incomplete * p)
398 // Borland C++ 5.5.1 fails on static_cast<incomplete*>(0)
402 void deleter_constructor()
405 boost::shared_ptr<int> pi(static_cast<int*>(0), deleter);
406 BOOST_TEST(pi? false: true);
408 BOOST_TEST(pi.get() == 0);
409 BOOST_TEST(pi.use_count() == 1);
410 BOOST_TEST(pi.unique());
414 boost::shared_ptr<void> pv(static_cast<int*>(0), &deleter);
415 BOOST_TEST(pv? false: true);
417 BOOST_TEST(pv.get() == 0);
418 BOOST_TEST(pv.use_count() == 1);
419 BOOST_TEST(pv.unique());
423 boost::shared_ptr<void const> pv(static_cast<int*>(0), deleter);
424 BOOST_TEST(pv? false: true);
426 BOOST_TEST(pv.get() == 0);
427 BOOST_TEST(pv.use_count() == 1);
428 BOOST_TEST(pv.unique());
432 boost::shared_ptr<incomplete> px(p0, deleter3());
433 BOOST_TEST(px? false: true);
435 BOOST_TEST(px.get() == 0);
436 BOOST_TEST(px.use_count() == 1);
437 BOOST_TEST(px.unique());
441 boost::shared_ptr<void> pv(p0, deleter3());
442 BOOST_TEST(pv? false: true);
444 BOOST_TEST(pv.get() == 0);
445 BOOST_TEST(pv.use_count() == 1);
446 BOOST_TEST(pv.unique());
450 boost::shared_ptr<void const> pv(p0, deleter3());
451 BOOST_TEST(pv? false: true);
453 BOOST_TEST(pv.get() == 0);
454 BOOST_TEST(pv.use_count() == 1);
455 BOOST_TEST(pv.unique());
461 boost::shared_ptr<int> pi(&m, deleter2);
462 BOOST_TEST(pi? true: false);
464 BOOST_TEST(pi.get() == &m);
465 BOOST_TEST(pi.use_count() == 1);
466 BOOST_TEST(pi.unique());
472 boost::shared_ptr<int const> pi(&m, &deleter2);
473 BOOST_TEST(pi? true: false);
475 BOOST_TEST(pi.get() == &m);
476 BOOST_TEST(pi.use_count() == 1);
477 BOOST_TEST(pi.unique());
483 boost::shared_ptr<void> pv(&m, deleter2);
484 BOOST_TEST(pv? true: false);
486 BOOST_TEST(pv.get() == &m);
487 BOOST_TEST(pv.use_count() == 1);
488 BOOST_TEST(pv.unique());
494 boost::shared_ptr<void const> pv(&m, &deleter2);
495 BOOST_TEST(pv? true: false);
497 BOOST_TEST(pv.get() == &m);
498 BOOST_TEST(pv.use_count() == 1);
499 BOOST_TEST(pv.unique());
505 void copy_constructor()
508 boost::shared_ptr<int> pi;
510 boost::shared_ptr<int> pi2(pi);
511 BOOST_TEST(pi2 == pi);
512 BOOST_TEST(pi2? false: true);
514 BOOST_TEST(pi2.get() == 0);
515 BOOST_TEST(pi2.use_count() == pi.use_count());
517 boost::shared_ptr<void> pi3(pi);
518 BOOST_TEST(pi3 == pi);
519 BOOST_TEST(pi3? false: true);
521 BOOST_TEST(pi3.get() == 0);
522 BOOST_TEST(pi3.use_count() == pi.use_count());
524 boost::shared_ptr<void> pi4(pi3);
525 BOOST_TEST(pi4 == pi3);
526 BOOST_TEST(pi4? false: true);
528 BOOST_TEST(pi4.get() == 0);
529 BOOST_TEST(pi4.use_count() == pi3.use_count());
533 boost::shared_ptr<void> pv;
535 boost::shared_ptr<void> pv2(pv);
536 BOOST_TEST(pv2 == pv);
537 BOOST_TEST(pv2? false: true);
539 BOOST_TEST(pv2.get() == 0);
540 BOOST_TEST(pv2.use_count() == pv.use_count());
544 boost::shared_ptr<incomplete> px;
546 boost::shared_ptr<incomplete> px2(px);
547 BOOST_TEST(px2 == px);
548 BOOST_TEST(px2? false: true);
550 BOOST_TEST(px2.get() == 0);
551 BOOST_TEST(px2.use_count() == px.use_count());
553 boost::shared_ptr<void> px3(px);
554 BOOST_TEST(px3 == px);
555 BOOST_TEST(px3? false: true);
557 BOOST_TEST(px3.get() == 0);
558 BOOST_TEST(px3.use_count() == px.use_count());
562 boost::shared_ptr<int> pi(static_cast<int*>(0));
564 boost::shared_ptr<int> pi2(pi);
565 BOOST_TEST(pi2 == pi);
566 BOOST_TEST(pi2? false: true);
568 BOOST_TEST(pi2.get() == 0);
569 BOOST_TEST(pi2.use_count() == 2);
570 BOOST_TEST(!pi2.unique());
571 BOOST_TEST(pi2.use_count() == pi.use_count());
572 BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
574 boost::shared_ptr<void> pi3(pi);
575 BOOST_TEST(pi3 == pi);
576 BOOST_TEST(pi3? false: true);
578 BOOST_TEST(pi3.get() == 0);
579 BOOST_TEST(pi3.use_count() == 3);
580 BOOST_TEST(!pi3.unique());
581 BOOST_TEST(pi3.use_count() == pi.use_count());
582 BOOST_TEST(!(pi < pi3 || pi3 < pi)); // shared ownership test
584 boost::shared_ptr<void> pi4(pi2);
585 BOOST_TEST(pi4 == pi2);
586 BOOST_TEST(pi4? false: true);
588 BOOST_TEST(pi4.get() == 0);
589 BOOST_TEST(pi4.use_count() == 4);
590 BOOST_TEST(!pi4.unique());
591 BOOST_TEST(pi4.use_count() == pi2.use_count());
592 BOOST_TEST(!(pi2 < pi4 || pi4 < pi2)); // shared ownership test
594 BOOST_TEST(pi3.use_count() == pi4.use_count());
595 BOOST_TEST(!(pi3 < pi4 || pi4 < pi3)); // shared ownership test
599 boost::shared_ptr<X> px(static_cast<X*>(0));
601 boost::shared_ptr<X> px2(px);
602 BOOST_TEST(px2 == px);
603 BOOST_TEST(px2? false: true);
605 BOOST_TEST(px2.get() == 0);
606 BOOST_TEST(px2.use_count() == 2);
607 BOOST_TEST(!px2.unique());
608 BOOST_TEST(px2.use_count() == px.use_count());
609 BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
611 boost::shared_ptr<void> px3(px);
612 BOOST_TEST(px3 == px);
613 BOOST_TEST(px3? false: true);
615 BOOST_TEST(px3.get() == 0);
616 BOOST_TEST(px3.use_count() == 3);
617 BOOST_TEST(!px3.unique());
618 BOOST_TEST(px3.use_count() == px.use_count());
619 BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
621 boost::shared_ptr<void> px4(px2);
622 BOOST_TEST(px4 == px2);
623 BOOST_TEST(px4? false: true);
625 BOOST_TEST(px4.get() == 0);
626 BOOST_TEST(px4.use_count() == 4);
627 BOOST_TEST(!px4.unique());
628 BOOST_TEST(px4.use_count() == px2.use_count());
629 BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
631 BOOST_TEST(px3.use_count() == px4.use_count());
632 BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
636 int * p = new int(7);
637 boost::shared_ptr<int> pi(p);
639 boost::shared_ptr<int> pi2(pi);
640 BOOST_TEST(pi2 == pi);
641 BOOST_TEST(pi2? true: false);
643 BOOST_TEST(pi2.get() == p);
644 BOOST_TEST(pi2.use_count() == 2);
645 BOOST_TEST(!pi2.unique());
646 BOOST_TEST(*pi2 == 7);
647 BOOST_TEST(pi2.use_count() == pi.use_count());
648 BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
652 int * p = new int(7);
653 boost::shared_ptr<void> pv(p);
654 BOOST_TEST(pv.get() == p);
656 boost::shared_ptr<void> pv2(pv);
657 BOOST_TEST(pv2 == pv);
658 BOOST_TEST(pv2? true: false);
660 BOOST_TEST(pv2.get() == p);
661 BOOST_TEST(pv2.use_count() == 2);
662 BOOST_TEST(!pv2.unique());
663 BOOST_TEST(pv2.use_count() == pv.use_count());
664 BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
667 BOOST_TEST(X::instances == 0);
671 boost::shared_ptr<X> px(p);
672 BOOST_TEST(px.get() == p);
674 boost::shared_ptr<X> px2(px);
675 BOOST_TEST(px2 == px);
676 BOOST_TEST(px2? true: false);
678 BOOST_TEST(px2.get() == p);
679 BOOST_TEST(px2.use_count() == 2);
680 BOOST_TEST(!px2.unique());
682 BOOST_TEST(X::instances == 1);
684 BOOST_TEST(px2.use_count() == px.use_count());
685 BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
687 boost::shared_ptr<void> px3(px);
688 BOOST_TEST(px3 == px);
689 BOOST_TEST(px3? true: false);
691 BOOST_TEST(px3.get() == p);
692 BOOST_TEST(px3.use_count() == 3);
693 BOOST_TEST(!px3.unique());
694 BOOST_TEST(px3.use_count() == px.use_count());
695 BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
697 boost::shared_ptr<void> px4(px2);
698 BOOST_TEST(px4 == px2);
699 BOOST_TEST(px4? true: false);
701 BOOST_TEST(px4.get() == p);
702 BOOST_TEST(px4.use_count() == 4);
703 BOOST_TEST(!px4.unique());
704 BOOST_TEST(px4.use_count() == px2.use_count());
705 BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
707 BOOST_TEST(px3.use_count() == px4.use_count());
708 BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
711 BOOST_TEST(X::instances == 0);
712 BOOST_TEST(Y::instances == 0);
716 boost::shared_ptr<Y> py(p);
717 BOOST_TEST(py.get() == p);
719 boost::shared_ptr<X> px(py);
720 BOOST_TEST(px == py);
721 BOOST_TEST(px? true: false);
723 BOOST_TEST(px.get() == p);
724 BOOST_TEST(px.use_count() == 2);
725 BOOST_TEST(!px.unique());
726 BOOST_TEST(px.use_count() == py.use_count());
727 BOOST_TEST(!(px < py || py < px)); // shared ownership test
729 BOOST_TEST(X::instances == 1);
730 BOOST_TEST(Y::instances == 1);
732 boost::shared_ptr<void const> pv(px);
733 BOOST_TEST(pv == px);
734 BOOST_TEST(pv? true: false);
736 BOOST_TEST(pv.get() == px.get());
737 BOOST_TEST(pv.use_count() == 3);
738 BOOST_TEST(!pv.unique());
739 BOOST_TEST(pv.use_count() == px.use_count());
740 BOOST_TEST(!(px < pv || pv < px)); // shared ownership test
742 boost::shared_ptr<void const> pv2(py);
743 BOOST_TEST(pv2 == py);
744 BOOST_TEST(pv2? true: false);
746 BOOST_TEST(pv2.get() == py.get());
747 BOOST_TEST(pv2.use_count() == 4);
748 BOOST_TEST(!pv2.unique());
749 BOOST_TEST(pv2.use_count() == py.use_count());
750 BOOST_TEST(!(py < pv2 || pv2 < py)); // shared ownership test
752 BOOST_TEST(pv.use_count() == pv2.use_count());
753 BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
756 BOOST_TEST(X::instances == 0);
757 BOOST_TEST(Y::instances == 0);
760 void weak_ptr_constructor()
763 boost::weak_ptr<Y> wp;
764 BOOST_TEST(wp.use_count() == 0);
768 boost::shared_ptr<Y> p2(wp);
769 BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
771 catch(boost::bad_weak_ptr const&)
777 boost::shared_ptr<X> p3(wp);
778 BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
780 catch(boost::bad_weak_ptr const&)
786 boost::shared_ptr<Y> p;
787 boost::weak_ptr<Y> wp(p);
789 if(wp.use_count() != 0) // 0 allowed but not required
791 boost::shared_ptr<Y> p2(wp);
792 BOOST_TEST(p2.use_count() == wp.use_count());
793 BOOST_TEST(p2.get() == 0);
795 boost::shared_ptr<X> p3(wp);
796 BOOST_TEST(p3.use_count() == wp.use_count());
797 BOOST_TEST(p3.get() == 0);
802 boost::shared_ptr<Y> p(new Y);
803 boost::weak_ptr<Y> wp(p);
806 boost::shared_ptr<Y> p2(wp);
807 BOOST_TEST(p2? true: false);
809 BOOST_TEST(p2.get() == p.get());
810 BOOST_TEST(p2.use_count() == 2);
811 BOOST_TEST(!p2.unique());
812 BOOST_TEST(p2.use_count() == wp.use_count());
814 BOOST_TEST(p.use_count() == p2.use_count());
815 BOOST_TEST(!(p < p2 || p2 < p)); // shared ownership test
817 boost::shared_ptr<X> p3(wp);
818 BOOST_TEST(p3? true: false);
820 BOOST_TEST(p3.get() == p.get());
821 BOOST_TEST(p3.use_count() == 3);
822 BOOST_TEST(!p3.unique());
823 BOOST_TEST(p3.use_count() == wp.use_count());
825 BOOST_TEST(p.use_count() == p3.use_count());
829 BOOST_TEST(wp.use_count() == 0);
833 boost::shared_ptr<Y> p2(wp);
834 BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
836 catch(boost::bad_weak_ptr const&)
842 boost::shared_ptr<X> p3(wp);
843 BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
845 catch(boost::bad_weak_ptr const&)
851 #if defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB < 306)
852 # define BOOST_OLD_AUTO_PTR
855 void auto_ptr_constructor()
857 #if !defined( BOOST_NO_AUTO_PTR )
860 std::auto_ptr<int> p;
861 boost::shared_ptr<int> pi(p);
862 BOOST_TEST(pi? false: true);
864 BOOST_TEST(pi.get() == 0);
865 BOOST_TEST(pi.use_count() == 1);
866 BOOST_TEST(pi.unique());
867 BOOST_TEST(p.get() == 0);
871 std::auto_ptr<int> p;
872 boost::shared_ptr<int const> pi(p);
873 BOOST_TEST(pi? false: true);
875 BOOST_TEST(pi.get() == 0);
876 BOOST_TEST(pi.use_count() == 1);
877 BOOST_TEST(pi.unique());
878 BOOST_TEST(p.get() == 0);
882 std::auto_ptr<int> p;
883 boost::shared_ptr<void> pv(p);
884 BOOST_TEST(pv? false: true);
886 BOOST_TEST(pv.get() == 0);
887 BOOST_TEST(pv.use_count() == 1);
888 BOOST_TEST(pv.unique());
889 BOOST_TEST(p.get() == 0);
893 std::auto_ptr<int> p;
894 boost::shared_ptr<void const> pv(p);
895 BOOST_TEST(pv? false: true);
897 BOOST_TEST(pv.get() == 0);
898 BOOST_TEST(pv.use_count() == 1);
899 BOOST_TEST(pv.unique());
900 BOOST_TEST(p.get() == 0);
905 boost::shared_ptr<X> px(p);
906 BOOST_TEST(px? false: true);
908 BOOST_TEST(px.get() == 0);
909 BOOST_TEST(px.use_count() == 1);
910 BOOST_TEST(px.unique());
911 BOOST_TEST(p.get() == 0);
916 boost::shared_ptr<X const> px(p);
917 BOOST_TEST(px? false: true);
919 BOOST_TEST(px.get() == 0);
920 BOOST_TEST(px.use_count() == 1);
921 BOOST_TEST(px.unique());
922 BOOST_TEST(p.get() == 0);
927 boost::shared_ptr<X> px(p);
928 BOOST_TEST(px? false: true);
930 BOOST_TEST(px.get() == 0);
931 BOOST_TEST(px.use_count() == 1);
932 BOOST_TEST(px.unique());
933 BOOST_TEST(p.get() == 0);
938 boost::shared_ptr<X const> px(p);
939 BOOST_TEST(px? false: true);
941 BOOST_TEST(px.get() == 0);
942 BOOST_TEST(px.use_count() == 1);
943 BOOST_TEST(px.unique());
944 BOOST_TEST(p.get() == 0);
949 boost::shared_ptr<void> pv(p);
950 BOOST_TEST(pv? false: true);
952 BOOST_TEST(pv.get() == 0);
953 BOOST_TEST(pv.use_count() == 1);
954 BOOST_TEST(pv.unique());
955 BOOST_TEST(p.get() == 0);
960 boost::shared_ptr<void const> pv(p);
961 BOOST_TEST(pv? false: true);
963 BOOST_TEST(pv.get() == 0);
964 BOOST_TEST(pv.use_count() == 1);
965 BOOST_TEST(pv.unique());
966 BOOST_TEST(p.get() == 0);
970 std::auto_ptr<int> p(new int(7));
972 boost::shared_ptr<int> pi(p);
973 BOOST_TEST(pi? true: false);
975 BOOST_TEST(pi.get() == q);
976 BOOST_TEST(pi.use_count() == 1);
977 BOOST_TEST(pi.unique());
978 BOOST_TEST(*pi == 7);
980 #if !defined(BOOST_OLD_AUTO_PTR)
981 BOOST_TEST(p.get() == 0);
986 std::auto_ptr<int> p(new int(7));
988 boost::shared_ptr<int const> pi(p);
989 BOOST_TEST(pi? true: false);
991 BOOST_TEST(pi.get() == q);
992 BOOST_TEST(pi.use_count() == 1);
993 BOOST_TEST(pi.unique());
994 BOOST_TEST(*pi == 7);
996 #if !defined(BOOST_OLD_AUTO_PTR)
997 BOOST_TEST(p.get() == 0);
1002 std::auto_ptr<int> p(new int(7));
1004 boost::shared_ptr<void> pv(p);
1005 BOOST_TEST(pv? true: false);
1007 BOOST_TEST(pv.get() == q);
1008 BOOST_TEST(pv.use_count() == 1);
1009 BOOST_TEST(pv.unique());
1011 #if !defined(BOOST_OLD_AUTO_PTR)
1012 BOOST_TEST(p.get() == 0);
1017 std::auto_ptr<int> p(new int(7));
1019 boost::shared_ptr<void const> pv(p);
1020 BOOST_TEST(pv? true: false);
1022 BOOST_TEST(pv.get() == q);
1023 BOOST_TEST(pv.use_count() == 1);
1024 BOOST_TEST(pv.unique());
1026 #if !defined(BOOST_OLD_AUTO_PTR)
1027 BOOST_TEST(p.get() == 0);
1031 BOOST_TEST(X::instances == 0);
1034 std::auto_ptr<X> p(new X);
1036 boost::shared_ptr<X> px(p);
1037 BOOST_TEST(px? true: false);
1039 BOOST_TEST(px.get() == q);
1040 BOOST_TEST(px.use_count() == 1);
1041 BOOST_TEST(px.unique());
1042 BOOST_TEST(X::instances == 1);
1044 #if !defined(BOOST_OLD_AUTO_PTR)
1045 BOOST_TEST(p.get() == 0);
1049 BOOST_TEST(X::instances == 0);
1052 std::auto_ptr<X> p(new X);
1054 boost::shared_ptr<X const> px(p);
1055 BOOST_TEST(px? true: false);
1057 BOOST_TEST(px.get() == q);
1058 BOOST_TEST(px.use_count() == 1);
1059 BOOST_TEST(px.unique());
1060 BOOST_TEST(X::instances == 1);
1062 #if !defined(BOOST_OLD_AUTO_PTR)
1063 BOOST_TEST(p.get() == 0);
1067 BOOST_TEST(X::instances == 0);
1070 std::auto_ptr<X> p(new X);
1072 boost::shared_ptr<void> pv(p);
1073 BOOST_TEST(pv? true: false);
1075 BOOST_TEST(pv.get() == q);
1076 BOOST_TEST(pv.use_count() == 1);
1077 BOOST_TEST(pv.unique());
1078 BOOST_TEST(X::instances == 1);
1080 #if !defined(BOOST_OLD_AUTO_PTR)
1081 BOOST_TEST(p.get() == 0);
1085 BOOST_TEST(X::instances == 0);
1088 std::auto_ptr<X> p(new X);
1090 boost::shared_ptr<void const> pv(p);
1091 BOOST_TEST(pv? true: false);
1093 BOOST_TEST(pv.get() == q);
1094 BOOST_TEST(pv.use_count() == 1);
1095 BOOST_TEST(pv.unique());
1096 BOOST_TEST(X::instances == 1);
1098 #if !defined(BOOST_OLD_AUTO_PTR)
1099 BOOST_TEST(p.get() == 0);
1103 BOOST_TEST(X::instances == 0);
1104 BOOST_TEST(Y::instances == 0);
1107 std::auto_ptr<Y> p(new Y);
1109 boost::shared_ptr<X> px(p);
1110 BOOST_TEST(px? true: false);
1112 BOOST_TEST(px.get() == q);
1113 BOOST_TEST(px.use_count() == 1);
1114 BOOST_TEST(px.unique());
1115 BOOST_TEST(X::instances == 1);
1116 BOOST_TEST(Y::instances == 1);
1118 #if !defined(BOOST_OLD_AUTO_PTR)
1119 BOOST_TEST(p.get() == 0);
1123 BOOST_TEST(X::instances == 0);
1124 BOOST_TEST(Y::instances == 0);
1127 std::auto_ptr<Y> p(new Y);
1129 boost::shared_ptr<X const> px(p);
1130 BOOST_TEST(px? true: false);
1132 BOOST_TEST(px.get() == q);
1133 BOOST_TEST(px.use_count() == 1);
1134 BOOST_TEST(px.unique());
1135 BOOST_TEST(X::instances == 1);
1136 BOOST_TEST(Y::instances == 1);
1138 #if !defined(BOOST_OLD_AUTO_PTR)
1139 BOOST_TEST(p.get() == 0);
1143 BOOST_TEST(X::instances == 0);
1144 BOOST_TEST(Y::instances == 0);
1146 #endif // #if !defined( BOOST_NO_AUTO_PTR )
1151 default_constructor();
1152 pointer_constructor();
1153 deleter_constructor();
1155 weak_ptr_constructor();
1156 auto_ptr_constructor();
1159 } // namespace n_constructors
1161 namespace n_assignment
1173 static long instances;
1188 X & operator= (X const &);
1191 long X::instances = 0;
1193 struct Y: public A, public virtual X
1195 static long instances;
1210 Y & operator= (Y const &);
1213 long Y::instances = 0;
1215 void copy_assignment()
1218 boost::shared_ptr<incomplete> p1;
1222 BOOST_TEST(p1 == p1);
1223 BOOST_TEST(p1? false: true);
1225 BOOST_TEST(p1.get() == 0);
1227 boost::shared_ptr<incomplete> p2;
1231 BOOST_TEST(p1 == p2);
1232 BOOST_TEST(p1? false: true);
1234 BOOST_TEST(p1.get() == 0);
1236 boost::shared_ptr<incomplete> p3(p1);
1240 BOOST_TEST(p1 == p3);
1241 BOOST_TEST(p1? false: true);
1243 BOOST_TEST(p1.get() == 0);
1247 boost::shared_ptr<void> p1;
1251 BOOST_TEST(p1 == p1);
1252 BOOST_TEST(p1? false: true);
1254 BOOST_TEST(p1.get() == 0);
1256 boost::shared_ptr<void> p2;
1260 BOOST_TEST(p1 == p2);
1261 BOOST_TEST(p1? false: true);
1263 BOOST_TEST(p1.get() == 0);
1265 boost::shared_ptr<void> p3(p1);
1269 BOOST_TEST(p1 == p3);
1270 BOOST_TEST(p1? false: true);
1272 BOOST_TEST(p1.get() == 0);
1274 boost::shared_ptr<void> p4(new int);
1275 BOOST_TEST(p4.use_count() == 1);
1279 BOOST_TEST(p1 == p4);
1280 BOOST_TEST(!(p1 < p4 || p4 < p1));
1281 BOOST_TEST(p1.use_count() == 2);
1282 BOOST_TEST(p4.use_count() == 2);
1286 BOOST_TEST(p1 == p3);
1287 BOOST_TEST(p4.use_count() == 1);
1291 boost::shared_ptr<X> p1;
1295 BOOST_TEST(p1 == p1);
1296 BOOST_TEST(p1? false: true);
1298 BOOST_TEST(p1.get() == 0);
1300 boost::shared_ptr<X> p2;
1304 BOOST_TEST(p1 == p2);
1305 BOOST_TEST(p1? false: true);
1307 BOOST_TEST(p1.get() == 0);
1309 boost::shared_ptr<X> p3(p1);
1313 BOOST_TEST(p1 == p3);
1314 BOOST_TEST(p1? false: true);
1316 BOOST_TEST(p1.get() == 0);
1318 BOOST_TEST(X::instances == 0);
1320 boost::shared_ptr<X> p4(new X);
1322 BOOST_TEST(X::instances == 1);
1326 BOOST_TEST(X::instances == 1);
1328 BOOST_TEST(p1 == p4);
1329 BOOST_TEST(!(p1 < p4 || p4 < p1));
1331 BOOST_TEST(p1.use_count() == 2);
1335 BOOST_TEST(p1 == p2);
1336 BOOST_TEST(X::instances == 1);
1340 BOOST_TEST(p4 == p3);
1341 BOOST_TEST(X::instances == 0);
1345 void conversion_assignment()
1348 boost::shared_ptr<void> p1;
1350 boost::shared_ptr<incomplete> p2;
1354 BOOST_TEST(p1 == p2);
1355 BOOST_TEST(p1? false: true);
1357 BOOST_TEST(p1.get() == 0);
1359 boost::shared_ptr<int> p4(new int);
1360 BOOST_TEST(p4.use_count() == 1);
1362 boost::shared_ptr<void> p5(p4);
1363 BOOST_TEST(p4.use_count() == 2);
1367 BOOST_TEST(p1 == p4);
1368 BOOST_TEST(!(p1 < p5 || p5 < p1));
1369 BOOST_TEST(p1.use_count() == 3);
1370 BOOST_TEST(p4.use_count() == 3);
1374 BOOST_TEST(p1 == p2);
1375 BOOST_TEST(p4.use_count() == 2);
1379 boost::shared_ptr<X> p1;
1381 boost::shared_ptr<Y> p2;
1385 BOOST_TEST(p1 == p2);
1386 BOOST_TEST(p1? false: true);
1388 BOOST_TEST(p1.get() == 0);
1390 BOOST_TEST(X::instances == 0);
1391 BOOST_TEST(Y::instances == 0);
1393 boost::shared_ptr<Y> p4(new Y);
1395 BOOST_TEST(X::instances == 1);
1396 BOOST_TEST(Y::instances == 1);
1397 BOOST_TEST(p4.use_count() == 1);
1399 boost::shared_ptr<X> p5(p4);
1400 BOOST_TEST(p4.use_count() == 2);
1404 BOOST_TEST(X::instances == 1);
1405 BOOST_TEST(Y::instances == 1);
1407 BOOST_TEST(p1 == p4);
1408 BOOST_TEST(!(p1 < p5 || p5 < p1));
1410 BOOST_TEST(p1.use_count() == 3);
1411 BOOST_TEST(p4.use_count() == 3);
1415 BOOST_TEST(p1 == p2);
1416 BOOST_TEST(X::instances == 1);
1417 BOOST_TEST(Y::instances == 1);
1418 BOOST_TEST(p4.use_count() == 2);
1423 BOOST_TEST(p4 == p2);
1424 BOOST_TEST(X::instances == 0);
1425 BOOST_TEST(Y::instances == 0);
1429 void auto_ptr_assignment()
1431 #if !defined( BOOST_NO_AUTO_PTR )
1434 boost::shared_ptr<int> p1;
1436 std::auto_ptr<int> p2;
1439 BOOST_TEST(p1? false: true);
1441 BOOST_TEST(p1.get() == 0);
1442 BOOST_TEST(p1.use_count() == 1);
1445 std::auto_ptr<int> p3(p);
1448 BOOST_TEST(p1.get() == p);
1449 BOOST_TEST(p1.use_count() == 1);
1451 #if !defined(BOOST_OLD_AUTO_PTR)
1452 BOOST_TEST(p3.get() == 0);
1456 BOOST_TEST(p1? false: true);
1458 BOOST_TEST(p1.get() == 0);
1459 BOOST_TEST(p1.use_count() == 1);
1463 boost::shared_ptr<void> p1;
1465 std::auto_ptr<int> p2;
1468 BOOST_TEST(p1? false: true);
1470 BOOST_TEST(p1.get() == 0);
1471 BOOST_TEST(p1.use_count() == 1);
1474 std::auto_ptr<int> p3(p);
1477 BOOST_TEST(p1.get() == p);
1478 BOOST_TEST(p1.use_count() == 1);
1480 #if !defined(BOOST_OLD_AUTO_PTR)
1481 BOOST_TEST(p3.get() == 0);
1485 BOOST_TEST(p1? false: true);
1487 BOOST_TEST(p1.get() == 0);
1488 BOOST_TEST(p1.use_count() == 1);
1493 boost::shared_ptr<X> p1;
1495 std::auto_ptr<Y> p2;
1498 BOOST_TEST(p1? false: true);
1500 BOOST_TEST(p1.get() == 0);
1501 BOOST_TEST(p1.use_count() == 1);
1502 BOOST_TEST(X::instances == 0);
1503 BOOST_TEST(Y::instances == 0);
1506 std::auto_ptr<Y> p3(p);
1508 BOOST_TEST(X::instances == 1);
1509 BOOST_TEST(Y::instances == 1);
1512 BOOST_TEST(p1.get() == p);
1513 BOOST_TEST(p1.use_count() == 1);
1514 BOOST_TEST(X::instances == 1);
1515 BOOST_TEST(Y::instances == 1);
1517 #if !defined(BOOST_OLD_AUTO_PTR)
1518 BOOST_TEST(p3.get() == 0);
1522 BOOST_TEST(p1? false: true);
1524 BOOST_TEST(p1.get() == 0);
1525 BOOST_TEST(p1.use_count() == 1);
1526 BOOST_TEST(X::instances == 0);
1527 BOOST_TEST(Y::instances == 0);
1530 #endif // #if !defined( BOOST_NO_AUTO_PTR )
1536 conversion_assignment();
1537 auto_ptr_assignment();
1540 } // namespace n_assignment
1547 incomplete * p0 = 0;
1549 void deleter(incomplete *)
1555 static long instances;
1570 X & operator= (X const &);
1573 long X::instances = 0;
1578 boost::shared_ptr<int> pi;
1580 BOOST_TEST(pi? false: true);
1582 BOOST_TEST(pi.get() == 0);
1583 BOOST_TEST(pi.use_count() == 0);
1587 boost::shared_ptr<int> pi(static_cast<int*>(0));
1589 BOOST_TEST(pi? false: true);
1591 BOOST_TEST(pi.get() == 0);
1592 BOOST_TEST(pi.use_count() == 0);
1596 boost::shared_ptr<int> pi(new int);
1598 BOOST_TEST(pi? false: true);
1600 BOOST_TEST(pi.get() == 0);
1601 BOOST_TEST(pi.use_count() == 0);
1605 boost::shared_ptr<incomplete> px;
1607 BOOST_TEST(px? false: true);
1609 BOOST_TEST(px.get() == 0);
1610 BOOST_TEST(px.use_count() == 0);
1614 boost::shared_ptr<incomplete> px(p0, deleter);
1616 BOOST_TEST(px? false: true);
1618 BOOST_TEST(px.get() == 0);
1619 BOOST_TEST(px.use_count() == 0);
1623 boost::shared_ptr<X> px;
1625 BOOST_TEST(px? false: true);
1627 BOOST_TEST(px.get() == 0);
1628 BOOST_TEST(px.use_count() == 0);
1632 BOOST_TEST(X::instances == 0);
1633 boost::shared_ptr<X> px(new X);
1634 BOOST_TEST(X::instances == 1);
1636 BOOST_TEST(px? false: true);
1638 BOOST_TEST(px.get() == 0);
1639 BOOST_TEST(px.use_count() == 0);
1640 BOOST_TEST(X::instances == 0);
1644 boost::shared_ptr<void> pv;
1646 BOOST_TEST(pv? false: true);
1648 BOOST_TEST(pv.get() == 0);
1649 BOOST_TEST(pv.use_count() == 0);
1653 BOOST_TEST(X::instances == 0);
1654 boost::shared_ptr<void> pv(new X);
1655 BOOST_TEST(X::instances == 1);
1657 BOOST_TEST(pv? false: true);
1659 BOOST_TEST(pv.get() == 0);
1660 BOOST_TEST(pv.use_count() == 0);
1661 BOOST_TEST(X::instances == 0);
1670 struct Y: public A, public virtual X
1672 static long instances;
1687 Y & operator= (Y const &);
1690 long Y::instances = 0;
1692 void pointer_reset()
1695 boost::shared_ptr<int> pi;
1697 pi.reset(static_cast<int*>(0));
1698 BOOST_TEST(pi? false: true);
1700 BOOST_TEST(pi.get() == 0);
1701 BOOST_TEST(pi.use_count() == 1);
1702 BOOST_TEST(pi.unique());
1706 BOOST_TEST(pi? true: false);
1708 BOOST_TEST(pi.get() == p);
1709 BOOST_TEST(pi.use_count() == 1);
1710 BOOST_TEST(pi.unique());
1712 pi.reset(static_cast<int*>(0));
1713 BOOST_TEST(pi? false: true);
1715 BOOST_TEST(pi.get() == 0);
1716 BOOST_TEST(pi.use_count() == 1);
1717 BOOST_TEST(pi.unique());
1721 boost::shared_ptr<X> px;
1723 px.reset(static_cast<X*>(0));
1724 BOOST_TEST(px? false: true);
1726 BOOST_TEST(px.get() == 0);
1727 BOOST_TEST(px.use_count() == 1);
1728 BOOST_TEST(px.unique());
1729 BOOST_TEST(X::instances == 0);
1733 BOOST_TEST(px? true: false);
1735 BOOST_TEST(px.get() == p);
1736 BOOST_TEST(px.use_count() == 1);
1737 BOOST_TEST(px.unique());
1738 BOOST_TEST(X::instances == 1);
1740 px.reset(static_cast<X*>(0));
1741 BOOST_TEST(px? false: true);
1743 BOOST_TEST(px.get() == 0);
1744 BOOST_TEST(px.use_count() == 1);
1745 BOOST_TEST(px.unique());
1746 BOOST_TEST(X::instances == 0);
1747 BOOST_TEST(Y::instances == 0);
1751 BOOST_TEST(px? true: false);
1753 BOOST_TEST(px.get() == q);
1754 BOOST_TEST(px.use_count() == 1);
1755 BOOST_TEST(px.unique());
1756 BOOST_TEST(X::instances == 1);
1757 BOOST_TEST(Y::instances == 1);
1759 px.reset(static_cast<Y*>(0));
1760 BOOST_TEST(px? false: true);
1762 BOOST_TEST(px.get() == 0);
1763 BOOST_TEST(px.use_count() == 1);
1764 BOOST_TEST(px.unique());
1765 BOOST_TEST(X::instances == 0);
1766 BOOST_TEST(Y::instances == 0);
1770 boost::shared_ptr<void> pv;
1772 pv.reset(static_cast<X*>(0));
1773 BOOST_TEST(pv? false: true);
1775 BOOST_TEST(pv.get() == 0);
1776 BOOST_TEST(pv.use_count() == 1);
1777 BOOST_TEST(pv.unique());
1778 BOOST_TEST(X::instances == 0);
1782 BOOST_TEST(pv? true: false);
1784 BOOST_TEST(pv.get() == p);
1785 BOOST_TEST(pv.use_count() == 1);
1786 BOOST_TEST(pv.unique());
1787 BOOST_TEST(X::instances == 1);
1789 pv.reset(static_cast<X*>(0));
1790 BOOST_TEST(pv? false: true);
1792 BOOST_TEST(pv.get() == 0);
1793 BOOST_TEST(pv.use_count() == 1);
1794 BOOST_TEST(pv.unique());
1795 BOOST_TEST(X::instances == 0);
1796 BOOST_TEST(Y::instances == 0);
1800 BOOST_TEST(pv? true: false);
1802 BOOST_TEST(pv.get() == q);
1803 BOOST_TEST(pv.use_count() == 1);
1804 BOOST_TEST(pv.unique());
1805 BOOST_TEST(X::instances == 1);
1806 BOOST_TEST(Y::instances == 1);
1808 pv.reset(static_cast<Y*>(0));
1809 BOOST_TEST(pv? false: true);
1811 BOOST_TEST(pv.get() == 0);
1812 BOOST_TEST(pv.use_count() == 1);
1813 BOOST_TEST(pv.unique());
1814 BOOST_TEST(X::instances == 0);
1815 BOOST_TEST(Y::instances == 0);
1821 void deleter2(void * p)
1826 void deleter_reset()
1829 boost::shared_ptr<int> pi;
1831 pi.reset(static_cast<int*>(0), deleter2);
1832 BOOST_TEST(pi? false: true);
1834 BOOST_TEST(pi.get() == 0);
1835 BOOST_TEST(pi.use_count() == 1);
1836 BOOST_TEST(pi.unique());
1841 pi.reset(&m, deleter2);
1842 BOOST_TEST(deleted == 0);
1843 BOOST_TEST(pi? true: false);
1845 BOOST_TEST(pi.get() == &m);
1846 BOOST_TEST(pi.use_count() == 1);
1847 BOOST_TEST(pi.unique());
1849 pi.reset(static_cast<int*>(0), deleter2);
1850 BOOST_TEST(deleted == &m);
1851 BOOST_TEST(pi? false: true);
1853 BOOST_TEST(pi.get() == 0);
1854 BOOST_TEST(pi.use_count() == 1);
1855 BOOST_TEST(pi.unique());
1858 BOOST_TEST(deleted == 0);
1862 boost::shared_ptr<X> px;
1864 px.reset(static_cast<X*>(0), deleter2);
1865 BOOST_TEST(px? false: true);
1867 BOOST_TEST(px.get() == 0);
1868 BOOST_TEST(px.use_count() == 1);
1869 BOOST_TEST(px.unique());
1874 px.reset(&x, deleter2);
1875 BOOST_TEST(deleted == 0);
1876 BOOST_TEST(px? true: false);
1878 BOOST_TEST(px.get() == &x);
1879 BOOST_TEST(px.use_count() == 1);
1880 BOOST_TEST(px.unique());
1882 px.reset(static_cast<X*>(0), deleter2);
1883 BOOST_TEST(deleted == &x);
1884 BOOST_TEST(px? false: true);
1886 BOOST_TEST(px.get() == 0);
1887 BOOST_TEST(px.use_count() == 1);
1888 BOOST_TEST(px.unique());
1891 px.reset(&y, deleter2);
1892 BOOST_TEST(deleted == 0);
1893 BOOST_TEST(px? true: false);
1895 BOOST_TEST(px.get() == &y);
1896 BOOST_TEST(px.use_count() == 1);
1897 BOOST_TEST(px.unique());
1899 px.reset(static_cast<Y*>(0), deleter2);
1900 BOOST_TEST(deleted == &y);
1901 BOOST_TEST(px? false: true);
1903 BOOST_TEST(px.get() == 0);
1904 BOOST_TEST(px.use_count() == 1);
1905 BOOST_TEST(px.unique());
1908 BOOST_TEST(deleted == 0);
1912 boost::shared_ptr<void> pv;
1914 pv.reset(static_cast<X*>(0), deleter2);
1915 BOOST_TEST(pv? false: true);
1917 BOOST_TEST(pv.get() == 0);
1918 BOOST_TEST(pv.use_count() == 1);
1919 BOOST_TEST(pv.unique());
1924 pv.reset(&x, deleter2);
1925 BOOST_TEST(deleted == 0);
1926 BOOST_TEST(pv? true: false);
1928 BOOST_TEST(pv.get() == &x);
1929 BOOST_TEST(pv.use_count() == 1);
1930 BOOST_TEST(pv.unique());
1932 pv.reset(static_cast<X*>(0), deleter2);
1933 BOOST_TEST(deleted == &x);
1934 BOOST_TEST(pv? false: true);
1936 BOOST_TEST(pv.get() == 0);
1937 BOOST_TEST(pv.use_count() == 1);
1938 BOOST_TEST(pv.unique());
1941 pv.reset(&y, deleter2);
1942 BOOST_TEST(deleted == 0);
1943 BOOST_TEST(pv? true: false);
1945 BOOST_TEST(pv.get() == &y);
1946 BOOST_TEST(pv.use_count() == 1);
1947 BOOST_TEST(pv.unique());
1949 pv.reset(static_cast<Y*>(0), deleter2);
1950 BOOST_TEST(deleted == &y);
1951 BOOST_TEST(pv? false: true);
1953 BOOST_TEST(pv.get() == 0);
1954 BOOST_TEST(pv.use_count() == 1);
1955 BOOST_TEST(pv.unique());
1958 BOOST_TEST(deleted == 0);
1962 boost::shared_ptr<incomplete> px;
1964 px.reset(p0, deleter2);
1965 BOOST_TEST(px? false: true);
1967 BOOST_TEST(px.get() == 0);
1968 BOOST_TEST(px.use_count() == 1);
1969 BOOST_TEST(px.unique());
1972 px.reset(p0, deleter2);
1973 BOOST_TEST(deleted == 0);
1984 } // namespace n_reset
1996 boost::shared_ptr<X> px;
1997 BOOST_TEST(px.get() == 0);
1998 BOOST_TEST(px? false: true);
2001 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2002 using boost::get_pointer;
2005 BOOST_TEST(get_pointer(px) == px.get());
2009 boost::shared_ptr<X> px(static_cast<X*>(0));
2010 BOOST_TEST(px.get() == 0);
2011 BOOST_TEST(px? false: true);
2014 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2015 using boost::get_pointer;
2018 BOOST_TEST(get_pointer(px) == px.get());
2022 boost::shared_ptr<X> px(static_cast<X*>(0), boost::checked_deleter<X>());
2023 BOOST_TEST(px.get() == 0);
2024 BOOST_TEST(px? false: true);
2027 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2028 using boost::get_pointer;
2031 BOOST_TEST(get_pointer(px) == px.get());
2036 boost::shared_ptr<X> px(p);
2037 BOOST_TEST(px.get() == p);
2038 BOOST_TEST(px? true: false);
2040 BOOST_TEST(&*px == px.get());
2041 BOOST_TEST(px.operator ->() == px.get());
2043 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2044 using boost::get_pointer;
2047 BOOST_TEST(get_pointer(px) == px.get());
2052 boost::shared_ptr<X> px(p, boost::checked_deleter<X>());
2053 BOOST_TEST(px.get() == p);
2054 BOOST_TEST(px? true: false);
2056 BOOST_TEST(&*px == px.get());
2057 BOOST_TEST(px.operator ->() == px.get());
2059 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
2060 using boost::get_pointer;
2063 BOOST_TEST(get_pointer(px) == px.get());
2067 } // namespace n_access
2069 namespace n_use_count
2079 boost::shared_ptr<X> px(static_cast<X*>(0));
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);
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 boost::shared_ptr<X> px(new X, boost::checked_deleter<X>());
2104 BOOST_TEST(px.use_count() == 1);
2105 BOOST_TEST(px.unique());
2107 boost::shared_ptr<X> px2(px);
2108 BOOST_TEST(px2.use_count() == 2);
2109 BOOST_TEST(!px2.unique());
2110 BOOST_TEST(px.use_count() == 2);
2111 BOOST_TEST(!px.unique());
2115 } // namespace n_use_count
2127 boost::shared_ptr<X> px;
2128 boost::shared_ptr<X> px2;
2132 BOOST_TEST(px.get() == 0);
2133 BOOST_TEST(px2.get() == 0);
2138 BOOST_TEST(px.get() == 0);
2139 BOOST_TEST(px2.get() == 0);
2144 boost::shared_ptr<X> px;
2145 boost::shared_ptr<X> px2(p);
2146 boost::shared_ptr<X> px3(px2);
2150 BOOST_TEST(px.get() == p);
2151 BOOST_TEST(px.use_count() == 2);
2152 BOOST_TEST(px2.get() == 0);
2153 BOOST_TEST(px3.get() == p);
2154 BOOST_TEST(px3.use_count() == 2);
2159 BOOST_TEST(px.get() == 0);
2160 BOOST_TEST(px2.get() == p);
2161 BOOST_TEST(px2.use_count() == 2);
2162 BOOST_TEST(px3.get() == p);
2163 BOOST_TEST(px3.use_count() == 2);
2169 boost::shared_ptr<X> px(p1);
2170 boost::shared_ptr<X> px2(p2);
2171 boost::shared_ptr<X> px3(px2);
2175 BOOST_TEST(px.get() == p2);
2176 BOOST_TEST(px.use_count() == 2);
2177 BOOST_TEST(px2.get() == p1);
2178 BOOST_TEST(px2.use_count() == 1);
2179 BOOST_TEST(px3.get() == p2);
2180 BOOST_TEST(px3.use_count() == 2);
2185 BOOST_TEST(px.get() == p1);
2186 BOOST_TEST(px.use_count() == 1);
2187 BOOST_TEST(px2.get() == p2);
2188 BOOST_TEST(px2.use_count() == 2);
2189 BOOST_TEST(px3.get() == p2);
2190 BOOST_TEST(px3.use_count() == 2);
2194 } // namespace n_swap
2196 namespace n_comparison
2209 struct Z: public X, public virtual Y
2216 boost::shared_ptr<X> px;
2217 BOOST_TEST(px == px);
2218 BOOST_TEST(!(px != px));
2219 BOOST_TEST(!(px < px));
2221 boost::shared_ptr<X> px2;
2223 BOOST_TEST(px.get() == px2.get());
2224 BOOST_TEST(px == px2);
2225 BOOST_TEST(!(px != px2));
2226 BOOST_TEST(!(px < px2 && px2 < px));
2230 boost::shared_ptr<X> px;
2231 boost::shared_ptr<X> px2(px);
2233 BOOST_TEST(px2 == px2);
2234 BOOST_TEST(!(px2 != px2));
2235 BOOST_TEST(!(px2 < px2));
2237 BOOST_TEST(px.get() == px2.get());
2238 BOOST_TEST(px == px2);
2239 BOOST_TEST(!(px != px2));
2240 BOOST_TEST(!(px < px2 && px2 < px));
2244 boost::shared_ptr<X> px;
2245 boost::shared_ptr<X> px2(new X);
2247 BOOST_TEST(px2 == px2);
2248 BOOST_TEST(!(px2 != px2));
2249 BOOST_TEST(!(px2 < px2));
2251 BOOST_TEST(px.get() != px2.get());
2252 BOOST_TEST(px != px2);
2253 BOOST_TEST(!(px == px2));
2254 BOOST_TEST(px < px2 || px2 < px);
2255 BOOST_TEST(!(px < px2 && px2 < px));
2259 boost::shared_ptr<X> px(new X);
2260 boost::shared_ptr<X> px2(new X);
2262 BOOST_TEST(px.get() != px2.get());
2263 BOOST_TEST(px != px2);
2264 BOOST_TEST(!(px == px2));
2265 BOOST_TEST(px < px2 || px2 < px);
2266 BOOST_TEST(!(px < px2 && px2 < px));
2270 boost::shared_ptr<X> px(new X);
2271 boost::shared_ptr<X> px2(px);
2273 BOOST_TEST(px2 == px2);
2274 BOOST_TEST(!(px2 != px2));
2275 BOOST_TEST(!(px2 < px2));
2277 BOOST_TEST(px.get() == px2.get());
2278 BOOST_TEST(px == px2);
2279 BOOST_TEST(!(px != px2));
2280 BOOST_TEST(!(px < px2 || px2 < px));
2284 boost::shared_ptr<X> px(new X);
2285 boost::shared_ptr<Y> py(new Y);
2286 boost::shared_ptr<Z> pz(new Z);
2288 BOOST_TEST(px.get() != pz.get());
2289 BOOST_TEST(px != pz);
2290 BOOST_TEST(!(px == pz));
2292 BOOST_TEST(py.get() != pz.get());
2293 BOOST_TEST(py != pz);
2294 BOOST_TEST(!(py == pz));
2296 BOOST_TEST(px < py || py < px);
2297 BOOST_TEST(px < pz || pz < px);
2298 BOOST_TEST(py < pz || pz < py);
2300 BOOST_TEST(!(px < py && py < px));
2301 BOOST_TEST(!(px < pz && pz < px));
2302 BOOST_TEST(!(py < pz && pz < py));
2304 boost::shared_ptr<void> pvx(px);
2306 BOOST_TEST(pvx == pvx);
2307 BOOST_TEST(!(pvx != pvx));
2308 BOOST_TEST(!(pvx < pvx));
2310 boost::shared_ptr<void> pvy(py);
2311 boost::shared_ptr<void> pvz(pz);
2313 BOOST_TEST(pvx < pvy || pvy < pvx);
2314 BOOST_TEST(pvx < pvz || pvz < pvx);
2315 BOOST_TEST(pvy < pvz || pvz < pvy);
2317 BOOST_TEST(!(pvx < pvy && pvy < pvx));
2318 BOOST_TEST(!(pvx < pvz && pvz < pvx));
2319 BOOST_TEST(!(pvy < pvz && pvz < pvy));
2323 boost::shared_ptr<Z> pz(new Z);
2324 boost::shared_ptr<X> px(pz);
2326 BOOST_TEST(px == px);
2327 BOOST_TEST(!(px != px));
2328 BOOST_TEST(!(px < px));
2330 boost::shared_ptr<Y> py(pz);
2332 BOOST_TEST(px.get() == pz.get());
2333 BOOST_TEST(px == pz);
2334 BOOST_TEST(!(px != pz));
2336 BOOST_TEST(py.get() == pz.get());
2337 BOOST_TEST(py == pz);
2338 BOOST_TEST(!(py != pz));
2340 BOOST_TEST(!(px < py || py < px));
2341 BOOST_TEST(!(px < pz || pz < px));
2342 BOOST_TEST(!(py < pz || pz < py));
2344 boost::shared_ptr<void> pvx(px);
2345 boost::shared_ptr<void> pvy(py);
2346 boost::shared_ptr<void> pvz(pz);
2348 // pvx and pvy aren't equal...
2349 BOOST_TEST(pvx.get() != pvy.get());
2350 BOOST_TEST(pvx != pvy);
2351 BOOST_TEST(!(pvx == pvy));
2353 // ... but they share ownership ...
2354 BOOST_TEST(!(pvx < pvy || pvy < pvx));
2357 BOOST_TEST(!(pvx < pvz || pvz < pvx));
2358 BOOST_TEST(!(pvy < pvz || pvz < pvy));
2362 } // namespace n_comparison
2364 namespace n_static_cast
2378 boost::shared_ptr<void> pv;
2380 boost::shared_ptr<int> pi = boost::static_pointer_cast<int>(pv);
2381 BOOST_TEST(pi.get() == 0);
2383 boost::shared_ptr<X> px = boost::static_pointer_cast<X>(pv);
2384 BOOST_TEST(px.get() == 0);
2388 boost::shared_ptr<int> pi(new int);
2389 boost::shared_ptr<void> pv(pi);
2391 boost::shared_ptr<int> pi2 = boost::static_pointer_cast<int>(pv);
2392 BOOST_TEST(pi.get() == pi2.get());
2393 BOOST_TEST(!(pi < pi2 || pi2 < pi));
2394 BOOST_TEST(pi.use_count() == 3);
2395 BOOST_TEST(pv.use_count() == 3);
2396 BOOST_TEST(pi2.use_count() == 3);
2400 boost::shared_ptr<X> px(new X);
2401 boost::shared_ptr<void> pv(px);
2403 boost::shared_ptr<X> px2 = boost::static_pointer_cast<X>(pv);
2404 BOOST_TEST(px.get() == px2.get());
2405 BOOST_TEST(!(px < px2 || px2 < px));
2406 BOOST_TEST(px.use_count() == 3);
2407 BOOST_TEST(pv.use_count() == 3);
2408 BOOST_TEST(px2.use_count() == 3);
2412 boost::shared_ptr<X> px(new Y);
2414 boost::shared_ptr<Y> py = boost::static_pointer_cast<Y>(px);
2415 BOOST_TEST(px.get() == py.get());
2416 BOOST_TEST(px.use_count() == 2);
2417 BOOST_TEST(py.use_count() == 2);
2419 boost::shared_ptr<X> px2(py);
2420 BOOST_TEST(!(px < px2 || px2 < px));
2424 } // namespace n_static_cast
2426 namespace n_const_cast
2434 boost::shared_ptr<void const volatile> px;
2436 boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
2437 BOOST_TEST(px2.get() == 0);
2441 boost::shared_ptr<int const volatile> px;
2443 boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
2444 BOOST_TEST(px2.get() == 0);
2448 boost::shared_ptr<X const volatile> px;
2450 boost::shared_ptr<X> px2 = boost::const_pointer_cast<X>(px);
2451 BOOST_TEST(px2.get() == 0);
2455 boost::shared_ptr<void const volatile> px(new int);
2457 boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
2458 BOOST_TEST(px.get() == px2.get());
2459 BOOST_TEST(!(px < px2 || px2 < px));
2460 BOOST_TEST(px.use_count() == 2);
2461 BOOST_TEST(px2.use_count() == 2);
2465 boost::shared_ptr<int const volatile> px(new int);
2467 boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
2468 BOOST_TEST(px.get() == px2.get());
2469 BOOST_TEST(!(px < px2 || px2 < px));
2470 BOOST_TEST(px.use_count() == 2);
2471 BOOST_TEST(px2.use_count() == 2);
2475 } // namespace n_const_cast
2477 #if !defined( BOOST_NO_RTTI )
2479 namespace n_dynamic_cast
2494 boost::shared_ptr<V> pv;
2495 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2496 BOOST_TEST(pw.get() == 0);
2500 boost::shared_ptr<V> pv(static_cast<V*>(0));
2502 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2503 BOOST_TEST(pw.get() == 0);
2505 boost::shared_ptr<V> pv2(pw);
2506 BOOST_TEST(pv < pv2 || pv2 < pv);
2510 boost::shared_ptr<V> pv(static_cast<W*>(0));
2512 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2513 BOOST_TEST(pw.get() == 0);
2515 boost::shared_ptr<V> pv2(pw);
2516 BOOST_TEST(pv < pv2 || pv2 < pv);
2520 boost::shared_ptr<V> pv(new V);
2522 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2523 BOOST_TEST(pw.get() == 0);
2525 boost::shared_ptr<V> pv2(pw);
2526 BOOST_TEST(pv < pv2 || pv2 < pv);
2530 boost::shared_ptr<V> pv(new W);
2532 boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
2533 BOOST_TEST(pw.get() == pv.get());
2534 BOOST_TEST(pv.use_count() == 2);
2535 BOOST_TEST(pw.use_count() == 2);
2537 boost::shared_ptr<V> pv2(pw);
2538 BOOST_TEST(!(pv < pv2 || pv2 < pv));
2542 } // namespace n_dynamic_cast
2555 std::vector< boost::shared_ptr<int> > vi;
2558 boost::shared_ptr<int> pi1(new int);
2559 boost::shared_ptr<int> pi2(new int);
2560 boost::shared_ptr<int> pi3(new int);
2575 std::vector< boost::shared_ptr<X> > vx;
2578 boost::shared_ptr<X> px1(new X);
2579 boost::shared_ptr<X> px2(new X);
2580 boost::shared_ptr<X> px3(new X);
2595 std::map< boost::shared_ptr<void>, long > m;
2598 for(std::vector< boost::shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i)
2605 for(std::vector< boost::shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i)
2612 for(std::map< boost::shared_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
2614 BOOST_TEST(i->first.use_count() == i->second + 1);
2619 } // namespace n_map
2621 namespace n_transitive
2627 boost::shared_ptr<X> next;
2632 boost::shared_ptr<X> p(new X);
2633 p->next = boost::shared_ptr<X>(new X);
2634 BOOST_TEST(!p->next->next);
2636 BOOST_TEST(!p->next);
2639 } // namespace n_transitive
2641 namespace n_report_1
2659 boost::shared_ptr<foo> m_self;
2664 foo * foo_ptr = new foo;
2668 } // namespace n_report_1
2670 // Test case by Per Kristensen
2671 namespace n_report_2
2678 void setWeak(boost::shared_ptr<foo> s)
2685 boost::weak_ptr<foo> w;
2698 BOOST_TEST(lock == 0);
2701 void operator() (foo * p)
2715 boost::shared_ptr<foo> s(new foo, deleter());
2720 } // namespace n_report_2
2722 namespace n_spt_incomplete
2727 boost::shared_ptr<file> fopen(char const * name, char const * mode);
2728 void fread(boost::shared_ptr<file> f, void * data, long size);
2730 int file_instances = 0;
2734 BOOST_TEST(file_instances == 0);
2737 boost::shared_ptr<file> pf = fopen("name", "mode");
2738 BOOST_TEST(file_instances == 1);
2739 fread(pf, 0, 17041);
2742 BOOST_TEST(file_instances == 0);
2745 } // namespace n_spt_incomplete
2747 namespace n_spt_pimpl
2755 boost::shared_ptr<impl> pimpl_;
2759 file(char const * name, char const * mode);
2761 // compiler generated members are fine and useful
2763 void read(void * data, long size);
2765 long total_size() const;
2768 int file_instances = 0;
2772 BOOST_TEST(file_instances == 0);
2775 file f("name", "mode");
2776 BOOST_TEST(file_instances == 1);
2780 BOOST_TEST(file_instances == 1);
2783 BOOST_TEST(f.total_size() == 152+894);
2786 file f3("name2", "mode2");
2787 BOOST_TEST(file_instances == 2);
2790 BOOST_TEST(file_instances == 1);
2793 BOOST_TEST(file_instances == 0);
2796 } // namespace n_spt_pimpl
2798 namespace n_spt_abstract
2805 virtual void f(int) = 0;
2806 virtual int g() = 0;
2813 boost::shared_ptr<X> createX();
2815 int X_instances = 0;
2819 BOOST_TEST(X_instances == 0);
2822 boost::shared_ptr<X> px = createX();
2824 BOOST_TEST(X_instances == 1);
2829 BOOST_TEST(px->g() == 170);
2832 BOOST_TEST(X_instances == 0);
2835 } // namespace n_spt_abstract
2837 namespace n_spt_preventing_delete
2840 int X_instances = 0;
2857 friend class deleter;
2863 void operator()(X * p) { delete p; }
2868 static boost::shared_ptr<X> create()
2870 boost::shared_ptr<X> px(new X, X::deleter());
2877 BOOST_TEST(X_instances == 0);
2880 boost::shared_ptr<X> px = X::create();
2881 BOOST_TEST(X_instances == 1);
2884 BOOST_TEST(X_instances == 0);
2887 } // namespace n_spt_preventing_delete
2889 namespace n_spt_array
2892 int X_instances = 0;
2909 BOOST_TEST(X_instances == 0);
2912 boost::shared_ptr<X> px(new X[4], boost::checked_array_deleter<X>());
2913 BOOST_TEST(X_instances == 4);
2916 BOOST_TEST(X_instances == 0);
2919 } // namespace n_spt_array
2921 namespace n_spt_static
2934 void operator delete(void *)
2936 // Comeau 4.3.0.1 wants a definition
2937 BOOST_ERROR("n_spt_static::X::operator delete() called.");
2943 void operator()(void const *) const
2952 boost::shared_ptr<X> px(&x, null_deleter());
2955 } // namespace n_spt_static
2957 namespace n_spt_intrusive
2960 int X_instances = 0;
2977 void intrusive_ptr_add_ref(X * p)
2982 void intrusive_ptr_release(X * p)
2984 if(--p->count == 0) delete p;
2987 template<class T> struct intrusive_deleter
2989 void operator()(T * p)
2991 if(p != 0) intrusive_ptr_release(p);
2995 boost::shared_ptr<X> make_shared_from_intrusive(X * p)
2997 if(p != 0) intrusive_ptr_add_ref(p);
2998 boost::shared_ptr<X> px(p, intrusive_deleter<X>());
3004 BOOST_TEST(X_instances == 0);
3008 BOOST_TEST(X_instances == 1);
3009 BOOST_TEST(p->count == 0);
3010 boost::shared_ptr<X> px = make_shared_from_intrusive(p);
3011 BOOST_TEST(px.get() == p);
3012 BOOST_TEST(p->count == 1);
3013 boost::shared_ptr<X> px2(px);
3014 BOOST_TEST(px2.get() == p);
3015 BOOST_TEST(p->count == 1);
3018 BOOST_TEST(X_instances == 0);
3021 } // namespace n_spt_intrusive
3023 namespace n_spt_another_sp
3026 template<class T> class another_ptr: private boost::shared_ptr<T>
3030 typedef boost::shared_ptr<T> base_type;
3034 explicit another_ptr(T * p = 0): base_type(p)
3045 return base_type::get();
3053 virtual ~event_handler() {}
3054 virtual void begin() = 0;
3055 virtual void handle(int event) = 0;
3056 virtual void end() = 0;
3059 int begin_called = 0;
3060 int handle_called = 0;
3063 class event_handler_impl: public event_handler
3067 virtual void begin()
3072 virtual void handle(int event)
3074 handle_called = event;
3083 another_ptr<event_handler> get_event_handler()
3085 another_ptr<event_handler> p(new event_handler_impl);
3089 boost::shared_ptr<event_handler> current_handler;
3091 void install_event_handler(boost::shared_ptr<event_handler> p)
3094 current_handler = p;
3097 void handle_event(int event)
3099 current_handler->handle(event);
3102 void remove_event_handler()
3104 current_handler->end();
3105 current_handler.reset();
3108 template<class P> class smart_pointer_deleter
3116 smart_pointer_deleter(P const & p): p_(p)
3120 void operator()(void const *)
3128 another_ptr<event_handler> p = get_event_handler();
3130 boost::shared_ptr<event_handler> q(p.get(), smart_pointer_deleter< another_ptr<event_handler> >(p));
3134 BOOST_TEST(begin_called == 0);
3136 install_event_handler(q);
3138 BOOST_TEST(begin_called == 1);
3140 BOOST_TEST(handle_called == 0);
3142 handle_event(17041);
3144 BOOST_TEST(handle_called == 17041);
3146 BOOST_TEST(end_called == 0);
3148 remove_event_handler();
3150 BOOST_TEST(end_called == 1);
3153 } // namespace n_spt_another_sp
3155 namespace n_spt_shared_from_this
3162 virtual void f() = 0;
3173 virtual boost::shared_ptr<X> getX() = 0;
3180 class impl: public X, public Y
3184 boost::weak_ptr<impl> weak_this;
3187 impl & operator=(impl const &);
3193 static boost::shared_ptr<impl> create()
3195 boost::shared_ptr<impl> pi(new impl);
3202 virtual boost::shared_ptr<X> getX()
3204 boost::shared_ptr<X> px = weak_this.lock();
3211 boost::shared_ptr<Y> py = impl::create();
3212 BOOST_TEST(py.get() != 0);
3213 BOOST_TEST(py.use_count() == 1);
3215 boost::shared_ptr<X> px = py->getX();
3216 BOOST_TEST(px.get() != 0);
3217 BOOST_TEST(py.use_count() == 2);
3219 #if !defined( BOOST_NO_RTTI )
3220 boost::shared_ptr<Y> py2 = boost::dynamic_pointer_cast<Y>(px);
3221 BOOST_TEST(py.get() == py2.get());
3222 BOOST_TEST(!(py < py2 || py2 < py));
3223 BOOST_TEST(py.use_count() == 3);
3227 } // namespace n_spt_shared_from_this
3229 namespace n_spt_wrap
3236 } // namespace n_spt_wrap
3240 n_element_type::test();
3241 n_constructors::test();
3242 n_assignment::test();
3245 n_use_count::test();
3247 n_comparison::test();
3248 n_static_cast::test();
3249 n_const_cast::test();
3250 #if !defined( BOOST_NO_RTTI )
3251 n_dynamic_cast::test();
3256 n_transitive::test();
3260 n_spt_incomplete::test();
3261 n_spt_pimpl::test();
3262 n_spt_abstract::test();
3263 n_spt_preventing_delete::test();
3264 n_spt_array::test();
3265 n_spt_static::test();
3266 n_spt_intrusive::test();
3267 n_spt_another_sp::test();
3268 n_spt_shared_from_this::test();
3271 return boost::report_errors();
3274 namespace n_spt_incomplete
3281 file(): fread_called(false)
3288 BOOST_TEST(fread_called);
3295 boost::shared_ptr<file> fopen(char const *, char const *)
3297 boost::shared_ptr<file> pf(new file);
3301 void fread(boost::shared_ptr<file> pf, void *, long)
3303 pf->fread_called = true;
3306 } // namespace n_spt_incomplete
3308 namespace n_spt_pimpl
3316 impl & operator=(impl const &);
3322 impl(char const *, char const *): total_size_(0)
3332 void read(void *, long size)
3334 total_size_ += size;
3337 long total_size() const
3343 file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
3347 void file::read(void * data, long size)
3349 pimpl_->read(data, size);
3352 long file::total_size() const
3354 return pimpl_->total_size();
3357 } // namespace n_spt_pimpl
3359 namespace n_spt_abstract
3362 class X_impl: public X
3366 X_impl(X_impl const &);
3367 X_impl & operator=(X_impl const &);
3383 virtual void f(int n)
3394 boost::shared_ptr<X> createX()
3396 boost::shared_ptr<X> px(new X_impl);
3400 } // namespace n_spt_abstract