libs/smart_ptr/test/smart_ptr_test.cpp

   1 //  smart pointer test program  ----------------------------------------------//
   2
   3 //  Copyright Beman Dawes 1998, 1999.  Distributed under the Boost
   4 //  Software License, Version 1.0. (See accompanying file
   5 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7 //  See http://www.boost.org/libs/smart_ptr for documentation.
   8
   9 //  Revision History
  10 //  24 May 01  use Boost test library for error detection, reporting, add tests
  11 //             for operations on incomplete types (Beman Dawes)
  12 //  29 Nov 99  added std::swap and associative container tests (Darin Adler)
  13 //  25 Sep 99  added swap tests
  14 //  20 Jul 99  header name changed to .hpp
  15 //  20 Apr 99  additional error tests added.
  16
  17 #include <boost/config.hpp>
  18
  19 #if defined(BOOST_MSVC)
  20
  21 # pragma warning(disable: 4786)  // identifier truncated in debug info
  22 # pragma warning(disable: 4710)  // function not inlined
  23 # pragma warning(disable: 4711)  // function selected for automatic inline expansion
  24 # pragma warning(disable: 4514)  // unreferenced inline removed
  25
  26 #if (BOOST_MSVC >= 1310)
  27 # pragma warning(disable: 4675)  // resolved overload found with Koenig lookup
  28 #endif
  29
  30 #endif
  31
  32 #ifdef __BORLANDC__
  33 # pragma warn -8092 // template argument passed to 'find' is not an iterator
  34 #endif
  35
  36 #include <boost/scoped_ptr.hpp>
  37 #include <boost/scoped_array.hpp>
  38 #include <boost/shared_ptr.hpp>
  39 #include <boost/shared_array.hpp>
  40
  41 #include <boost/detail/lightweight_test.hpp>
  42
  43 #include <iostream>
  44 #include <set>
  45 #include <string.h>
  46
  47 class Incomplete;
  48
  49 Incomplete * get_ptr(  boost::shared_ptr<Incomplete>& incomplete )
  50 {
  51   return incomplete.get();
  52 }
  53
  54 template<class T>
  55 void ck( const T* v1, T v2 ) { BOOST_TEST( *v1 == v2 ); }
  56
  57 namespace {
  58   int UDT_use_count;  // independent of pointer maintained counts
  59   }
  60
  61 //  user defined type  -------------------------------------------------------//
  62
  63 class UDT {
  64   long value_;
  65  public:
  66   explicit UDT( long value=0 ) : value_(value) { ++UDT_use_count; }
  67   ~UDT() {
  68     --UDT_use_count;
  69     std::cout << "UDT with value " << value_ << " being destroyed\n";
  70     }
  71   long value() const { return value_; }
  72   void value( long v ) { value_ = v;; }
  73   };  // UDT
  74
  75 //  tests on incomplete types  -----------------------------------------------//
  76
  77 //  Certain smart pointer operations are specified to work on incomplete types,
  78 //  and some uses depend upon this feature.  These tests verify compilation
  79 //  only - the functions aren't actually invoked.
  80
  81 class Incomplete;
  82
  83 Incomplete * check_incomplete( boost::scoped_ptr<Incomplete>& incomplete )
  84 {
  85   return incomplete.get();
  86 }
  87
  88 Incomplete * check_incomplete( boost::shared_ptr<Incomplete>& incomplete,
  89                                boost::shared_ptr<Incomplete>& i2 )
  90 {
  91   incomplete.swap(i2);
  92   std::cout << incomplete.use_count() << ' ' << incomplete.unique() << '\n';
  93   return incomplete.get();
  94 }
  95
  96 //  This isn't a very systematic test; it just hits some of the basics.
  97
  98 void test()
  99 {
 100     BOOST_TEST( UDT_use_count == 0 );  // reality check
 101
 102     //  test scoped_ptr with a built-in type
 103     long * lp = new long;
 104     boost::scoped_ptr<long> sp ( lp );
 105     BOOST_TEST( sp.get() == lp );
 106     BOOST_TEST( lp == sp.get() );
 107     BOOST_TEST( &*sp == lp );
 108
 109     *sp = 1234568901L;
 110     BOOST_TEST( *sp == 1234568901L );
 111     BOOST_TEST( *lp == 1234568901L );
 112     ck( static_cast<long*>(sp.get()), 1234568901L );
 113     ck( lp, *sp );
 114
 115     sp.reset();
 116     BOOST_TEST( sp.get() == 0 );
 117
 118     //  test scoped_ptr with a user defined type
 119     boost::scoped_ptr<UDT> udt_sp ( new UDT( 999888777 ) );
 120     BOOST_TEST( udt_sp->value() == 999888777 );
 121     udt_sp.reset();
 122     udt_sp.reset( new UDT( 111222333 ) );
 123     BOOST_TEST( udt_sp->value() == 111222333 );
 124     udt_sp.reset( new UDT( 333222111 ) );
 125     BOOST_TEST( udt_sp->value() == 333222111 );
 126
 127     //  test scoped_array with a build-in type
 128     char * sap = new char [ 100 ];
 129     boost::scoped_array<char> sa ( sap );
 130     BOOST_TEST( sa.get() == sap );
 131     BOOST_TEST( sap == sa.get() );
 132
 133     strcpy( sa.get(), "Hot Dog with mustard and relish" );
 134     BOOST_TEST( strcmp( sa.get(), "Hot Dog with mustard and relish" ) == 0 );
 135     BOOST_TEST( strcmp( sap, "Hot Dog with mustard and relish" ) == 0 );
 136
 137     BOOST_TEST( sa[0] == 'H' );
 138     BOOST_TEST( sa[30] == 'h' );
 139
 140     sa[0] = 'N';
 141     sa[4] = 'd';
 142     BOOST_TEST( strcmp( sap, "Not dog with mustard and relish" ) == 0 );
 143
 144     sa.reset();
 145     BOOST_TEST( sa.get() == 0 );
 146
 147     //  test shared_ptr with a built-in type
 148     int * ip = new int;
 149     boost::shared_ptr<int> cp ( ip );
 150     BOOST_TEST( ip == cp.get() );
 151     BOOST_TEST( cp.use_count() == 1 );
 152
 153     *cp = 54321;
 154     BOOST_TEST( *cp == 54321 );
 155     BOOST_TEST( *ip == 54321 );
 156     ck( static_cast<int*>(cp.get()), 54321 );
 157     ck( static_cast<int*>(ip), *cp );
 158
 159     boost::shared_ptr<int> cp2 ( cp );
 160     BOOST_TEST( ip == cp2.get() );
 161     BOOST_TEST( cp.use_count() == 2 );
 162     BOOST_TEST( cp2.use_count() == 2 );
 163
 164     BOOST_TEST( *cp == 54321 );
 165     BOOST_TEST( *cp2 == 54321 );
 166     ck( static_cast<int*>(cp2.get()), 54321 );
 167     ck( static_cast<int*>(ip), *cp2 );
 168
 169     boost::shared_ptr<int> cp3 ( cp );
 170     BOOST_TEST( cp.use_count() == 3 );
 171     BOOST_TEST( cp2.use_count() == 3 );
 172     BOOST_TEST( cp3.use_count() == 3 );
 173     cp.reset();
 174     BOOST_TEST( cp2.use_count() == 2 );
 175     BOOST_TEST( cp3.use_count() == 2 );
 176     cp.reset( new int );
 177     *cp =  98765;
 178     BOOST_TEST( *cp == 98765 );
 179     *cp3 = 87654;
 180     BOOST_TEST( *cp3 == 87654 );
 181     BOOST_TEST( *cp2 == 87654 );
 182     cp.swap( cp3 );
 183     BOOST_TEST( *cp == 87654 );
 184     BOOST_TEST( *cp2 == 87654 );
 185     BOOST_TEST( *cp3 == 98765 );
 186     cp.swap( cp3 );
 187     BOOST_TEST( *cp == 98765 );
 188     BOOST_TEST( *cp2 == 87654 );
 189     BOOST_TEST( *cp3 == 87654 );
 190     cp2 = cp2;
 191     BOOST_TEST( cp2.use_count() == 2 );
 192     BOOST_TEST( *cp2 == 87654 );
 193     cp = cp2;
 194     BOOST_TEST( cp2.use_count() == 3 );
 195     BOOST_TEST( *cp2 == 87654 );
 196     BOOST_TEST( cp.use_count() == 3 );
 197     BOOST_TEST( *cp == 87654 );
 198
 199 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP )
 200     using boost::swap;
 201 #endif
 202
 203     boost::shared_ptr<int> cp4;
 204     swap( cp2, cp4 );
 205     BOOST_TEST( cp4.use_count() == 3 );
 206     BOOST_TEST( *cp4 == 87654 );
 207     BOOST_TEST( cp2.get() == 0 );
 208
 209     std::set< boost::shared_ptr<int> > scp;
 210     scp.insert(cp4);
 211     BOOST_TEST( scp.find(cp4) != scp.end() );
 212     BOOST_TEST( scp.find(cp4) == scp.find( boost::shared_ptr<int>(cp4) ) );
 213
 214     //  test shared_array with a built-in type
 215     char * cap = new char [ 100 ];
 216     boost::shared_array<char> ca ( cap );
 217     BOOST_TEST( ca.get() == cap );
 218     BOOST_TEST( cap == ca.get() );
 219     BOOST_TEST( &ca[0] == cap );
 220
 221     strcpy( ca.get(), "Hot Dog with mustard and relish" );
 222     BOOST_TEST( strcmp( ca.get(), "Hot Dog with mustard and relish" ) == 0 );
 223     BOOST_TEST( strcmp( cap, "Hot Dog with mustard and relish" ) == 0 );
 224
 225     BOOST_TEST( ca[0] == 'H' );
 226     BOOST_TEST( ca[30] == 'h' );
 227
 228     boost::shared_array<char> ca2 ( ca );
 229     boost::shared_array<char> ca3 ( ca2 );
 230
 231     ca[0] = 'N';
 232     ca[4] = 'd';
 233     BOOST_TEST( strcmp( ca.get(), "Not dog with mustard and relish" ) == 0 );
 234     BOOST_TEST( strcmp( ca2.get(), "Not dog with mustard and relish" ) == 0 );
 235     BOOST_TEST( strcmp( ca3.get(), "Not dog with mustard and relish" ) == 0 );
 236     BOOST_TEST( ca.use_count() == 3 );
 237     BOOST_TEST( ca2.use_count() == 3 );
 238     BOOST_TEST( ca3.use_count() == 3 );
 239     ca2.reset();
 240     BOOST_TEST( ca.use_count() == 2 );
 241     BOOST_TEST( ca3.use_count() == 2 );
 242     BOOST_TEST( ca2.use_count() == 1 );
 243
 244     ca.reset();
 245     BOOST_TEST( ca.get() == 0 );
 246
 247     boost::shared_array<char> ca4;
 248     swap( ca3, ca4 );
 249     BOOST_TEST( ca4.use_count() == 1 );
 250     BOOST_TEST( strcmp( ca4.get(), "Not dog with mustard and relish" ) == 0 );
 251     BOOST_TEST( ca3.get() == 0 );
 252
 253     std::set< boost::shared_array<char> > sca;
 254     sca.insert(ca4);
 255     BOOST_TEST( sca.find(ca4) != sca.end() );
 256     BOOST_TEST( sca.find(ca4) == sca.find( boost::shared_array<char>(ca4) ) );
 257
 258     //  test shared_array with user defined type
 259     boost::shared_array<UDT> udta ( new UDT[3] );
 260
 261     udta[0].value( 111 );
 262     udta[1].value( 222 );
 263     udta[2].value( 333 );
 264     boost::shared_array<UDT> udta2 ( udta );
 265
 266     BOOST_TEST( udta[0].value() == 111 );
 267     BOOST_TEST( udta[1].value() == 222 );
 268     BOOST_TEST( udta[2].value() == 333 );
 269     BOOST_TEST( udta2[0].value() == 111 );
 270     BOOST_TEST( udta2[1].value() == 222 );
 271     BOOST_TEST( udta2[2].value() == 333 );
 272     udta2.reset();
 273     BOOST_TEST( udta2.get() == 0 );
 274     BOOST_TEST( udta.use_count() == 1 );
 275     BOOST_TEST( udta2.use_count() == 1 );
 276
 277     BOOST_TEST( UDT_use_count == 4 );  // reality check
 278
 279     //  test shared_ptr with a user defined type
 280     UDT * up = new UDT;
 281     boost::shared_ptr<UDT> sup ( up );
 282     BOOST_TEST( up == sup.get() );
 283     BOOST_TEST( sup.use_count() == 1 );
 284
 285     sup->value( 54321 ) ;
 286     BOOST_TEST( sup->value() == 54321 );
 287     BOOST_TEST( up->value() == 54321 );
 288
 289     boost::shared_ptr<UDT> sup2;
 290     sup2 = sup;
 291     BOOST_TEST( sup2->value() == 54321 );
 292     BOOST_TEST( sup.use_count() == 2 );
 293     BOOST_TEST( sup2.use_count() == 2 );
 294     sup2 = sup2;
 295     BOOST_TEST( sup2->value() == 54321 );
 296     BOOST_TEST( sup.use_count() == 2 );
 297     BOOST_TEST( sup2.use_count() == 2 );
 298
 299     std::cout << "OK\n";
 300
 301     new char[12345]; // deliberate memory leak to verify leaks detected
 302 }
 303
 304 int main()
 305 {
 306     test();
 307     return boost::report_errors();
 308 }