CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

testWeakPtr.cc
Go to the documentation of this file.
1// ======================================================================
2//
3// Test compilability and basic functionality of Utility/memory.h
4//
5// Author: W. E. Brown, 2010-03-19, adapted from the boost library's
6// shared_ptr and related functionality whose internal attributions bear
7// the following various notices:
8//
9// Copyright (c) 2002-2005 Peter Dimov
10// Distributed under the Boost Software License, Version 1.0.
11// See http://www.boost.org/LICENSE_1_0.txt
12//
13// ======================================================================
14
15
16#include "CLHEP/Utility/memory.h"
17
18#include <cassert>
19#include <map>
20#include <vector>
21
22
23using namespace CLHEP;
25using CLHEP::weak_ptr;
26
27
28#if defined(_MSC_VER) && (_MSC_VER >= 1310)
29# pragma warning (disable : 4675) // suppress ADL warning
30#endif
31
32
33namespace n_element_type
34{
35
36void
37 f(int &)
38{ }
39
40void
41 test()
42{
44 T t;
45 f(t);
46}
47
48} // namespace n_element_type
49
50class incomplete;
51
53
54struct X
55{
56 int dummy;
57};
58
59struct Y
60{
61 int dummy2;
62};
63
64struct Z
65 : public X, public virtual Y
66{ };
67
68namespace n_constructors
69{
70
71void
73{
74 {
76 assert(wp.use_count() == 0);
77 }
78
79 {
81 assert(wp.use_count() == 0);
82 }
83
84 {
86 assert(wp.use_count() == 0);
87 }
88}
89
90void
92{
93 {
95
96 weak_ptr<int> wp(sp);
97 assert(wp.use_count() == sp.use_count());
98
99 weak_ptr<void> wp2(sp);
100 assert(wp2.use_count() == sp.use_count());
101 }
102
103 {
104 shared_ptr<int> sp(static_cast<int*>(0));
105
106 {
107 weak_ptr<int> wp(sp);
108 assert(wp.use_count() == sp.use_count());
109 assert(wp.use_count() == 1);
110 shared_ptr<int> sp2(wp);
111 assert(wp.use_count() == 2);
112 assert(!(sp < sp2 || sp2 < sp));
113 }
114
115 {
116 weak_ptr<void> wp(sp);
117 assert(wp.use_count() == sp.use_count());
118 assert(wp.use_count() == 1);
119 shared_ptr<void> sp2(wp);
120 assert(wp.use_count() == 2);
121 assert(!(sp < sp2 || sp2 < sp));
122 }
123 }
124
125 {
126 shared_ptr<int> sp(new int);
127
128 {
129 weak_ptr<int> wp(sp);
130 assert(wp.use_count() == sp.use_count());
131 assert(wp.use_count() == 1);
132 shared_ptr<int> sp2(wp);
133 assert(wp.use_count() == 2);
134 assert(!(sp < sp2 || sp2 < sp));
135 }
136
137 {
138 weak_ptr<void> wp(sp);
139 assert(wp.use_count() == sp.use_count());
140 assert(wp.use_count() == 1);
141 shared_ptr<void> sp2(wp);
142 assert(wp.use_count() == 2);
143 assert(!(sp < sp2 || sp2 < sp));
144 }
145 }
146
147 {
149
150 weak_ptr<void> wp(sp);
151 assert(wp.use_count() == sp.use_count());
152 }
153
154 {
155 shared_ptr<void> sp(static_cast<int*>(0));
156
157 weak_ptr<void> wp(sp);
158 assert(wp.use_count() == sp.use_count());
159 assert(wp.use_count() == 1);
160 shared_ptr<void> sp2(wp);
161 assert(wp.use_count() == 2);
162 assert(!(sp < sp2 || sp2 < sp));
163 }
164
165 {
166 shared_ptr<void> sp(new int);
167
168 weak_ptr<void> wp(sp);
169 assert(wp.use_count() == sp.use_count());
170 assert(wp.use_count() == 1);
171 shared_ptr<void> sp2(wp);
172 assert(wp.use_count() == 2);
173 assert(!(sp < sp2 || sp2 < sp));
174 }
175
176 {
178
180 assert(wp.use_count() == sp.use_count());
181
182 weak_ptr<void> wp2(sp);
183 assert(wp2.use_count() == sp.use_count());
184 }
185
186 {
188
189 {
191 assert(wp.use_count() == sp.use_count());
192 assert(wp.use_count() == 1);
194 assert(wp.use_count() == 2);
195 assert(!(sp < sp2 || sp2 < sp));
196 }
197
198 {
199 weak_ptr<void> wp(sp);
200 assert(wp.use_count() == sp.use_count());
201 assert(wp.use_count() == 1);
202 shared_ptr<void> sp2(wp);
203 assert(wp.use_count() == 2);
204 assert(!(sp < sp2 || sp2 < sp));
205 }
206 }
207
208 {
210
211 weak_ptr<void> wp(sp);
212 assert(wp.use_count() == sp.use_count());
213 assert(wp.use_count() == 1);
214 shared_ptr<void> sp2(wp);
215 assert(wp.use_count() == 2);
216 assert(!(sp < sp2 || sp2 < sp));
217 }
218}
219
220void
222{
223 {
224 weak_ptr<int> wp;
225 weak_ptr<int> wp2(wp);
226 assert(wp2.use_count() == wp.use_count());
227 assert(wp2.use_count() == 0);
228 }
229
230 {
232 weak_ptr<void> wp2(wp);
233 assert(wp2.use_count() == wp.use_count());
234 assert(wp2.use_count() == 0);
235 }
236
237 {
239 weak_ptr<incomplete> wp2(wp);
240 assert(wp2.use_count() == wp.use_count());
241 assert(wp2.use_count() == 0);
242 }
243
244 {
245 shared_ptr<int> sp(static_cast<int*>(0));
246 weak_ptr<int> wp(sp);
247
248 weak_ptr<int> wp2(wp);
249 assert(wp2.use_count() == wp.use_count());
250 assert(wp2.use_count() == 1);
251 assert(!(wp < wp2 || wp2 < wp));
252
253 sp.reset();
254 assert(!(wp < wp2 || wp2 < wp));
255
256 weak_ptr<int> wp3(wp);
257 assert(wp3.use_count() == wp.use_count());
258 assert(wp3.use_count() == 0);
259 assert(!(wp < wp3 || wp3 < wp));
260 }
261
262 {
263 shared_ptr<int> sp(new int);
264 weak_ptr<int> wp(sp);
265
266 weak_ptr<int> wp2(wp);
267 assert(wp2.use_count() == wp.use_count());
268 assert(wp2.use_count() == 1);
269 assert(!(wp < wp2 || wp2 < wp));
270
271 sp.reset();
272 assert(!(wp < wp2 || wp2 < wp));
273
274 weak_ptr<int> wp3(wp);
275 assert(wp3.use_count() == wp.use_count());
276 assert(wp3.use_count() == 0);
277 assert(!(wp < wp3 || wp3 < wp));
278 }
279
280 {
281 shared_ptr<void> sp(static_cast<int*>(0));
282 weak_ptr<void> wp(sp);
283
284 weak_ptr<void> wp2(wp);
285 assert(wp2.use_count() == wp.use_count());
286 assert(wp2.use_count() == 1);
287 assert(!(wp < wp2 || wp2 < wp));
288
289 sp.reset();
290 assert(!(wp < wp2 || wp2 < wp));
291
292 weak_ptr<void> wp3(wp);
293 assert(wp3.use_count() == wp.use_count());
294 assert(wp3.use_count() == 0);
295 assert(!(wp < wp3 || wp3 < wp));
296 }
297
298 {
299 shared_ptr<void> sp(new int);
300 weak_ptr<void> wp(sp);
301
302 weak_ptr<void> wp2(wp);
303 assert(wp2.use_count() == wp.use_count());
304 assert(wp2.use_count() == 1);
305 assert(!(wp < wp2 || wp2 < wp));
306
307 sp.reset();
308 assert(!(wp < wp2 || wp2 < wp));
309
310 weak_ptr<void> wp3(wp);
311 assert(wp3.use_count() == wp.use_count());
312 assert(wp3.use_count() == 0);
313 assert(!(wp < wp3 || wp3 < wp));
314 }
315
316 {
319
320 weak_ptr<incomplete> wp2(wp);
321 assert(wp2.use_count() == wp.use_count());
322 assert(wp2.use_count() == 1);
323 assert(!(wp < wp2 || wp2 < wp));
324
325 sp.reset();
326 assert(!(wp < wp2 || wp2 < wp));
327
328 weak_ptr<incomplete> wp3(wp);
329 assert(wp3.use_count() == wp.use_count());
330 assert(wp3.use_count() == 0);
331 assert(!(wp < wp3 || wp3 < wp));
332 }
333}
334
335void
337{
338 {
339 weak_ptr<int> wp;
340 weak_ptr<void> wp2(wp);
341 assert(wp2.use_count() == wp.use_count());
342 assert(wp2.use_count() == 0);
343 }
344
345 {
347 weak_ptr<void> wp2(wp);
348 assert(wp2.use_count() == wp.use_count());
349 assert(wp2.use_count() == 0);
350 }
351
352 {
353 weak_ptr<Z> wp;
354
355 weak_ptr<X> wp2(wp);
356 assert(wp2.use_count() == wp.use_count());
357 assert(wp2.use_count() == 0);
358
359 weak_ptr<Y> wp3(wp);
360 assert(wp3.use_count() == wp.use_count());
361 assert(wp3.use_count() == 0);
362 }
363
364 {
365 shared_ptr<int> sp(static_cast<int*>(0));
366 weak_ptr<int> wp(sp);
367
368 weak_ptr<void> wp2(wp);
369 assert(wp2.use_count() == wp.use_count());
370 assert(wp2.use_count() == 1);
371 assert(!(wp < wp2 || wp2 < wp));
372
373 sp.reset();
374 assert(!(wp < wp2 || wp2 < wp));
375
376 weak_ptr<void> wp3(wp);
377 assert(wp3.use_count() == wp.use_count());
378 assert(wp3.use_count() == 0);
379 assert(!(wp < wp3 || wp3 < wp));
380 }
381
382 {
383 shared_ptr<int> sp(new int);
384 weak_ptr<int> wp(sp);
385
386 weak_ptr<void> wp2(wp);
387 assert(wp2.use_count() == wp.use_count());
388 assert(wp2.use_count() == 1);
389 assert(!(wp < wp2 || wp2 < wp));
390
391 sp.reset();
392 assert(!(wp < wp2 || wp2 < wp));
393
394 weak_ptr<void> wp3(wp);
395 assert(wp3.use_count() == wp.use_count());
396 assert(wp3.use_count() == 0);
397 assert(!(wp < wp3 || wp3 < wp));
398 }
399
400 {
403
404 weak_ptr<void> wp2(wp);
405 assert(wp2.use_count() == wp.use_count());
406 assert(wp2.use_count() == 1);
407 assert(!(wp < wp2 || wp2 < wp));
408
409 sp.reset();
410 assert(!(wp < wp2 || wp2 < wp));
411
412 weak_ptr<void> wp3(wp);
413 assert(wp3.use_count() == wp.use_count());
414 assert(wp3.use_count() == 0);
415 assert(!(wp < wp3 || wp3 < wp));
416 }
417
418 {
419 shared_ptr<Z> sp(static_cast<Z*>(0));
420 weak_ptr<Z> wp(sp);
421
422 weak_ptr<X> wp2(wp);
423 assert(wp2.use_count() == wp.use_count());
424 assert(wp2.use_count() == 1);
425 assert(!(wp < wp2 || wp2 < wp));
426
427 sp.reset();
428 assert(!(wp < wp2 || wp2 < wp));
429
430 weak_ptr<X> wp3(wp);
431 assert(wp3.use_count() == wp.use_count());
432 assert(wp3.use_count() == 0);
433 assert(!(wp < wp3 || wp3 < wp));
434 }
435
436 {
437 shared_ptr<Z> sp(static_cast<Z*>(0));
438 weak_ptr<Z> wp(sp);
439
440 weak_ptr<Y> wp2(wp);
441 assert(wp2.use_count() == wp.use_count());
442 assert(wp2.use_count() == 1);
443 assert(!(wp < wp2 || wp2 < wp));
444
445 sp.reset();
446 assert(!(wp < wp2 || wp2 < wp));
447
448 weak_ptr<Y> wp3(wp);
449 assert(wp3.use_count() == wp.use_count());
450 assert(wp3.use_count() == 0);
451 assert(!(wp < wp3 || wp3 < wp));
452 }
453
454 {
455 shared_ptr<Z> sp(new Z);
456 weak_ptr<Z> wp(sp);
457
458 weak_ptr<X> wp2(wp);
459 assert(wp2.use_count() == wp.use_count());
460 assert(wp2.use_count() == 1);
461 assert(!(wp < wp2 || wp2 < wp));
462
463 sp.reset();
464 assert(!(wp < wp2 || wp2 < wp));
465
466 weak_ptr<X> wp3(wp);
467 assert(wp3.use_count() == wp.use_count());
468 assert(wp3.use_count() == 0);
469 assert(!(wp < wp3 || wp3 < wp));
470 }
471
472 {
473 shared_ptr<Z> sp(new Z);
474 weak_ptr<Z> wp(sp);
475
476 weak_ptr<Y> wp2(wp);
477 assert(wp2.use_count() == wp.use_count());
478 assert(wp2.use_count() == 1);
479 assert(!(wp < wp2 || wp2 < wp));
480
481 sp.reset();
482 assert(!(wp < wp2 || wp2 < wp));
483
484 weak_ptr<Y> wp3(wp);
485 assert(wp3.use_count() == wp.use_count());
486 assert(wp3.use_count() == 0);
487 assert(!(wp < wp3 || wp3 < wp));
488 }
489}
490
491void
492 test()
493{
498}
499
500} // namespace n_constructors
501
502namespace n_assignment
503{
504
505template< class T >
506 void
508{
509 assert(sp.unique());
510
511 weak_ptr<T> p1;
512
513 p1 = p1;
514 assert(p1.use_count() == 0);
515
516 weak_ptr<T> p2;
517
518 p1 = p2;
519 assert(p1.use_count() == 0);
520
521 weak_ptr<T> p3(p1);
522
523 p1 = p3;
524 assert(p1.use_count() == 0);
525
526 weak_ptr<T> p4(sp);
527
528 p4 = p4;
529 assert(p4.use_count() == 1);
530
531 p1 = p4;
532 assert(p1.use_count() == 1);
533
534 p4 = p2;
535 assert(p4.use_count() == 0);
536
537 sp.reset();
538
539 p1 = p1;
540 assert(p1.use_count() == 0);
541
542 p4 = p1;
543 assert(p4.use_count() == 0);
544}
545
546void
548{
549 {
551
553
554 p1 = p2;
555 assert(p1.use_count() == 0);
556
559
560 p1 = p3;
561 assert(p1.use_count() == 1);
562
563 sp.reset();
564
565 p1 = p3;
566 assert(p1.use_count() == 0);
567
568 p1 = p2;
569 assert(p1.use_count() == 0);
570 }
571
572 {
573 weak_ptr<X> p1;
574
575 weak_ptr<Z> p2;
576
577 p1 = p2;
578 assert(p1.use_count() == 0);
579
580 shared_ptr<Z> sp(new Z);
581 weak_ptr<Z> p3(sp);
582
583 p1 = p3;
584 assert(p1.use_count() == 1);
585
586 sp.reset();
587
588 p1 = p3;
589 assert(p1.use_count() == 0);
590
591 p1 = p2;
592 assert(p1.use_count() == 0);
593 }
594
595 {
596 weak_ptr<Y> p1;
597
598 weak_ptr<Z> p2;
599
600 p1 = p2;
601 assert(p1.use_count() == 0);
602
603 shared_ptr<Z> sp(new Z);
604 weak_ptr<Z> p3(sp);
605
606 p1 = p3;
607 assert(p1.use_count() == 1);
608
609 sp.reset();
610
611 p1 = p3;
612 assert(p1.use_count() == 0);
613
614 p1 = p2;
615 assert(p1.use_count() == 0);
616 }
617}
618
619template< class T, class U >
620 void
622{
623 assert(sp.unique());
624
625 weak_ptr<T> p1;
626 weak_ptr<T> p2(p1);
627 weak_ptr<T> p3(sp);
628 weak_ptr<T> p4(p3);
629
630 p1 = sp;
631 assert(p1.use_count() == 1);
632
633 p2 = sp;
634 assert(p2.use_count() == 1);
635
636 p3 = sp;
637 assert(p3.use_count() == 1);
638
639 p4 = sp;
640 assert(p4.use_count() == 1);
641
642 sp.reset();
643
644 assert(p1.use_count() == 0);
645 assert(p2.use_count() == 0);
646 assert(p3.use_count() == 0);
647 assert(p4.use_count() == 0);
648
649 p1 = sp;
650}
651
652void
653 test()
654{
655 {
656 shared_ptr<int> p( new int );
657 copy_assignment( p );
658 }
659
660 {
661 shared_ptr<X> p( new X );
662 copy_assignment( p );
663 }
664
665 {
666 shared_ptr<void> p( new int );
667 copy_assignment( p );
668 }
669
670 {
672 copy_assignment( p );
673 }
674
676
677 {
678 shared_ptr<int> p( new int );
679 shared_ptr_assignment<int>( p );
680 }
681
682 {
683 shared_ptr<int> p( new int );
684 shared_ptr_assignment<void>( p );
685 }
686
687 {
688 shared_ptr<X> p( new X );
689 shared_ptr_assignment<X>( p );
690 }
691
692 {
693 shared_ptr<X> p( new X );
694 shared_ptr_assignment<void>( p );
695 }
696
697 {
698 shared_ptr<void> p( new int );
699 shared_ptr_assignment<void>( p );
700 }
701
702 {
704 shared_ptr_assignment<incomplete>( p );
705 }
706
707 {
709 shared_ptr_assignment<void>( p );
710 }
711}
712
713} // namespace n_assignment
714
715namespace n_reset
716{
717
718template< class T, class U >
719 void
720 test2( shared_ptr<U> & sp, T * = 0 )
721{
722 assert(sp.unique());
723
724 weak_ptr<T> p1;
725 weak_ptr<T> p2(p1);
726 weak_ptr<T> p3(sp);
727 weak_ptr<T> p4(p3);
728 weak_ptr<T> p5(sp);
729 weak_ptr<T> p6(p5);
730
731 p1.reset();
732 assert(p1.use_count() == 0);
733
734 p2.reset();
735 assert(p2.use_count() == 0);
736
737 p3.reset();
738 assert(p3.use_count() == 0);
739
740 p4.reset();
741 assert(p4.use_count() == 0);
742
743 sp.reset();
744
745 p5.reset();
746 assert(p5.use_count() == 0);
747
748 p6.reset();
749 assert(p6.use_count() == 0);
750}
751
752void
753 test()
754{
755 {
756 shared_ptr<int> p( new int );
757 test2<int>( p );
758 }
759
760 {
761 shared_ptr<int> p( new int );
762 test2<void>( p );
763 }
764
765 {
766 shared_ptr<X> p( new X );
767 test2<X>( p );
768 }
769
770 {
771 shared_ptr<X> p( new X );
772 test2<void>( p );
773 }
774
775 {
776 shared_ptr<void> p( new int );
777 test2<void>( p );
778 }
779
780 {
782 test2<incomplete>( p );
783 }
784
785 {
787 test2<void>( p );
788 }
789}
790
791} // namespace n_reset
792
793namespace n_use_count
794{
795
796void
797 test()
798{
799 {
800 weak_ptr<X> wp;
801 assert(wp.use_count() == 0);
802 assert(wp.expired());
803
804 weak_ptr<X> wp2;
805 assert(wp.use_count() == 0);
806 assert(wp.expired());
807
808 weak_ptr<X> wp3(wp);
809 assert(wp.use_count() == 0);
810 assert(wp.expired());
811 assert(wp3.use_count() == 0);
812 assert(wp3.expired());
813 }
814
815 {
816 shared_ptr<X> sp(static_cast<X*>(0));
817
818 weak_ptr<X> wp(sp);
819 assert(wp.use_count() == 1);
820 assert(!wp.expired());
821
822 weak_ptr<X> wp2(sp);
823 assert(wp.use_count() == 1);
824 assert(!wp.expired());
825
826 weak_ptr<X> wp3(wp);
827 assert(wp.use_count() == 1);
828 assert(!wp.expired());
829 assert(wp3.use_count() == 1);
830 assert(!wp3.expired());
831
832 shared_ptr<X> sp2(sp);
833
834 assert(wp.use_count() == 2);
835 assert(!wp.expired());
836 assert(wp2.use_count() == 2);
837 assert(!wp2.expired());
838 assert(wp3.use_count() == 2);
839 assert(!wp3.expired());
840
841 shared_ptr<void> sp3(sp);
842
843 assert(wp.use_count() == 3);
844 assert(!wp.expired());
845 assert(wp2.use_count() == 3);
846 assert(!wp2.expired());
847 assert(wp3.use_count() == 3);
848 assert(!wp3.expired());
849
850 sp.reset();
851
852 assert(wp.use_count() == 2);
853 assert(!wp.expired());
854 assert(wp2.use_count() == 2);
855 assert(!wp2.expired());
856 assert(wp3.use_count() == 2);
857 assert(!wp3.expired());
858
859 sp2.reset();
860
861 assert(wp.use_count() == 1);
862 assert(!wp.expired());
863 assert(wp2.use_count() == 1);
864 assert(!wp2.expired());
865 assert(wp3.use_count() == 1);
866 assert(!wp3.expired());
867
868 sp3.reset();
869
870 assert(wp.use_count() == 0);
871 assert(wp.expired());
872 assert(wp2.use_count() == 0);
873 assert(wp2.expired());
874 assert(wp3.use_count() == 0);
875 assert(wp3.expired());
876 }
877}
878
879} // namespace n_use_count
880
881namespace n_swap
882{
883
884void
885 test()
886{
887 {
888 weak_ptr<X> wp;
889 weak_ptr<X> wp2;
890
891 wp.swap(wp2);
892
893 assert(wp.use_count() == 0);
894 assert(wp2.use_count() == 0);
895
896 using std::swap;
897 swap(wp, wp2);
898
899 assert(wp.use_count() == 0);
900 assert(wp2.use_count() == 0);
901 }
902
903 {
904 shared_ptr<X> sp(new X);
905 weak_ptr<X> wp;
906 weak_ptr<X> wp2(sp);
907 weak_ptr<X> wp3(sp);
908
909 wp.swap(wp2);
910
911 assert(wp.use_count() == 1);
912 assert(wp2.use_count() == 0);
913 assert(!(wp < wp3 || wp3 < wp));
914
915 using std::swap;
916 swap(wp, wp2);
917
918 assert(wp.use_count() == 0);
919 assert(wp2.use_count() == 1);
920 assert(!(wp2 < wp3 || wp3 < wp2));
921
922 sp.reset();
923
924 wp.swap(wp2);
925
926 assert(wp.use_count() == 0);
927 assert(wp2.use_count() == 0);
928 assert(!(wp < wp3 || wp3 < wp));
929
930 using std::swap;
931 swap(wp, wp2);
932
933 assert(wp.use_count() == 0);
934 assert(wp2.use_count() == 0);
935 assert(!(wp2 < wp3 || wp3 < wp2));
936 }
937
938 {
939 shared_ptr<X> sp(new X);
940 shared_ptr<X> sp2(new X);
941 weak_ptr<X> wp(sp);
942 weak_ptr<X> wp2(sp2);
943 weak_ptr<X> wp3(sp2);
944
945 wp.swap(wp2);
946
947 assert(wp.use_count() == 1);
948 assert(wp2.use_count() == 1);
949 assert(!(wp < wp3 || wp3 < wp));
950
951 using std::swap;
952 swap(wp, wp2);
953
954 assert(wp.use_count() == 1);
955 assert(wp2.use_count() == 1);
956 assert(!(wp2 < wp3 || wp3 < wp2));
957
958 sp.reset();
959
960 wp.swap(wp2);
961
962 assert(wp.use_count() == 1);
963 assert(wp2.use_count() == 0);
964 assert(!(wp < wp3 || wp3 < wp));
965
966 using std::swap;
967 swap(wp, wp2);
968
969 assert(wp.use_count() == 0);
970 assert(wp2.use_count() == 1);
971 assert(!(wp2 < wp3 || wp3 < wp2));
972
973 sp2.reset();
974
975 wp.swap(wp2);
976
977 assert(wp.use_count() == 0);
978 assert(wp2.use_count() == 0);
979 assert(!(wp < wp3 || wp3 < wp));
980
981 using std::swap;
982 swap(wp, wp2);
983
984 assert(wp.use_count() == 0);
985 assert(wp2.use_count() == 0);
986 assert(!(wp2 < wp3 || wp3 < wp2));
987 }
988}
989
990} // namespace n_swap
991
992namespace n_comparison
993{
994
995void
996 test()
997{
998 {
999 weak_ptr<X> wp;
1000 assert(!(wp < wp));
1001
1002 weak_ptr<X> wp2;
1003 assert(!(wp < wp2 && wp2 < wp));
1004
1005 weak_ptr<X> wp3(wp);
1006 assert(!(wp3 < wp3));
1007 assert(!(wp < wp3 && wp3 < wp));
1008 }
1009
1010 {
1011 shared_ptr<X> sp(new X);
1012
1013 weak_ptr<X> wp(sp);
1014 assert(!(wp < wp));
1015
1016 weak_ptr<X> wp2;
1017 assert(wp < wp2 || wp2 < wp);
1018 assert(!(wp < wp2 && wp2 < wp));
1019
1020 bool b1 = wp < wp2;
1021 bool b2 = wp2 < wp;
1022
1023 {
1024 weak_ptr<X> wp3(wp);
1025
1026 assert(!(wp < wp3 || wp3 < wp));
1027 assert(!(wp < wp3 && wp3 < wp));
1028
1029 assert(wp2 < wp3 || wp3 < wp2);
1030 assert(!(wp2 < wp3 && wp3 < wp2));
1031
1032 weak_ptr<X> wp4(wp2);
1033
1034 assert(wp4 < wp3 || wp3 < wp4);
1035 assert(!(wp4 < wp3 && wp3 < wp4));
1036 }
1037
1038 sp.reset();
1039
1040 assert(b1 == (wp < wp2));
1041 assert(b2 == (wp2 < wp));
1042
1043 {
1044 weak_ptr<X> wp3(wp);
1045
1046 assert(!(wp < wp3 || wp3 < wp));
1047 assert(!(wp < wp3 && wp3 < wp));
1048
1049 assert(wp2 < wp3 || wp3 < wp2);
1050 assert(!(wp2 < wp3 && wp3 < wp2));
1051
1052 weak_ptr<X> wp4(wp2);
1053
1054 assert(wp4 < wp3 || wp3 < wp4);
1055 assert(!(wp4 < wp3 && wp3 < wp4));
1056 }
1057 }
1058
1059 {
1060 shared_ptr<X> sp(new X);
1061 shared_ptr<X> sp2(new X);
1062
1063 weak_ptr<X> wp(sp);
1064 weak_ptr<X> wp2(sp2);
1065
1066 assert(wp < wp2 || wp2 < wp);
1067 assert(!(wp < wp2 && wp2 < wp));
1068
1069 bool b1 = wp < wp2;
1070 bool b2 = wp2 < wp;
1071
1072 {
1073 weak_ptr<X> wp3(wp);
1074
1075 assert(!(wp < wp3 || wp3 < wp));
1076 assert(!(wp < wp3 && wp3 < wp));
1077
1078 assert(wp2 < wp3 || wp3 < wp2);
1079 assert(!(wp2 < wp3 && wp3 < wp2));
1080
1081 weak_ptr<X> wp4(wp2);
1082
1083 assert(wp4 < wp3 || wp3 < wp4);
1084 assert(!(wp4 < wp3 && wp3 < wp4));
1085 }
1086
1087 sp.reset();
1088
1089 assert(b1 == (wp < wp2));
1090 assert(b2 == (wp2 < wp));
1091
1092 {
1093 weak_ptr<X> wp3(wp);
1094
1095 assert(!(wp < wp3 || wp3 < wp));
1096 assert(!(wp < wp3 && wp3 < wp));
1097
1098 assert(wp2 < wp3 || wp3 < wp2);
1099 assert(!(wp2 < wp3 && wp3 < wp2));
1100
1101 weak_ptr<X> wp4(wp2);
1102
1103 assert(wp4 < wp3 || wp3 < wp4);
1104 assert(!(wp4 < wp3 && wp3 < wp4));
1105 }
1106
1107 sp2.reset();
1108
1109 assert(b1 == (wp < wp2));
1110 assert(b2 == (wp2 < wp));
1111
1112 {
1113 weak_ptr<X> wp3(wp);
1114
1115 assert(!(wp < wp3 || wp3 < wp));
1116 assert(!(wp < wp3 && wp3 < wp));
1117
1118 assert(wp2 < wp3 || wp3 < wp2);
1119 assert(!(wp2 < wp3 && wp3 < wp2));
1120
1121 weak_ptr<X> wp4(wp2);
1122
1123 assert(wp4 < wp3 || wp3 < wp4);
1124 assert(!(wp4 < wp3 && wp3 < wp4));
1125 }
1126 }
1127
1128 {
1129 shared_ptr<X> sp(new X);
1130 shared_ptr<X> sp2(sp);
1131
1132 weak_ptr<X> wp(sp);
1133 weak_ptr<X> wp2(sp2);
1134
1135 assert(!(wp < wp2 || wp2 < wp));
1136 assert(!(wp < wp2 && wp2 < wp));
1137
1138 bool b1 = wp < wp2;
1139 bool b2 = wp2 < wp;
1140
1141 {
1142 weak_ptr<X> wp3(wp);
1143
1144 assert(!(wp < wp3 || wp3 < wp));
1145 assert(!(wp < wp3 && wp3 < wp));
1146
1147 assert(!(wp2 < wp3 || wp3 < wp2));
1148 assert(!(wp2 < wp3 && wp3 < wp2));
1149
1150 weak_ptr<X> wp4(wp2);
1151
1152 assert(!(wp4 < wp3 || wp3 < wp4));
1153 assert(!(wp4 < wp3 && wp3 < wp4));
1154 }
1155
1156 sp.reset();
1157 sp2.reset();
1158
1159 assert(b1 == (wp < wp2));
1160 assert(b2 == (wp2 < wp));
1161
1162 {
1163 weak_ptr<X> wp3(wp);
1164
1165 assert(!(wp < wp3 || wp3 < wp));
1166 assert(!(wp < wp3 && wp3 < wp));
1167
1168 assert(!(wp2 < wp3 || wp3 < wp2));
1169 assert(!(wp2 < wp3 && wp3 < wp2));
1170
1171 weak_ptr<X> wp4(wp2);
1172
1173 assert(!(wp4 < wp3 || wp3 < wp4));
1174 assert(!(wp4 < wp3 && wp3 < wp4));
1175 }
1176 }
1177
1178 {
1179 shared_ptr<X> spx(new X);
1180 shared_ptr<Y> spy(new Y);
1181 shared_ptr<Z> spz(new Z);
1182
1183 weak_ptr<X> px(spx);
1184 weak_ptr<Y> py(spy);
1185 weak_ptr<Z> pz(spz);
1186
1187 assert(px < py || py < px);
1188 assert(px < pz || pz < px);
1189 assert(py < pz || pz < py);
1190
1191 assert(!(px < py && py < px));
1192 assert(!(px < pz && pz < px));
1193 assert(!(py < pz && pz < py));
1194
1195 weak_ptr<void> pvx(px);
1196 assert(!(pvx < pvx));
1197
1198 weak_ptr<void> pvy(py);
1199 assert(!(pvy < pvy));
1200
1201 weak_ptr<void> pvz(pz);
1202 assert(!(pvz < pvz));
1203
1204 assert(pvx < pvy || pvy < pvx);
1205 assert(pvx < pvz || pvz < pvx);
1206 assert(pvy < pvz || pvz < pvy);
1207
1208 assert(!(pvx < pvy && pvy < pvx));
1209 assert(!(pvx < pvz && pvz < pvx));
1210 assert(!(pvy < pvz && pvz < pvy));
1211
1212 spx.reset();
1213 spy.reset();
1214 spz.reset();
1215
1216 assert(px < py || py < px);
1217 assert(px < pz || pz < px);
1218 assert(py < pz || pz < py);
1219
1220 assert(!(px < py && py < px));
1221 assert(!(px < pz && pz < px));
1222 assert(!(py < pz && pz < py));
1223
1224 assert(!(pvx < pvx));
1225 assert(!(pvy < pvy));
1226 assert(!(pvz < pvz));
1227
1228 assert(pvx < pvy || pvy < pvx);
1229 assert(pvx < pvz || pvz < pvx);
1230 assert(pvy < pvz || pvz < pvy);
1231
1232 assert(!(pvx < pvy && pvy < pvx));
1233 assert(!(pvx < pvz && pvz < pvx));
1234 assert(!(pvy < pvz && pvz < pvy));
1235 }
1236
1237 {
1238 shared_ptr<Z> spz(new Z);
1239 shared_ptr<X> spx(spz);
1240
1241 weak_ptr<Z> pz(spz);
1242 weak_ptr<X> px(spx);
1243 weak_ptr<Y> py(spz);
1244
1245 assert(!(px < px));
1246 assert(!(py < py));
1247
1248 assert(!(px < py || py < px));
1249 assert(!(px < pz || pz < px));
1250 assert(!(py < pz || pz < py));
1251
1252 weak_ptr<void> pvx(px);
1253 weak_ptr<void> pvy(py);
1254 weak_ptr<void> pvz(pz);
1255
1256 assert(!(pvx < pvy || pvy < pvx));
1257 assert(!(pvx < pvz || pvz < pvx));
1258 assert(!(pvy < pvz || pvz < pvy));
1259
1260 spx.reset();
1261 spz.reset();
1262
1263 assert(!(px < px));
1264 assert(!(py < py));
1265
1266 assert(!(px < py || py < px));
1267 assert(!(px < pz || pz < px));
1268 assert(!(py < pz || pz < py));
1269
1270 assert(!(pvx < pvy || pvy < pvx));
1271 assert(!(pvx < pvz || pvz < pvx));
1272 assert(!(pvy < pvz || pvz < pvy));
1273 }
1274}
1275
1276} // namespace n_comparison
1277
1278namespace n_lock
1279{
1280
1281void
1283{
1284}
1285
1286} // namespace n_lock
1287
1288namespace n_map
1289{
1290
1291void
1292 test()
1293{
1294 std::vector< shared_ptr<int> > vi;
1295
1296 {
1297 shared_ptr<int> pi1(new int);
1298 shared_ptr<int> pi2(new int);
1299 shared_ptr<int> pi3(new int);
1300
1301 vi.push_back(pi1);
1302 vi.push_back(pi1);
1303 vi.push_back(pi1);
1304 vi.push_back(pi2);
1305 vi.push_back(pi1);
1306 vi.push_back(pi2);
1307 vi.push_back(pi1);
1308 vi.push_back(pi3);
1309 vi.push_back(pi3);
1310 vi.push_back(pi2);
1311 vi.push_back(pi1);
1312 }
1313
1314 std::vector< shared_ptr<X> > vx;
1315
1316 {
1317 shared_ptr<X> px1(new X);
1318 shared_ptr<X> px2(new X);
1319 shared_ptr<X> px3(new X);
1320
1321 vx.push_back(px2);
1322 vx.push_back(px2);
1323 vx.push_back(px1);
1324 vx.push_back(px2);
1325 vx.push_back(px1);
1326 vx.push_back(px1);
1327 vx.push_back(px1);
1328 vx.push_back(px2);
1329 vx.push_back(px1);
1330 vx.push_back(px3);
1331 vx.push_back(px2);
1332 }
1333
1334 std::map< weak_ptr<void>, long > m;
1335
1336 {
1337 for(std::vector< shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i)
1338 {
1339 ++m[*i];
1340 }
1341 }
1342
1343 {
1344 for(std::vector< shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i)
1345 {
1346 ++m[*i];
1347 }
1348 }
1349
1350 {
1351 for(std::map< weak_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
1352 {
1353 assert(i->first.use_count() == i->second);
1354 }
1355 }
1356}
1357
1358} // namespace n_map
1359
1360int main()
1361{
1365 n_reset::test();
1367 n_swap::test();
1369 n_lock::test();
1370
1371 n_map::test();
1372
1373 return 0;
1374}
1375
1377{ };
1378
1381{
1383 return px;
1384}
void swap(this_type &other)
void test2()
void swap(shared_ptr< P > &, shared_ptr< P > &)
void conversion_assignment()
void shared_ptr_assignment(shared_ptr< U > &sp, T *=0)
void shared_ptr_constructor()
void conversion_constructor()
void default_constructor()
void f(int &)
void test()
void test()
void test()
int dummy
int dummy2
shared_ptr< incomplete > create_incomplete()
int main()