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 
23 using namespace CLHEP;
24 using CLHEP::shared_ptr;
25 using 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 
33 namespace n_element_type
34 {
35 
36 void
37  f(int &)
38 { }
39 
40 void
41  test()
42 {
44  T t;
45  f(t);
46 }
47 
48 } // namespace n_element_type
49 
50 class incomplete;
51 
53 
54 struct X
55 {
56  int dummy;
57 };
58 
59 struct Y
60 {
61  int dummy2;
62 };
63 
64 struct Z
65  : public X, public virtual Y
66 { };
67 
68 namespace n_constructors
69 {
70 
71 void
73 {
74  {
75  weak_ptr<int> wp;
76  assert(wp.use_count() == 0);
77  }
78 
79  {
80  weak_ptr<void> wp;
81  assert(wp.use_count() == 0);
82  }
83 
84  {
86  assert(wp.use_count() == 0);
87  }
88 }
89 
90 void
92 {
93  {
94  shared_ptr<int> sp;
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  {
148  shared_ptr<void> sp;
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 
179  weak_ptr<incomplete> wp(sp);
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  {
190  weak_ptr<incomplete> wp(sp);
191  assert(wp.use_count() == sp.use_count());
192  assert(wp.use_count() == 1);
193  shared_ptr<incomplete> sp2(wp);
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 
220 void
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  {
231  weak_ptr<void> wp;
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  {
318  weak_ptr<incomplete> wp(sp);
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 
335 void
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  {
402  weak_ptr<incomplete> wp(sp);
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 
491 void
492  test()
493 {
498 }
499 
500 } // namespace n_constructors
501 
502 namespace n_assignment
503 {
504 
505 template< 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 
546 void
548 {
549  {
550  weak_ptr<void> p1;
551 
553 
554  p1 = p2;
555  assert(p1.use_count() == 0);
556 
558  weak_ptr<incomplete> p3(sp);
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 
619 template< 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 
652 void
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 
715 namespace n_reset
716 {
717 
718 template< 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 
752 void
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 
793 namespace n_use_count
794 {
795 
796 void
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 
881 namespace n_swap
882 {
883 
884 void
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 
992 namespace n_comparison
993 {
994 
995 void
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 
1278 namespace n_lock
1279 {
1280 
1281 void
1283 {
1284 }
1285 
1286 } // namespace n_lock
1287 
1288 namespace n_map
1289 {
1290 
1291 void
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 
1360 int 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 test2()
Definition: excDblThrow.cc:48
void test()
void conversion_constructor()
Definition: testWeakPtr.cc:336
int dummy2
Definition: testWeakPtr.cc:61
shared_ptr< incomplete > create_incomplete()
void conversion_assignment()
void copy_assignment()
void test()
void swap(this_type &other)
void default_constructor()
void f(void g())
Definition: excDblThrow.cc:38
void test()
void test()
void copy_constructor()
void shared_ptr_constructor()
Definition: testWeakPtr.cc:91
int dummy
Definition: testWeakPtr.cc:56
void swap(shared_ptr< P > &, shared_ptr< P > &)
int main()
Definition: testBug66214.cc:30
void shared_ptr_assignment(shared_ptr< U > &sp, T *=0)
Definition: testWeakPtr.cc:621