libs/smart_ptr/test/shared_ptr_alias_test.cpp

   1 #include <boost/config.hpp>
   2
   3 //  shared_ptr_alias_test.cpp
   4 //
   5 //  Copyright (c) 2007 Peter Dimov
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11
  12 #include <boost/detail/lightweight_test.hpp>
  13 #include <boost/shared_ptr.hpp>
  14 #include <memory>
  15 #include <cstddef>
  16
  17 //
  18
  19 class incomplete;
  20
  21 struct X
  22 {
  23     int v_;
  24
  25     explicit X( int v ): v_( v )
  26     {
  27     }
  28
  29     ~X()
  30     {
  31         v_ = 0;
  32     }
  33 };
  34
  35 int main()
  36 {
  37     {
  38         int m = 0;
  39         boost::shared_ptr< int > p;
  40         boost::shared_ptr< int > p2( p, &m );
  41
  42         BOOST_TEST( p2.get() == &m );
  43         BOOST_TEST( p2? true: false );
  44         BOOST_TEST( !!p2 );
  45         BOOST_TEST( p2.use_count() == p.use_count() );
  46         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
  47
  48         p2.reset( p, 0 );
  49
  50         BOOST_TEST( p2.get() == 0 );
  51         BOOST_TEST( p2? false: true );
  52         BOOST_TEST( !p2 );
  53         BOOST_TEST( p2.use_count() == p.use_count() );
  54         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
  55     }
  56
  57     {
  58         int m = 0;
  59         boost::shared_ptr< int > p( new int );
  60         boost::shared_ptr< int const > p2( p, &m );
  61
  62         BOOST_TEST( p2.get() == &m );
  63         BOOST_TEST( p2? true: false );
  64         BOOST_TEST( !!p2 );
  65         BOOST_TEST( p2.use_count() == p.use_count() );
  66         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
  67
  68         boost::shared_ptr< int volatile > p3;
  69         p2.reset( p3, 0 );
  70
  71         BOOST_TEST( p2.get() == 0 );
  72         BOOST_TEST( p2? false: true );
  73         BOOST_TEST( !p2 );
  74         BOOST_TEST( p2.use_count() == p3.use_count() );
  75         BOOST_TEST( !( p3 < p2 ) && !( p2 < p3 ) );
  76     }
  77
  78     {
  79         boost::shared_ptr< int > p( new int );
  80         boost::shared_ptr< void const > p2( p, 0 );
  81
  82         BOOST_TEST( p2.get() == 0 );
  83         BOOST_TEST( p2? false: true );
  84         BOOST_TEST( !p2 );
  85         BOOST_TEST( p2.use_count() == p.use_count() );
  86         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
  87
  88         int m = 0;
  89         boost::shared_ptr< void volatile > p3;
  90
  91         p2.reset( p3, &m );
  92
  93         BOOST_TEST( p2.get() == &m );
  94         BOOST_TEST( p2? true: false );
  95         BOOST_TEST( !!p2 );
  96         BOOST_TEST( p2.use_count() == p3.use_count() );
  97         BOOST_TEST( !( p3 < p2 ) && !( p2 < p3 ) );
  98     }
  99
 100     {
 101         boost::shared_ptr< incomplete > p;
 102         boost::shared_ptr< incomplete > p2( p, 0 );
 103
 104         BOOST_TEST( p2.get() == 0 );
 105         BOOST_TEST( p2? false: true );
 106         BOOST_TEST( !p2 );
 107         BOOST_TEST( p2.use_count() == p.use_count() );
 108         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
 109
 110         p2.reset( p, 0 );
 111
 112         BOOST_TEST( p2.get() == 0 );
 113         BOOST_TEST( p2? false: true );
 114         BOOST_TEST( !p2 );
 115         BOOST_TEST( p2.use_count() == p.use_count() );
 116         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
 117     }
 118
 119     {
 120         boost::shared_ptr< X > p( new X( 5 ) );
 121         boost::shared_ptr< int const > p2( p, &p->v_ );
 122
 123         BOOST_TEST( p2.get() == &p->v_ );
 124         BOOST_TEST( p2? true: false );
 125         BOOST_TEST( !!p2 );
 126         BOOST_TEST( p2.use_count() == p.use_count() );
 127         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
 128
 129         p.reset();
 130         BOOST_TEST( *p2 == 5 );
 131
 132         boost::shared_ptr< X const > p3( new X( 8 ) );
 133         p2.reset( p3, &p3->v_ );
 134
 135         BOOST_TEST( p2.get() == &p3->v_ );
 136         BOOST_TEST( p2? true: false );
 137         BOOST_TEST( !!p2 );
 138         BOOST_TEST( p2.use_count() == p3.use_count() );
 139         BOOST_TEST( !( p3 < p2 ) && !( p2 < p3 ) );
 140
 141         p3.reset();
 142         BOOST_TEST( *p2 == 8 );
 143     }
 144
 145     return boost::report_errors();
 146 }