CLHEP VERSION Reference Documentation
CLHEP Home Page CLHEP Documentation CLHEP Bug Reports |
00001 // ====================================================================== 00002 // 00003 // Test compilability and basic functionality of Utility/memory.h 00004 // 00005 // Author: W. E. Brown, 2010-03-19, adapted from the boost library's 00006 // shared_ptr and related functionality whose internal attributions bear 00007 // the following various notices: 00008 // 00009 // Copyright (c) 2002-2005 Peter Dimov 00010 // Distributed under the Boost Software License, Version 1.0. 00011 // See http://www.boost.org/LICENSE_1_0.txt 00012 // 00013 // ====================================================================== 00014 00015 00016 #include "CLHEP/Utility/memory.h" 00017 00018 #include <cassert> 00019 #include <map> 00020 #include <vector> 00021 00022 00023 using namespace CLHEP; 00024 using CLHEP::shared_ptr; 00025 using CLHEP::weak_ptr; 00026 00027 00028 #if defined(_MSC_VER) && (_MSC_VER >= 1310) 00029 # pragma warning (disable : 4675) // suppress ADL warning 00030 #endif 00031 00032 00033 namespace n_element_type 00034 { 00035 00036 void 00037 f(int &) 00038 { } 00039 00040 void 00041 test() 00042 { 00043 typedef weak_ptr<int>::element_type T; 00044 T t; 00045 f(t); 00046 } 00047 00048 } // namespace n_element_type 00049 00050 class incomplete; 00051 00052 shared_ptr<incomplete> create_incomplete(); 00053 00054 struct X 00055 { 00056 int dummy; 00057 }; 00058 00059 struct Y 00060 { 00061 int dummy2; 00062 }; 00063 00064 struct Z 00065 : public X, public virtual Y 00066 { }; 00067 00068 namespace n_constructors 00069 { 00070 00071 void 00072 default_constructor() 00073 { 00074 { 00075 weak_ptr<int> wp; 00076 assert(wp.use_count() == 0); 00077 } 00078 00079 { 00080 weak_ptr<void> wp; 00081 assert(wp.use_count() == 0); 00082 } 00083 00084 { 00085 weak_ptr<incomplete> wp; 00086 assert(wp.use_count() == 0); 00087 } 00088 } 00089 00090 void 00091 shared_ptr_constructor() 00092 { 00093 { 00094 shared_ptr<int> sp; 00095 00096 weak_ptr<int> wp(sp); 00097 assert(wp.use_count() == sp.use_count()); 00098 00099 weak_ptr<void> wp2(sp); 00100 assert(wp2.use_count() == sp.use_count()); 00101 } 00102 00103 { 00104 shared_ptr<int> sp(static_cast<int*>(0)); 00105 00106 { 00107 weak_ptr<int> wp(sp); 00108 assert(wp.use_count() == sp.use_count()); 00109 assert(wp.use_count() == 1); 00110 shared_ptr<int> sp2(wp); 00111 assert(wp.use_count() == 2); 00112 assert(!(sp < sp2 || sp2 < sp)); 00113 } 00114 00115 { 00116 weak_ptr<void> wp(sp); 00117 assert(wp.use_count() == sp.use_count()); 00118 assert(wp.use_count() == 1); 00119 shared_ptr<void> sp2(wp); 00120 assert(wp.use_count() == 2); 00121 assert(!(sp < sp2 || sp2 < sp)); 00122 } 00123 } 00124 00125 { 00126 shared_ptr<int> sp(new int); 00127 00128 { 00129 weak_ptr<int> wp(sp); 00130 assert(wp.use_count() == sp.use_count()); 00131 assert(wp.use_count() == 1); 00132 shared_ptr<int> sp2(wp); 00133 assert(wp.use_count() == 2); 00134 assert(!(sp < sp2 || sp2 < sp)); 00135 } 00136 00137 { 00138 weak_ptr<void> wp(sp); 00139 assert(wp.use_count() == sp.use_count()); 00140 assert(wp.use_count() == 1); 00141 shared_ptr<void> sp2(wp); 00142 assert(wp.use_count() == 2); 00143 assert(!(sp < sp2 || sp2 < sp)); 00144 } 00145 } 00146 00147 { 00148 shared_ptr<void> sp; 00149 00150 weak_ptr<void> wp(sp); 00151 assert(wp.use_count() == sp.use_count()); 00152 } 00153 00154 { 00155 shared_ptr<void> sp(static_cast<int*>(0)); 00156 00157 weak_ptr<void> wp(sp); 00158 assert(wp.use_count() == sp.use_count()); 00159 assert(wp.use_count() == 1); 00160 shared_ptr<void> sp2(wp); 00161 assert(wp.use_count() == 2); 00162 assert(!(sp < sp2 || sp2 < sp)); 00163 } 00164 00165 { 00166 shared_ptr<void> sp(new int); 00167 00168 weak_ptr<void> wp(sp); 00169 assert(wp.use_count() == sp.use_count()); 00170 assert(wp.use_count() == 1); 00171 shared_ptr<void> sp2(wp); 00172 assert(wp.use_count() == 2); 00173 assert(!(sp < sp2 || sp2 < sp)); 00174 } 00175 00176 { 00177 shared_ptr<incomplete> sp; 00178 00179 weak_ptr<incomplete> wp(sp); 00180 assert(wp.use_count() == sp.use_count()); 00181 00182 weak_ptr<void> wp2(sp); 00183 assert(wp2.use_count() == sp.use_count()); 00184 } 00185 00186 { 00187 shared_ptr<incomplete> sp = create_incomplete(); 00188 00189 { 00190 weak_ptr<incomplete> wp(sp); 00191 assert(wp.use_count() == sp.use_count()); 00192 assert(wp.use_count() == 1); 00193 shared_ptr<incomplete> sp2(wp); 00194 assert(wp.use_count() == 2); 00195 assert(!(sp < sp2 || sp2 < sp)); 00196 } 00197 00198 { 00199 weak_ptr<void> wp(sp); 00200 assert(wp.use_count() == sp.use_count()); 00201 assert(wp.use_count() == 1); 00202 shared_ptr<void> sp2(wp); 00203 assert(wp.use_count() == 2); 00204 assert(!(sp < sp2 || sp2 < sp)); 00205 } 00206 } 00207 00208 { 00209 shared_ptr<void> sp = create_incomplete(); 00210 00211 weak_ptr<void> wp(sp); 00212 assert(wp.use_count() == sp.use_count()); 00213 assert(wp.use_count() == 1); 00214 shared_ptr<void> sp2(wp); 00215 assert(wp.use_count() == 2); 00216 assert(!(sp < sp2 || sp2 < sp)); 00217 } 00218 } 00219 00220 void 00221 copy_constructor() 00222 { 00223 { 00224 weak_ptr<int> wp; 00225 weak_ptr<int> wp2(wp); 00226 assert(wp2.use_count() == wp.use_count()); 00227 assert(wp2.use_count() == 0); 00228 } 00229 00230 { 00231 weak_ptr<void> wp; 00232 weak_ptr<void> wp2(wp); 00233 assert(wp2.use_count() == wp.use_count()); 00234 assert(wp2.use_count() == 0); 00235 } 00236 00237 { 00238 weak_ptr<incomplete> wp; 00239 weak_ptr<incomplete> wp2(wp); 00240 assert(wp2.use_count() == wp.use_count()); 00241 assert(wp2.use_count() == 0); 00242 } 00243 00244 { 00245 shared_ptr<int> sp(static_cast<int*>(0)); 00246 weak_ptr<int> wp(sp); 00247 00248 weak_ptr<int> wp2(wp); 00249 assert(wp2.use_count() == wp.use_count()); 00250 assert(wp2.use_count() == 1); 00251 assert(!(wp < wp2 || wp2 < wp)); 00252 00253 sp.reset(); 00254 assert(!(wp < wp2 || wp2 < wp)); 00255 00256 weak_ptr<int> wp3(wp); 00257 assert(wp3.use_count() == wp.use_count()); 00258 assert(wp3.use_count() == 0); 00259 assert(!(wp < wp3 || wp3 < wp)); 00260 } 00261 00262 { 00263 shared_ptr<int> sp(new int); 00264 weak_ptr<int> wp(sp); 00265 00266 weak_ptr<int> wp2(wp); 00267 assert(wp2.use_count() == wp.use_count()); 00268 assert(wp2.use_count() == 1); 00269 assert(!(wp < wp2 || wp2 < wp)); 00270 00271 sp.reset(); 00272 assert(!(wp < wp2 || wp2 < wp)); 00273 00274 weak_ptr<int> wp3(wp); 00275 assert(wp3.use_count() == wp.use_count()); 00276 assert(wp3.use_count() == 0); 00277 assert(!(wp < wp3 || wp3 < wp)); 00278 } 00279 00280 { 00281 shared_ptr<void> sp(static_cast<int*>(0)); 00282 weak_ptr<void> wp(sp); 00283 00284 weak_ptr<void> wp2(wp); 00285 assert(wp2.use_count() == wp.use_count()); 00286 assert(wp2.use_count() == 1); 00287 assert(!(wp < wp2 || wp2 < wp)); 00288 00289 sp.reset(); 00290 assert(!(wp < wp2 || wp2 < wp)); 00291 00292 weak_ptr<void> wp3(wp); 00293 assert(wp3.use_count() == wp.use_count()); 00294 assert(wp3.use_count() == 0); 00295 assert(!(wp < wp3 || wp3 < wp)); 00296 } 00297 00298 { 00299 shared_ptr<void> sp(new int); 00300 weak_ptr<void> wp(sp); 00301 00302 weak_ptr<void> wp2(wp); 00303 assert(wp2.use_count() == wp.use_count()); 00304 assert(wp2.use_count() == 1); 00305 assert(!(wp < wp2 || wp2 < wp)); 00306 00307 sp.reset(); 00308 assert(!(wp < wp2 || wp2 < wp)); 00309 00310 weak_ptr<void> wp3(wp); 00311 assert(wp3.use_count() == wp.use_count()); 00312 assert(wp3.use_count() == 0); 00313 assert(!(wp < wp3 || wp3 < wp)); 00314 } 00315 00316 { 00317 shared_ptr<incomplete> sp = create_incomplete(); 00318 weak_ptr<incomplete> wp(sp); 00319 00320 weak_ptr<incomplete> wp2(wp); 00321 assert(wp2.use_count() == wp.use_count()); 00322 assert(wp2.use_count() == 1); 00323 assert(!(wp < wp2 || wp2 < wp)); 00324 00325 sp.reset(); 00326 assert(!(wp < wp2 || wp2 < wp)); 00327 00328 weak_ptr<incomplete> wp3(wp); 00329 assert(wp3.use_count() == wp.use_count()); 00330 assert(wp3.use_count() == 0); 00331 assert(!(wp < wp3 || wp3 < wp)); 00332 } 00333 } 00334 00335 void 00336 conversion_constructor() 00337 { 00338 { 00339 weak_ptr<int> wp; 00340 weak_ptr<void> wp2(wp); 00341 assert(wp2.use_count() == wp.use_count()); 00342 assert(wp2.use_count() == 0); 00343 } 00344 00345 { 00346 weak_ptr<incomplete> wp; 00347 weak_ptr<void> wp2(wp); 00348 assert(wp2.use_count() == wp.use_count()); 00349 assert(wp2.use_count() == 0); 00350 } 00351 00352 { 00353 weak_ptr<Z> wp; 00354 00355 weak_ptr<X> wp2(wp); 00356 assert(wp2.use_count() == wp.use_count()); 00357 assert(wp2.use_count() == 0); 00358 00359 weak_ptr<Y> wp3(wp); 00360 assert(wp3.use_count() == wp.use_count()); 00361 assert(wp3.use_count() == 0); 00362 } 00363 00364 { 00365 shared_ptr<int> sp(static_cast<int*>(0)); 00366 weak_ptr<int> wp(sp); 00367 00368 weak_ptr<void> wp2(wp); 00369 assert(wp2.use_count() == wp.use_count()); 00370 assert(wp2.use_count() == 1); 00371 assert(!(wp < wp2 || wp2 < wp)); 00372 00373 sp.reset(); 00374 assert(!(wp < wp2 || wp2 < wp)); 00375 00376 weak_ptr<void> wp3(wp); 00377 assert(wp3.use_count() == wp.use_count()); 00378 assert(wp3.use_count() == 0); 00379 assert(!(wp < wp3 || wp3 < wp)); 00380 } 00381 00382 { 00383 shared_ptr<int> sp(new int); 00384 weak_ptr<int> wp(sp); 00385 00386 weak_ptr<void> wp2(wp); 00387 assert(wp2.use_count() == wp.use_count()); 00388 assert(wp2.use_count() == 1); 00389 assert(!(wp < wp2 || wp2 < wp)); 00390 00391 sp.reset(); 00392 assert(!(wp < wp2 || wp2 < wp)); 00393 00394 weak_ptr<void> wp3(wp); 00395 assert(wp3.use_count() == wp.use_count()); 00396 assert(wp3.use_count() == 0); 00397 assert(!(wp < wp3 || wp3 < wp)); 00398 } 00399 00400 { 00401 shared_ptr<incomplete> sp = create_incomplete(); 00402 weak_ptr<incomplete> wp(sp); 00403 00404 weak_ptr<void> wp2(wp); 00405 assert(wp2.use_count() == wp.use_count()); 00406 assert(wp2.use_count() == 1); 00407 assert(!(wp < wp2 || wp2 < wp)); 00408 00409 sp.reset(); 00410 assert(!(wp < wp2 || wp2 < wp)); 00411 00412 weak_ptr<void> wp3(wp); 00413 assert(wp3.use_count() == wp.use_count()); 00414 assert(wp3.use_count() == 0); 00415 assert(!(wp < wp3 || wp3 < wp)); 00416 } 00417 00418 { 00419 shared_ptr<Z> sp(static_cast<Z*>(0)); 00420 weak_ptr<Z> wp(sp); 00421 00422 weak_ptr<X> wp2(wp); 00423 assert(wp2.use_count() == wp.use_count()); 00424 assert(wp2.use_count() == 1); 00425 assert(!(wp < wp2 || wp2 < wp)); 00426 00427 sp.reset(); 00428 assert(!(wp < wp2 || wp2 < wp)); 00429 00430 weak_ptr<X> wp3(wp); 00431 assert(wp3.use_count() == wp.use_count()); 00432 assert(wp3.use_count() == 0); 00433 assert(!(wp < wp3 || wp3 < wp)); 00434 } 00435 00436 { 00437 shared_ptr<Z> sp(static_cast<Z*>(0)); 00438 weak_ptr<Z> wp(sp); 00439 00440 weak_ptr<Y> wp2(wp); 00441 assert(wp2.use_count() == wp.use_count()); 00442 assert(wp2.use_count() == 1); 00443 assert(!(wp < wp2 || wp2 < wp)); 00444 00445 sp.reset(); 00446 assert(!(wp < wp2 || wp2 < wp)); 00447 00448 weak_ptr<Y> wp3(wp); 00449 assert(wp3.use_count() == wp.use_count()); 00450 assert(wp3.use_count() == 0); 00451 assert(!(wp < wp3 || wp3 < wp)); 00452 } 00453 00454 { 00455 shared_ptr<Z> sp(new Z); 00456 weak_ptr<Z> wp(sp); 00457 00458 weak_ptr<X> wp2(wp); 00459 assert(wp2.use_count() == wp.use_count()); 00460 assert(wp2.use_count() == 1); 00461 assert(!(wp < wp2 || wp2 < wp)); 00462 00463 sp.reset(); 00464 assert(!(wp < wp2 || wp2 < wp)); 00465 00466 weak_ptr<X> wp3(wp); 00467 assert(wp3.use_count() == wp.use_count()); 00468 assert(wp3.use_count() == 0); 00469 assert(!(wp < wp3 || wp3 < wp)); 00470 } 00471 00472 { 00473 shared_ptr<Z> sp(new Z); 00474 weak_ptr<Z> wp(sp); 00475 00476 weak_ptr<Y> wp2(wp); 00477 assert(wp2.use_count() == wp.use_count()); 00478 assert(wp2.use_count() == 1); 00479 assert(!(wp < wp2 || wp2 < wp)); 00480 00481 sp.reset(); 00482 assert(!(wp < wp2 || wp2 < wp)); 00483 00484 weak_ptr<Y> wp3(wp); 00485 assert(wp3.use_count() == wp.use_count()); 00486 assert(wp3.use_count() == 0); 00487 assert(!(wp < wp3 || wp3 < wp)); 00488 } 00489 } 00490 00491 void 00492 test() 00493 { 00494 default_constructor(); 00495 shared_ptr_constructor(); 00496 copy_constructor(); 00497 conversion_constructor(); 00498 } 00499 00500 } // namespace n_constructors 00501 00502 namespace n_assignment 00503 { 00504 00505 template< class T > 00506 void 00507 copy_assignment(shared_ptr<T> & sp) 00508 { 00509 assert(sp.unique()); 00510 00511 weak_ptr<T> p1; 00512 00513 p1 = p1; 00514 assert(p1.use_count() == 0); 00515 00516 weak_ptr<T> p2; 00517 00518 p1 = p2; 00519 assert(p1.use_count() == 0); 00520 00521 weak_ptr<T> p3(p1); 00522 00523 p1 = p3; 00524 assert(p1.use_count() == 0); 00525 00526 weak_ptr<T> p4(sp); 00527 00528 p4 = p4; 00529 assert(p4.use_count() == 1); 00530 00531 p1 = p4; 00532 assert(p1.use_count() == 1); 00533 00534 p4 = p2; 00535 assert(p4.use_count() == 0); 00536 00537 sp.reset(); 00538 00539 p1 = p1; 00540 assert(p1.use_count() == 0); 00541 00542 p4 = p1; 00543 assert(p4.use_count() == 0); 00544 } 00545 00546 void 00547 conversion_assignment() 00548 { 00549 { 00550 weak_ptr<void> p1; 00551 00552 weak_ptr<incomplete> p2; 00553 00554 p1 = p2; 00555 assert(p1.use_count() == 0); 00556 00557 shared_ptr<incomplete> sp = create_incomplete(); 00558 weak_ptr<incomplete> p3(sp); 00559 00560 p1 = p3; 00561 assert(p1.use_count() == 1); 00562 00563 sp.reset(); 00564 00565 p1 = p3; 00566 assert(p1.use_count() == 0); 00567 00568 p1 = p2; 00569 assert(p1.use_count() == 0); 00570 } 00571 00572 { 00573 weak_ptr<X> p1; 00574 00575 weak_ptr<Z> p2; 00576 00577 p1 = p2; 00578 assert(p1.use_count() == 0); 00579 00580 shared_ptr<Z> sp(new Z); 00581 weak_ptr<Z> p3(sp); 00582 00583 p1 = p3; 00584 assert(p1.use_count() == 1); 00585 00586 sp.reset(); 00587 00588 p1 = p3; 00589 assert(p1.use_count() == 0); 00590 00591 p1 = p2; 00592 assert(p1.use_count() == 0); 00593 } 00594 00595 { 00596 weak_ptr<Y> p1; 00597 00598 weak_ptr<Z> p2; 00599 00600 p1 = p2; 00601 assert(p1.use_count() == 0); 00602 00603 shared_ptr<Z> sp(new Z); 00604 weak_ptr<Z> p3(sp); 00605 00606 p1 = p3; 00607 assert(p1.use_count() == 1); 00608 00609 sp.reset(); 00610 00611 p1 = p3; 00612 assert(p1.use_count() == 0); 00613 00614 p1 = p2; 00615 assert(p1.use_count() == 0); 00616 } 00617 } 00618 00619 template< class T, class U > 00620 void 00621 shared_ptr_assignment(shared_ptr<U> & sp, T * = 0) 00622 { 00623 assert(sp.unique()); 00624 00625 weak_ptr<T> p1; 00626 weak_ptr<T> p2(p1); 00627 weak_ptr<T> p3(sp); 00628 weak_ptr<T> p4(p3); 00629 00630 p1 = sp; 00631 assert(p1.use_count() == 1); 00632 00633 p2 = sp; 00634 assert(p2.use_count() == 1); 00635 00636 p3 = sp; 00637 assert(p3.use_count() == 1); 00638 00639 p4 = sp; 00640 assert(p4.use_count() == 1); 00641 00642 sp.reset(); 00643 00644 assert(p1.use_count() == 0); 00645 assert(p2.use_count() == 0); 00646 assert(p3.use_count() == 0); 00647 assert(p4.use_count() == 0); 00648 00649 p1 = sp; 00650 } 00651 00652 void 00653 test() 00654 { 00655 { 00656 shared_ptr<int> p( new int ); 00657 copy_assignment( p ); 00658 } 00659 00660 { 00661 shared_ptr<X> p( new X ); 00662 copy_assignment( p ); 00663 } 00664 00665 { 00666 shared_ptr<void> p( new int ); 00667 copy_assignment( p ); 00668 } 00669 00670 { 00671 shared_ptr<incomplete> p = create_incomplete(); 00672 copy_assignment( p ); 00673 } 00674 00675 conversion_assignment(); 00676 00677 { 00678 shared_ptr<int> p( new int ); 00679 shared_ptr_assignment<int>( p ); 00680 } 00681 00682 { 00683 shared_ptr<int> p( new int ); 00684 shared_ptr_assignment<void>( p ); 00685 } 00686 00687 { 00688 shared_ptr<X> p( new X ); 00689 shared_ptr_assignment<X>( p ); 00690 } 00691 00692 { 00693 shared_ptr<X> p( new X ); 00694 shared_ptr_assignment<void>( p ); 00695 } 00696 00697 { 00698 shared_ptr<void> p( new int ); 00699 shared_ptr_assignment<void>( p ); 00700 } 00701 00702 { 00703 shared_ptr<incomplete> p = create_incomplete(); 00704 shared_ptr_assignment<incomplete>( p ); 00705 } 00706 00707 { 00708 shared_ptr<incomplete> p = create_incomplete(); 00709 shared_ptr_assignment<void>( p ); 00710 } 00711 } 00712 00713 } // namespace n_assignment 00714 00715 namespace n_reset 00716 { 00717 00718 template< class T, class U > 00719 void 00720 test2( shared_ptr<U> & sp, T * = 0 ) 00721 { 00722 assert(sp.unique()); 00723 00724 weak_ptr<T> p1; 00725 weak_ptr<T> p2(p1); 00726 weak_ptr<T> p3(sp); 00727 weak_ptr<T> p4(p3); 00728 weak_ptr<T> p5(sp); 00729 weak_ptr<T> p6(p5); 00730 00731 p1.reset(); 00732 assert(p1.use_count() == 0); 00733 00734 p2.reset(); 00735 assert(p2.use_count() == 0); 00736 00737 p3.reset(); 00738 assert(p3.use_count() == 0); 00739 00740 p4.reset(); 00741 assert(p4.use_count() == 0); 00742 00743 sp.reset(); 00744 00745 p5.reset(); 00746 assert(p5.use_count() == 0); 00747 00748 p6.reset(); 00749 assert(p6.use_count() == 0); 00750 } 00751 00752 void 00753 test() 00754 { 00755 { 00756 shared_ptr<int> p( new int ); 00757 test2<int>( p ); 00758 } 00759 00760 { 00761 shared_ptr<int> p( new int ); 00762 test2<void>( p ); 00763 } 00764 00765 { 00766 shared_ptr<X> p( new X ); 00767 test2<X>( p ); 00768 } 00769 00770 { 00771 shared_ptr<X> p( new X ); 00772 test2<void>( p ); 00773 } 00774 00775 { 00776 shared_ptr<void> p( new int ); 00777 test2<void>( p ); 00778 } 00779 00780 { 00781 shared_ptr<incomplete> p = create_incomplete(); 00782 test2<incomplete>( p ); 00783 } 00784 00785 { 00786 shared_ptr<incomplete> p = create_incomplete(); 00787 test2<void>( p ); 00788 } 00789 } 00790 00791 } // namespace n_reset 00792 00793 namespace n_use_count 00794 { 00795 00796 void 00797 test() 00798 { 00799 { 00800 weak_ptr<X> wp; 00801 assert(wp.use_count() == 0); 00802 assert(wp.expired()); 00803 00804 weak_ptr<X> wp2; 00805 assert(wp.use_count() == 0); 00806 assert(wp.expired()); 00807 00808 weak_ptr<X> wp3(wp); 00809 assert(wp.use_count() == 0); 00810 assert(wp.expired()); 00811 assert(wp3.use_count() == 0); 00812 assert(wp3.expired()); 00813 } 00814 00815 { 00816 shared_ptr<X> sp(static_cast<X*>(0)); 00817 00818 weak_ptr<X> wp(sp); 00819 assert(wp.use_count() == 1); 00820 assert(!wp.expired()); 00821 00822 weak_ptr<X> wp2(sp); 00823 assert(wp.use_count() == 1); 00824 assert(!wp.expired()); 00825 00826 weak_ptr<X> wp3(wp); 00827 assert(wp.use_count() == 1); 00828 assert(!wp.expired()); 00829 assert(wp3.use_count() == 1); 00830 assert(!wp3.expired()); 00831 00832 shared_ptr<X> sp2(sp); 00833 00834 assert(wp.use_count() == 2); 00835 assert(!wp.expired()); 00836 assert(wp2.use_count() == 2); 00837 assert(!wp2.expired()); 00838 assert(wp3.use_count() == 2); 00839 assert(!wp3.expired()); 00840 00841 shared_ptr<void> sp3(sp); 00842 00843 assert(wp.use_count() == 3); 00844 assert(!wp.expired()); 00845 assert(wp2.use_count() == 3); 00846 assert(!wp2.expired()); 00847 assert(wp3.use_count() == 3); 00848 assert(!wp3.expired()); 00849 00850 sp.reset(); 00851 00852 assert(wp.use_count() == 2); 00853 assert(!wp.expired()); 00854 assert(wp2.use_count() == 2); 00855 assert(!wp2.expired()); 00856 assert(wp3.use_count() == 2); 00857 assert(!wp3.expired()); 00858 00859 sp2.reset(); 00860 00861 assert(wp.use_count() == 1); 00862 assert(!wp.expired()); 00863 assert(wp2.use_count() == 1); 00864 assert(!wp2.expired()); 00865 assert(wp3.use_count() == 1); 00866 assert(!wp3.expired()); 00867 00868 sp3.reset(); 00869 00870 assert(wp.use_count() == 0); 00871 assert(wp.expired()); 00872 assert(wp2.use_count() == 0); 00873 assert(wp2.expired()); 00874 assert(wp3.use_count() == 0); 00875 assert(wp3.expired()); 00876 } 00877 } 00878 00879 } // namespace n_use_count 00880 00881 namespace n_swap 00882 { 00883 00884 void 00885 test() 00886 { 00887 { 00888 weak_ptr<X> wp; 00889 weak_ptr<X> wp2; 00890 00891 wp.swap(wp2); 00892 00893 assert(wp.use_count() == 0); 00894 assert(wp2.use_count() == 0); 00895 00896 using std::swap; 00897 swap(wp, wp2); 00898 00899 assert(wp.use_count() == 0); 00900 assert(wp2.use_count() == 0); 00901 } 00902 00903 { 00904 shared_ptr<X> sp(new X); 00905 weak_ptr<X> wp; 00906 weak_ptr<X> wp2(sp); 00907 weak_ptr<X> wp3(sp); 00908 00909 wp.swap(wp2); 00910 00911 assert(wp.use_count() == 1); 00912 assert(wp2.use_count() == 0); 00913 assert(!(wp < wp3 || wp3 < wp)); 00914 00915 using std::swap; 00916 swap(wp, wp2); 00917 00918 assert(wp.use_count() == 0); 00919 assert(wp2.use_count() == 1); 00920 assert(!(wp2 < wp3 || wp3 < wp2)); 00921 00922 sp.reset(); 00923 00924 wp.swap(wp2); 00925 00926 assert(wp.use_count() == 0); 00927 assert(wp2.use_count() == 0); 00928 assert(!(wp < wp3 || wp3 < wp)); 00929 00930 using std::swap; 00931 swap(wp, wp2); 00932 00933 assert(wp.use_count() == 0); 00934 assert(wp2.use_count() == 0); 00935 assert(!(wp2 < wp3 || wp3 < wp2)); 00936 } 00937 00938 { 00939 shared_ptr<X> sp(new X); 00940 shared_ptr<X> sp2(new X); 00941 weak_ptr<X> wp(sp); 00942 weak_ptr<X> wp2(sp2); 00943 weak_ptr<X> wp3(sp2); 00944 00945 wp.swap(wp2); 00946 00947 assert(wp.use_count() == 1); 00948 assert(wp2.use_count() == 1); 00949 assert(!(wp < wp3 || wp3 < wp)); 00950 00951 using std::swap; 00952 swap(wp, wp2); 00953 00954 assert(wp.use_count() == 1); 00955 assert(wp2.use_count() == 1); 00956 assert(!(wp2 < wp3 || wp3 < wp2)); 00957 00958 sp.reset(); 00959 00960 wp.swap(wp2); 00961 00962 assert(wp.use_count() == 1); 00963 assert(wp2.use_count() == 0); 00964 assert(!(wp < wp3 || wp3 < wp)); 00965 00966 using std::swap; 00967 swap(wp, wp2); 00968 00969 assert(wp.use_count() == 0); 00970 assert(wp2.use_count() == 1); 00971 assert(!(wp2 < wp3 || wp3 < wp2)); 00972 00973 sp2.reset(); 00974 00975 wp.swap(wp2); 00976 00977 assert(wp.use_count() == 0); 00978 assert(wp2.use_count() == 0); 00979 assert(!(wp < wp3 || wp3 < wp)); 00980 00981 using std::swap; 00982 swap(wp, wp2); 00983 00984 assert(wp.use_count() == 0); 00985 assert(wp2.use_count() == 0); 00986 assert(!(wp2 < wp3 || wp3 < wp2)); 00987 } 00988 } 00989 00990 } // namespace n_swap 00991 00992 namespace n_comparison 00993 { 00994 00995 void 00996 test() 00997 { 00998 { 00999 weak_ptr<X> wp; 01000 assert(!(wp < wp)); 01001 01002 weak_ptr<X> wp2; 01003 assert(!(wp < wp2 && wp2 < wp)); 01004 01005 weak_ptr<X> wp3(wp); 01006 assert(!(wp3 < wp3)); 01007 assert(!(wp < wp3 && wp3 < wp)); 01008 } 01009 01010 { 01011 shared_ptr<X> sp(new X); 01012 01013 weak_ptr<X> wp(sp); 01014 assert(!(wp < wp)); 01015 01016 weak_ptr<X> wp2; 01017 assert(wp < wp2 || wp2 < wp); 01018 assert(!(wp < wp2 && wp2 < wp)); 01019 01020 bool b1 = wp < wp2; 01021 bool b2 = wp2 < wp; 01022 01023 { 01024 weak_ptr<X> wp3(wp); 01025 01026 assert(!(wp < wp3 || wp3 < wp)); 01027 assert(!(wp < wp3 && wp3 < wp)); 01028 01029 assert(wp2 < wp3 || wp3 < wp2); 01030 assert(!(wp2 < wp3 && wp3 < wp2)); 01031 01032 weak_ptr<X> wp4(wp2); 01033 01034 assert(wp4 < wp3 || wp3 < wp4); 01035 assert(!(wp4 < wp3 && wp3 < wp4)); 01036 } 01037 01038 sp.reset(); 01039 01040 assert(b1 == (wp < wp2)); 01041 assert(b2 == (wp2 < wp)); 01042 01043 { 01044 weak_ptr<X> wp3(wp); 01045 01046 assert(!(wp < wp3 || wp3 < wp)); 01047 assert(!(wp < wp3 && wp3 < wp)); 01048 01049 assert(wp2 < wp3 || wp3 < wp2); 01050 assert(!(wp2 < wp3 && wp3 < wp2)); 01051 01052 weak_ptr<X> wp4(wp2); 01053 01054 assert(wp4 < wp3 || wp3 < wp4); 01055 assert(!(wp4 < wp3 && wp3 < wp4)); 01056 } 01057 } 01058 01059 { 01060 shared_ptr<X> sp(new X); 01061 shared_ptr<X> sp2(new X); 01062 01063 weak_ptr<X> wp(sp); 01064 weak_ptr<X> wp2(sp2); 01065 01066 assert(wp < wp2 || wp2 < wp); 01067 assert(!(wp < wp2 && wp2 < wp)); 01068 01069 bool b1 = wp < wp2; 01070 bool b2 = wp2 < wp; 01071 01072 { 01073 weak_ptr<X> wp3(wp); 01074 01075 assert(!(wp < wp3 || wp3 < wp)); 01076 assert(!(wp < wp3 && wp3 < wp)); 01077 01078 assert(wp2 < wp3 || wp3 < wp2); 01079 assert(!(wp2 < wp3 && wp3 < wp2)); 01080 01081 weak_ptr<X> wp4(wp2); 01082 01083 assert(wp4 < wp3 || wp3 < wp4); 01084 assert(!(wp4 < wp3 && wp3 < wp4)); 01085 } 01086 01087 sp.reset(); 01088 01089 assert(b1 == (wp < wp2)); 01090 assert(b2 == (wp2 < wp)); 01091 01092 { 01093 weak_ptr<X> wp3(wp); 01094 01095 assert(!(wp < wp3 || wp3 < wp)); 01096 assert(!(wp < wp3 && wp3 < wp)); 01097 01098 assert(wp2 < wp3 || wp3 < wp2); 01099 assert(!(wp2 < wp3 && wp3 < wp2)); 01100 01101 weak_ptr<X> wp4(wp2); 01102 01103 assert(wp4 < wp3 || wp3 < wp4); 01104 assert(!(wp4 < wp3 && wp3 < wp4)); 01105 } 01106 01107 sp2.reset(); 01108 01109 assert(b1 == (wp < wp2)); 01110 assert(b2 == (wp2 < wp)); 01111 01112 { 01113 weak_ptr<X> wp3(wp); 01114 01115 assert(!(wp < wp3 || wp3 < wp)); 01116 assert(!(wp < wp3 && wp3 < wp)); 01117 01118 assert(wp2 < wp3 || wp3 < wp2); 01119 assert(!(wp2 < wp3 && wp3 < wp2)); 01120 01121 weak_ptr<X> wp4(wp2); 01122 01123 assert(wp4 < wp3 || wp3 < wp4); 01124 assert(!(wp4 < wp3 && wp3 < wp4)); 01125 } 01126 } 01127 01128 { 01129 shared_ptr<X> sp(new X); 01130 shared_ptr<X> sp2(sp); 01131 01132 weak_ptr<X> wp(sp); 01133 weak_ptr<X> wp2(sp2); 01134 01135 assert(!(wp < wp2 || wp2 < wp)); 01136 assert(!(wp < wp2 && wp2 < wp)); 01137 01138 bool b1 = wp < wp2; 01139 bool b2 = wp2 < wp; 01140 01141 { 01142 weak_ptr<X> wp3(wp); 01143 01144 assert(!(wp < wp3 || wp3 < wp)); 01145 assert(!(wp < wp3 && wp3 < wp)); 01146 01147 assert(!(wp2 < wp3 || wp3 < wp2)); 01148 assert(!(wp2 < wp3 && wp3 < wp2)); 01149 01150 weak_ptr<X> wp4(wp2); 01151 01152 assert(!(wp4 < wp3 || wp3 < wp4)); 01153 assert(!(wp4 < wp3 && wp3 < wp4)); 01154 } 01155 01156 sp.reset(); 01157 sp2.reset(); 01158 01159 assert(b1 == (wp < wp2)); 01160 assert(b2 == (wp2 < wp)); 01161 01162 { 01163 weak_ptr<X> wp3(wp); 01164 01165 assert(!(wp < wp3 || wp3 < wp)); 01166 assert(!(wp < wp3 && wp3 < wp)); 01167 01168 assert(!(wp2 < wp3 || wp3 < wp2)); 01169 assert(!(wp2 < wp3 && wp3 < wp2)); 01170 01171 weak_ptr<X> wp4(wp2); 01172 01173 assert(!(wp4 < wp3 || wp3 < wp4)); 01174 assert(!(wp4 < wp3 && wp3 < wp4)); 01175 } 01176 } 01177 01178 { 01179 shared_ptr<X> spx(new X); 01180 shared_ptr<Y> spy(new Y); 01181 shared_ptr<Z> spz(new Z); 01182 01183 weak_ptr<X> px(spx); 01184 weak_ptr<Y> py(spy); 01185 weak_ptr<Z> pz(spz); 01186 01187 assert(px < py || py < px); 01188 assert(px < pz || pz < px); 01189 assert(py < pz || pz < py); 01190 01191 assert(!(px < py && py < px)); 01192 assert(!(px < pz && pz < px)); 01193 assert(!(py < pz && pz < py)); 01194 01195 weak_ptr<void> pvx(px); 01196 assert(!(pvx < pvx)); 01197 01198 weak_ptr<void> pvy(py); 01199 assert(!(pvy < pvy)); 01200 01201 weak_ptr<void> pvz(pz); 01202 assert(!(pvz < pvz)); 01203 01204 assert(pvx < pvy || pvy < pvx); 01205 assert(pvx < pvz || pvz < pvx); 01206 assert(pvy < pvz || pvz < pvy); 01207 01208 assert(!(pvx < pvy && pvy < pvx)); 01209 assert(!(pvx < pvz && pvz < pvx)); 01210 assert(!(pvy < pvz && pvz < pvy)); 01211 01212 spx.reset(); 01213 spy.reset(); 01214 spz.reset(); 01215 01216 assert(px < py || py < px); 01217 assert(px < pz || pz < px); 01218 assert(py < pz || pz < py); 01219 01220 assert(!(px < py && py < px)); 01221 assert(!(px < pz && pz < px)); 01222 assert(!(py < pz && pz < py)); 01223 01224 assert(!(pvx < pvx)); 01225 assert(!(pvy < pvy)); 01226 assert(!(pvz < pvz)); 01227 01228 assert(pvx < pvy || pvy < pvx); 01229 assert(pvx < pvz || pvz < pvx); 01230 assert(pvy < pvz || pvz < pvy); 01231 01232 assert(!(pvx < pvy && pvy < pvx)); 01233 assert(!(pvx < pvz && pvz < pvx)); 01234 assert(!(pvy < pvz && pvz < pvy)); 01235 } 01236 01237 { 01238 shared_ptr<Z> spz(new Z); 01239 shared_ptr<X> spx(spz); 01240 01241 weak_ptr<Z> pz(spz); 01242 weak_ptr<X> px(spx); 01243 weak_ptr<Y> py(spz); 01244 01245 assert(!(px < px)); 01246 assert(!(py < py)); 01247 01248 assert(!(px < py || py < px)); 01249 assert(!(px < pz || pz < px)); 01250 assert(!(py < pz || pz < py)); 01251 01252 weak_ptr<void> pvx(px); 01253 weak_ptr<void> pvy(py); 01254 weak_ptr<void> pvz(pz); 01255 01256 assert(!(pvx < pvy || pvy < pvx)); 01257 assert(!(pvx < pvz || pvz < pvx)); 01258 assert(!(pvy < pvz || pvz < pvy)); 01259 01260 spx.reset(); 01261 spz.reset(); 01262 01263 assert(!(px < px)); 01264 assert(!(py < py)); 01265 01266 assert(!(px < py || py < px)); 01267 assert(!(px < pz || pz < px)); 01268 assert(!(py < pz || pz < py)); 01269 01270 assert(!(pvx < pvy || pvy < pvx)); 01271 assert(!(pvx < pvz || pvz < pvx)); 01272 assert(!(pvy < pvz || pvz < pvy)); 01273 } 01274 } 01275 01276 } // namespace n_comparison 01277 01278 namespace n_lock 01279 { 01280 01281 void 01282 test() 01283 { 01284 } 01285 01286 } // namespace n_lock 01287 01288 namespace n_map 01289 { 01290 01291 void 01292 test() 01293 { 01294 std::vector< shared_ptr<int> > vi; 01295 01296 { 01297 shared_ptr<int> pi1(new int); 01298 shared_ptr<int> pi2(new int); 01299 shared_ptr<int> pi3(new int); 01300 01301 vi.push_back(pi1); 01302 vi.push_back(pi1); 01303 vi.push_back(pi1); 01304 vi.push_back(pi2); 01305 vi.push_back(pi1); 01306 vi.push_back(pi2); 01307 vi.push_back(pi1); 01308 vi.push_back(pi3); 01309 vi.push_back(pi3); 01310 vi.push_back(pi2); 01311 vi.push_back(pi1); 01312 } 01313 01314 std::vector< shared_ptr<X> > vx; 01315 01316 { 01317 shared_ptr<X> px1(new X); 01318 shared_ptr<X> px2(new X); 01319 shared_ptr<X> px3(new X); 01320 01321 vx.push_back(px2); 01322 vx.push_back(px2); 01323 vx.push_back(px1); 01324 vx.push_back(px2); 01325 vx.push_back(px1); 01326 vx.push_back(px1); 01327 vx.push_back(px1); 01328 vx.push_back(px2); 01329 vx.push_back(px1); 01330 vx.push_back(px3); 01331 vx.push_back(px2); 01332 } 01333 01334 std::map< weak_ptr<void>, long > m; 01335 01336 { 01337 for(std::vector< shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i) 01338 { 01339 ++m[*i]; 01340 } 01341 } 01342 01343 { 01344 for(std::vector< shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i) 01345 { 01346 ++m[*i]; 01347 } 01348 } 01349 01350 { 01351 for(std::map< weak_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i) 01352 { 01353 assert(i->first.use_count() == i->second); 01354 } 01355 } 01356 } 01357 01358 } // namespace n_map 01359 01360 int main() 01361 { 01362 n_element_type::test(); 01363 n_constructors::test(); 01364 n_assignment::test(); 01365 n_reset::test(); 01366 n_use_count::test(); 01367 n_swap::test(); 01368 n_comparison::test(); 01369 n_lock::test(); 01370 01371 n_map::test(); 01372 01373 return 0; 01374 } 01375 01376 class incomplete 01377 { }; 01378 01379 shared_ptr<incomplete> 01380 create_incomplete() 01381 { 01382 shared_ptr<incomplete> px(new incomplete); 01383 return px; 01384 }