| // |
| // local_sp_test.cpp |
| // |
| // Copyright 2002, 2003, 2017 Peter Dimov |
| // |
| // Distributed under the Boost Software License, Version 1.0. |
| // See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt |
| // |
| |
| #include <boost/smart_ptr/local_shared_ptr.hpp> |
| #include <boost/smart_ptr/shared_ptr.hpp> |
| #include <boost/smart_ptr/weak_ptr.hpp> |
| #include <boost/core/lightweight_test.hpp> |
| |
| struct X |
| { |
| static long instances; |
| |
| X() |
| { |
| ++instances; |
| } |
| |
| ~X() |
| { |
| --instances; |
| } |
| |
| private: |
| |
| X( X const & ); |
| X & operator=( X const & ); |
| }; |
| |
| long X::instances = 0; |
| |
| class incomplete; |
| |
| // default constructor |
| |
| static void default_constructor() |
| { |
| { |
| boost::local_shared_ptr<int> p; |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| { |
| boost::local_shared_ptr<void> p; |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| { |
| boost::local_shared_ptr<incomplete> p; |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| { |
| boost::local_shared_ptr<X> p; |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| } |
| |
| // nullptr_constructor |
| |
| static void nullptr_constructor() |
| { |
| #if !defined( BOOST_NO_CXX11_NULLPTR ) |
| |
| { |
| boost::local_shared_ptr<int> p( nullptr ); |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| { |
| boost::local_shared_ptr<void> p( nullptr ); |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| { |
| boost::local_shared_ptr<incomplete> p( nullptr ); |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| { |
| boost::local_shared_ptr<X> p( nullptr ); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| |
| BOOST_TEST_EQ( p.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p.local_use_count(), 0 ); |
| } |
| |
| #endif |
| } |
| |
| // pointer constructor |
| |
| template<class T, class U> static void pc0_test_() |
| { |
| boost::local_shared_ptr<T> p( static_cast<U*>( 0 ) ); |
| |
| BOOST_TEST( p? false: true ); |
| BOOST_TEST( !p ); |
| BOOST_TEST( p.get() == 0 ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| template<class T> static void pc0_test() |
| { |
| pc0_test_<T, T>(); |
| pc0_test_<T const, T const>(); |
| pc0_test_<T volatile, T volatile>(); |
| pc0_test_<T const volatile, T const volatile>(); |
| |
| pc0_test_<T const, T>(); |
| pc0_test_<T volatile, T>(); |
| pc0_test_<T const volatile, T>(); |
| |
| pc0_test_<void, T>(); |
| pc0_test_<void const, T>(); |
| pc0_test_<void volatile, T>(); |
| pc0_test_<void const volatile, T>(); |
| } |
| |
| template<class T, class U> static void pc1_test_() |
| { |
| boost::local_shared_ptr<T> p( new U() ); |
| |
| BOOST_TEST( p? true: false ); |
| BOOST_TEST( !!p ); |
| BOOST_TEST( p.get() != 0 ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| template<class T> static void pc1_test() |
| { |
| pc1_test_<T, T>(); |
| pc1_test_<T const, T const>(); |
| pc1_test_<T volatile, T volatile>(); |
| pc1_test_<T const volatile, T const volatile>(); |
| |
| pc1_test_<T const, T>(); |
| pc1_test_<T volatile, T>(); |
| pc1_test_<T const volatile, T>(); |
| |
| pc1_test_<void, T>(); |
| pc1_test_<void const, T>(); |
| pc1_test_<void volatile, T>(); |
| pc1_test_<void const volatile, T>(); |
| } |
| |
| static void pointer_constructor() |
| { |
| pc0_test<int>(); |
| pc0_test<X>(); |
| |
| pc1_test<int>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| pc1_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // deleter constructor |
| |
| int m = 0; |
| |
| void deleter2( int * p ) |
| { |
| BOOST_TEST( p == &m ); |
| ++*p; |
| } |
| |
| template<class T> static void deleter2_test_() |
| { |
| { |
| m = 0; |
| boost::local_shared_ptr<T> p( &m, deleter2 ); |
| |
| BOOST_TEST( p? true: false ); |
| BOOST_TEST( !!p ); |
| BOOST_TEST( p.get() == &m ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| BOOST_TEST( m == 1 ); |
| } |
| |
| static void deleter_constructor() |
| { |
| deleter2_test_<int>(); |
| deleter2_test_<int const>(); |
| deleter2_test_<int volatile>(); |
| deleter2_test_<int const volatile>(); |
| |
| deleter2_test_<void>(); |
| deleter2_test_<void const>(); |
| deleter2_test_<void volatile>(); |
| deleter2_test_<void const volatile>(); |
| } |
| |
| // nullptr_deleter_constructor |
| |
| #if !defined( BOOST_NO_CXX11_NULLPTR ) |
| |
| void deleter3( boost::detail::sp_nullptr_t ) |
| { |
| ++m; |
| } |
| |
| template<class T> static void deleter3_test_() |
| { |
| { |
| m = 0; |
| boost::local_shared_ptr<T> p( nullptr, deleter3 ); |
| |
| BOOST_TEST( !p ); |
| BOOST_TEST( p.get() == 0 ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| BOOST_TEST( m == 1 ); |
| } |
| |
| static void nullptr_deleter_constructor() |
| { |
| deleter3_test_<int>(); |
| deleter3_test_<int const>(); |
| deleter3_test_<int volatile>(); |
| deleter3_test_<int const volatile>(); |
| |
| deleter3_test_<void>(); |
| deleter3_test_<void const>(); |
| deleter3_test_<void volatile>(); |
| deleter3_test_<void const volatile>(); |
| } |
| |
| #else |
| |
| static void nullptr_deleter_constructor() |
| { |
| } |
| |
| #endif |
| |
| // allocator constructor |
| |
| template<class T> static void allocator_test_() |
| { |
| { |
| m = 0; |
| boost::local_shared_ptr<T> p( &m, deleter2, std::allocator<void>() ); |
| |
| BOOST_TEST( p? true: false ); |
| BOOST_TEST( !!p ); |
| BOOST_TEST( p.get() == &m ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| BOOST_TEST( m == 1 ); |
| } |
| |
| static void allocator_constructor() |
| { |
| allocator_test_<int>(); |
| allocator_test_<int const>(); |
| allocator_test_<int volatile>(); |
| allocator_test_<int const volatile>(); |
| |
| allocator_test_<void>(); |
| allocator_test_<void const>(); |
| allocator_test_<void volatile>(); |
| allocator_test_<void const volatile>(); |
| } |
| |
| // nullptr_allocator_constructor |
| |
| #if !defined( BOOST_NO_CXX11_NULLPTR ) |
| |
| template<class T> static void allocator3_test_() |
| { |
| { |
| m = 0; |
| boost::local_shared_ptr<T> p( nullptr, deleter3, std::allocator<void>() ); |
| |
| BOOST_TEST( !p ); |
| BOOST_TEST( p.get() == 0 ); |
| BOOST_TEST( p.local_use_count() == 1 ); |
| } |
| |
| BOOST_TEST( m == 1 ); |
| } |
| |
| static void nullptr_allocator_constructor() |
| { |
| allocator3_test_<int>(); |
| allocator3_test_<int const>(); |
| allocator3_test_<int volatile>(); |
| allocator3_test_<int const volatile>(); |
| |
| allocator3_test_<void>(); |
| allocator3_test_<void const>(); |
| allocator3_test_<void volatile>(); |
| allocator3_test_<void const volatile>(); |
| } |
| |
| #else |
| |
| static void nullptr_allocator_constructor() |
| { |
| } |
| |
| #endif |
| |
| // copy constructor |
| |
| template<class T> static void empty_copy_test() |
| { |
| boost::local_shared_ptr<T> p1; |
| |
| BOOST_TEST_EQ( p1.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p1.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( p1 ); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( p1 ); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( p3 ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_copy( boost::local_shared_ptr<U> const & p1 ) |
| { |
| long k = p1.local_use_count(); |
| |
| { |
| boost::local_shared_ptr<T> p2( p1 ); |
| |
| BOOST_TEST( p2.get() == p1.get() ); |
| BOOST_TEST( p2.local_use_count() == p1.local_use_count() ); |
| BOOST_TEST( p2.local_use_count() == k + 1 ); |
| } |
| |
| BOOST_TEST( p1.local_use_count() == k ); |
| } |
| |
| template<class T> static void null_copy_test() |
| { |
| boost::local_shared_ptr<T> p1( static_cast<T*>(0) ); |
| |
| test_nonempty_copy<T>( p1 ); |
| test_nonempty_copy<T const>( p1 ); |
| test_nonempty_copy<T volatile>( p1 ); |
| test_nonempty_copy<T const volatile>( p1 ); |
| test_nonempty_copy<void>( p1 ); |
| test_nonempty_copy<void const>( p1 ); |
| test_nonempty_copy<void volatile>( p1 ); |
| test_nonempty_copy<void const volatile>( p1 ); |
| } |
| |
| template<class T> static void new_copy_test() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| |
| test_nonempty_copy<T>( p1 ); |
| test_nonempty_copy<T const>( p1 ); |
| test_nonempty_copy<T volatile>( p1 ); |
| test_nonempty_copy<T const volatile>( p1 ); |
| test_nonempty_copy<void>( p1 ); |
| test_nonempty_copy<void const>( p1 ); |
| test_nonempty_copy<void volatile>( p1 ); |
| test_nonempty_copy<void const volatile>( p1 ); |
| } |
| |
| static void copy_constructor() |
| { |
| empty_copy_test<int>(); |
| empty_copy_test<incomplete>(); |
| empty_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_copy_test<int>(); |
| null_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_copy_test<int>(); |
| new_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // move constructor |
| |
| #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
| |
| template<class T> static void empty_move_test() |
| { |
| boost::local_shared_ptr<T> p2(( boost::local_shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3(( boost::local_shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4(( boost::local_shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( std::move(p3) ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_move( boost::local_shared_ptr<U> && p1 ) |
| { |
| U* q = p1.get(); |
| long k = p1.local_use_count(); |
| |
| boost::local_shared_ptr<T> p2( std::move(p1) ); |
| |
| BOOST_TEST( p2.get() == q ); |
| BOOST_TEST( p2.local_use_count() == k ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.local_use_count() == 0 ); |
| } |
| |
| template<class T> static void null_move_test() |
| { |
| test_nonempty_move<T>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<T const>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<T volatile>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<T const volatile>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<void>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<void const>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<void volatile>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move<void const volatile>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_move_test() |
| { |
| test_nonempty_move<T>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<T const>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<T volatile>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<T const volatile>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<void>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<void const>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<void volatile>( boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move<void const volatile>( boost::local_shared_ptr<T>( new T() ) ); |
| } |
| |
| static void move_constructor() |
| { |
| empty_move_test<int>(); |
| empty_move_test<incomplete>(); |
| empty_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_move_test<int>(); |
| null_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_move_test<int>(); |
| new_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void move_constructor() |
| { |
| } |
| |
| #endif |
| |
| // aliasing constructor |
| |
| template<class T, class U> void test_aliasing_( boost::local_shared_ptr<T> const & p1, U * p2 ) |
| { |
| boost::local_shared_ptr<U> p3( p1, p2 ); |
| |
| BOOST_TEST( p3.get() == p2 ); |
| BOOST_TEST( p3.local_use_count() == p1.local_use_count() ); |
| BOOST_TEST( !p3.owner_before( p1 ) && !p1.owner_before( p3 ) ); |
| } |
| |
| template<class T, class U> void test_01_aliasing_() |
| { |
| U u; |
| boost::local_shared_ptr<T> p1; |
| |
| test_aliasing_( p1, &u ); |
| } |
| |
| template<class T, class U> void test_01_aliasing() |
| { |
| test_01_aliasing_<T, U>(); |
| test_01_aliasing_<T const, U>(); |
| test_01_aliasing_<T volatile, U>(); |
| test_01_aliasing_<T const volatile, U>(); |
| |
| test_01_aliasing_<T, U volatile>(); |
| test_01_aliasing_<T const, U volatile>(); |
| test_01_aliasing_<T volatile, U volatile>(); |
| test_01_aliasing_<T const volatile, U volatile>(); |
| } |
| |
| template<class T, class U> void test_10_aliasing_() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| test_aliasing_( p1, static_cast<U*>(0) ); |
| } |
| |
| template<class T, class U> void test_10_aliasing() |
| { |
| test_10_aliasing_<T, U>(); |
| test_10_aliasing_<T const, U>(); |
| test_10_aliasing_<T volatile, U>(); |
| test_10_aliasing_<T const volatile, U>(); |
| |
| test_10_aliasing_<T, U const>(); |
| test_10_aliasing_<T const, U const>(); |
| test_10_aliasing_<T volatile, U const>(); |
| test_10_aliasing_<T const volatile, U const>(); |
| |
| test_10_aliasing_<T, U volatile>(); |
| test_10_aliasing_<T const, U volatile>(); |
| test_10_aliasing_<T volatile, U volatile>(); |
| test_10_aliasing_<T const volatile, U volatile>(); |
| |
| test_10_aliasing_<T, U const volatile>(); |
| test_10_aliasing_<T const, U const volatile>(); |
| test_10_aliasing_<T volatile, U const volatile>(); |
| test_10_aliasing_<T const volatile, U const volatile>(); |
| } |
| |
| template<class T, class U> void test_11_aliasing_() |
| { |
| U u; |
| boost::local_shared_ptr<T> p1( new T() ); |
| |
| test_aliasing_( p1, &u ); |
| } |
| |
| template<class T, class U> void test_11_aliasing() |
| { |
| test_11_aliasing_<T, U>(); |
| test_11_aliasing_<T const, U>(); |
| test_11_aliasing_<T volatile, U>(); |
| test_11_aliasing_<T const volatile, U>(); |
| |
| test_11_aliasing_<T, U volatile>(); |
| test_11_aliasing_<T const, U volatile>(); |
| test_11_aliasing_<T volatile, U volatile>(); |
| test_11_aliasing_<T const volatile, U volatile>(); |
| } |
| |
| static void aliasing_constructor() |
| { |
| test_01_aliasing<int, int>(); |
| test_10_aliasing<int, int>(); |
| test_11_aliasing<int, int>(); |
| |
| test_01_aliasing<void, int>(); |
| |
| test_10_aliasing<int, void>(); |
| |
| test_10_aliasing<int, incomplete>(); |
| |
| test_01_aliasing<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing<void, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing<X, void>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing<X, incomplete>(); |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // shared_ptr copy constructor |
| |
| template<class T> static void empty_shared_ptr_copy_test() |
| { |
| boost::shared_ptr<T> p1; |
| |
| boost::local_shared_ptr<T> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( p1 ); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( p1 ); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( p3 ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_shared_ptr_copy( boost::shared_ptr<U> const & p1 ) |
| { |
| long k = p1.use_count(); |
| |
| { |
| boost::local_shared_ptr<T> p2( p1 ); |
| |
| BOOST_TEST( p2.get() == p1.get() ); |
| BOOST_TEST( p2.local_use_count() == 1 ); |
| |
| BOOST_TEST( p1.use_count() == k + 1 ); |
| } |
| |
| BOOST_TEST( p1.use_count() == k ); |
| } |
| |
| template<class T> static void null_shared_ptr_copy_test() |
| { |
| boost::shared_ptr<T> p1( static_cast<T*>(0) ); |
| |
| test_nonempty_shared_ptr_copy<T>( p1 ); |
| test_nonempty_shared_ptr_copy<T const>( p1 ); |
| test_nonempty_shared_ptr_copy<T volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<T const volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<void>( p1 ); |
| test_nonempty_shared_ptr_copy<void const>( p1 ); |
| test_nonempty_shared_ptr_copy<void volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<void const volatile>( p1 ); |
| } |
| |
| template<class T> static void new_shared_ptr_copy_test() |
| { |
| boost::shared_ptr<T> p1( new T() ); |
| |
| test_nonempty_shared_ptr_copy<T>( p1 ); |
| test_nonempty_shared_ptr_copy<T const>( p1 ); |
| test_nonempty_shared_ptr_copy<T volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<T const volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<void>( p1 ); |
| test_nonempty_shared_ptr_copy<void const>( p1 ); |
| test_nonempty_shared_ptr_copy<void volatile>( p1 ); |
| test_nonempty_shared_ptr_copy<void const volatile>( p1 ); |
| } |
| |
| static void shared_ptr_copy_constructor() |
| { |
| empty_shared_ptr_copy_test<int>(); |
| empty_shared_ptr_copy_test<incomplete>(); |
| empty_shared_ptr_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_shared_ptr_copy_test<int>(); |
| null_shared_ptr_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_shared_ptr_copy_test<int>(); |
| new_shared_ptr_copy_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // shared_ptr_move constructor |
| |
| #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
| |
| template<class T> static void empty_shared_ptr_move_test() |
| { |
| boost::local_shared_ptr<T> p2(( boost::shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3(( boost::shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4(( boost::shared_ptr<T>() )); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( std::move(p3) ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_shared_ptr_move( boost::shared_ptr<U> && p1 ) |
| { |
| U* q = p1.get(); |
| |
| boost::local_shared_ptr<T> p2( std::move(p1) ); |
| |
| BOOST_TEST( p2.get() == q ); |
| BOOST_TEST( p2.local_use_count() == 1 ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.use_count() == 0 ); |
| } |
| |
| template<class T> static void null_shared_ptr_move_test() |
| { |
| test_nonempty_shared_ptr_move<T>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<T const>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<T volatile>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<T const volatile>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<void>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<void const>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<void volatile>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move<void const volatile>( boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_shared_ptr_move_test() |
| { |
| test_nonempty_shared_ptr_move<T>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<T const>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<T volatile>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<T const volatile>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<void>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<void const>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<void volatile>( boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move<void const volatile>( boost::shared_ptr<T>( new T() ) ); |
| } |
| |
| static void shared_ptr_move_constructor() |
| { |
| empty_shared_ptr_move_test<int>(); |
| empty_shared_ptr_move_test<incomplete>(); |
| empty_shared_ptr_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_shared_ptr_move_test<int>(); |
| null_shared_ptr_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_shared_ptr_move_test<int>(); |
| new_shared_ptr_move_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void shared_ptr_move_constructor() |
| { |
| } |
| |
| #endif |
| |
| // unique_ptr_constructor |
| |
| #if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
| |
| template<class T, class U> static void test_null_unique_ptr( std::unique_ptr<U> && p1 ) |
| { |
| boost::local_shared_ptr<T> p2( std::move( p1 ) ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| |
| BOOST_TEST( p2.get() == 0 ); |
| BOOST_TEST( p2.local_use_count() == 0 ); |
| } |
| |
| template<class T> static void null_unique_ptr_test() |
| { |
| test_null_unique_ptr<T>( std::unique_ptr<T>() ); |
| |
| test_null_unique_ptr<T const>( std::unique_ptr<T>() ); |
| test_null_unique_ptr<T volatile>( std::unique_ptr<T>() ); |
| test_null_unique_ptr<T const volatile>( std::unique_ptr<T>() ); |
| |
| test_null_unique_ptr<T const>( std::unique_ptr<T const>() ); |
| test_null_unique_ptr<T volatile>( std::unique_ptr<T volatile>() ); |
| test_null_unique_ptr<T const volatile>( std::unique_ptr<T const volatile>() ); |
| |
| test_null_unique_ptr<void>( std::unique_ptr<T>() ); |
| |
| test_null_unique_ptr<void const>( std::unique_ptr<T>() ); |
| test_null_unique_ptr<void volatile>( std::unique_ptr<T>() ); |
| test_null_unique_ptr<void const volatile>( std::unique_ptr<T>() ); |
| |
| test_null_unique_ptr<void const>( std::unique_ptr<T const>() ); |
| test_null_unique_ptr<void volatile>( std::unique_ptr<T volatile>() ); |
| test_null_unique_ptr<void const volatile>( std::unique_ptr<T const volatile>() ); |
| } |
| |
| template<class T, class U, class D> static void test_nonempty_unique_ptr( std::unique_ptr<U, D> && p1 ) |
| { |
| U * q = p1.get(); |
| |
| boost::local_shared_ptr<T> p2( std::move(p1) ); |
| |
| BOOST_TEST( p2.get() == q ); |
| BOOST_TEST( p2.local_use_count() == 1 ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| } |
| |
| template<class T> static void new_unique_ptr_test() |
| { |
| test_nonempty_unique_ptr<T>( std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr<T const>( std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr<T volatile>( std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr<T const volatile>( std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr<T const>( std::unique_ptr<T const>( new T() ) ); |
| test_nonempty_unique_ptr<T volatile>( std::unique_ptr<T volatile>( new T() ) ); |
| test_nonempty_unique_ptr<T const volatile>( std::unique_ptr<T const volatile>( new T() ) ); |
| |
| test_nonempty_unique_ptr<void>( std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr<void const>( std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr<void volatile>( std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr<void const volatile>( std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr<void const>( std::unique_ptr<T const>( new T() ) ); |
| test_nonempty_unique_ptr<void volatile>( std::unique_ptr<T volatile>( new T() ) ); |
| test_nonempty_unique_ptr<void const volatile>( std::unique_ptr<T const volatile>( new T() ) ); |
| } |
| |
| template<class T> static void test_deleter_unique_ptr() |
| { |
| m = 0; |
| |
| test_nonempty_unique_ptr<T>( std::unique_ptr<int, void(*)(int*)>( &m, deleter2 ) ); |
| |
| BOOST_TEST( m == 1 ); |
| } |
| |
| template<class T> static void deleter_unique_ptr_test() |
| { |
| test_deleter_unique_ptr<T>(); |
| test_deleter_unique_ptr<T const>(); |
| test_deleter_unique_ptr<T volatile>(); |
| test_deleter_unique_ptr<T const volatile>(); |
| } |
| |
| static void unique_ptr_constructor() |
| { |
| null_unique_ptr_test<int>(); |
| null_unique_ptr_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_unique_ptr_test<int>(); |
| new_unique_ptr_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| deleter_unique_ptr_test<int>(); |
| deleter_unique_ptr_test<void>(); |
| } |
| |
| #else |
| |
| static void unique_ptr_constructor() |
| { |
| } |
| |
| #endif |
| |
| // copy assignment |
| |
| template<class T> static void empty_copy_assign_test() |
| { |
| boost::local_shared_ptr<T> p1; |
| |
| BOOST_TEST_EQ( p1.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p1.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T> p2; |
| |
| p2 = p1; |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3; |
| |
| p3 = p1; |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4; |
| |
| p4 = p1; |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5; |
| |
| p5 = p3; |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_copy_assign_test_() |
| { |
| boost::local_shared_ptr<T> p1; |
| |
| BOOST_TEST_EQ( p1.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p1.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T> p2( static_cast<T*>(0) ); |
| |
| p2 = p1; |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( static_cast<T const*>(0) ); |
| |
| p3 = p1; |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( static_cast<T*>(0) ); |
| |
| p4 = p1; |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( static_cast<T const*>(0) ); |
| |
| p5 = p3; |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_copy_assign( boost::local_shared_ptr<T> p2, boost::local_shared_ptr<U> const & p1 ) |
| { |
| long k = p1.local_use_count(); |
| |
| p2 = p1; |
| |
| BOOST_TEST( p2.get() == p1.get() ); |
| BOOST_TEST( p2.local_use_count() == p1.local_use_count() ); |
| BOOST_TEST( p2.local_use_count() == k + 1 ); |
| |
| p2.reset(); |
| |
| BOOST_TEST( p1.local_use_count() == k ); |
| } |
| |
| template<class T> static void null_copy_assign_test() |
| { |
| boost::local_shared_ptr<T> p1( static_cast<T*>(0) ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<T>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T volatile>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const volatile>(), p1 ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), p1 ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<void>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void const>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void volatile>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void const volatile>(), p1 ); |
| } |
| |
| template<class T> static void new_copy_assign_test() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<T>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T volatile>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const volatile>(), p1 ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), p1 ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<T>( new T() ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const>( new T const() ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), p1 ); |
| |
| test_nonempty_copy_assign( boost::local_shared_ptr<void>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void const>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void volatile>(), p1 ); |
| test_nonempty_copy_assign( boost::local_shared_ptr<void const volatile>(), p1 ); |
| } |
| |
| static void copy_assignment() |
| { |
| empty_copy_assign_test<incomplete>(); |
| empty_copy_assign_test<int>(); |
| empty_copy_assign_test_<int>(); |
| empty_copy_assign_test<X>(); |
| empty_copy_assign_test_<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_copy_assign_test<int>(); |
| null_copy_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_copy_assign_test<int>(); |
| new_copy_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // move assignment |
| |
| #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
| |
| template<class T> static void empty_move_assign_test() |
| { |
| boost::local_shared_ptr<T> p2; |
| |
| p2 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3; |
| |
| p3 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4; |
| |
| p4 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5; |
| |
| p5 = std::move( p3 ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_move_assign_test_() |
| { |
| boost::local_shared_ptr<T> p2( static_cast<T*>(0) ); |
| |
| p2 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( static_cast<T const*>(0) ); |
| |
| p3 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( static_cast<T*>(0) ); |
| |
| p4 = boost::local_shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( static_cast<T const*>(0) ); |
| |
| p5 = std::move( p3 ); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_move_assign( boost::local_shared_ptr<T> p2, boost::local_shared_ptr<U> && p1 ) |
| { |
| U* q = p1.get(); |
| long k = p1.local_use_count(); |
| |
| p2 = std::move( p1 ); |
| |
| BOOST_TEST( p2.get() == q ); |
| BOOST_TEST( p2.local_use_count() == k ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.local_use_count() == 0 ); |
| } |
| |
| template<class T> static void null_move_assign_test() |
| { |
| test_nonempty_move_assign( boost::local_shared_ptr<T>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T volatile>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const volatile>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| |
| test_nonempty_move_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| |
| test_nonempty_move_assign( boost::local_shared_ptr<void>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void const>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void volatile>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void const volatile>(), boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_move_assign_test() |
| { |
| test_nonempty_move_assign( boost::local_shared_ptr<T>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T volatile>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const volatile>(), boost::local_shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_move_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), boost::local_shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_move_assign( boost::local_shared_ptr<T>( new T() ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const>( new T const() ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), boost::local_shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_move_assign( boost::local_shared_ptr<void>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void const>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void volatile>(), boost::local_shared_ptr<T>( new T() ) ); |
| test_nonempty_move_assign( boost::local_shared_ptr<void const volatile>(), boost::local_shared_ptr<T>( new T() ) ); |
| } |
| |
| static void move_assignment() |
| { |
| empty_move_assign_test<incomplete>(); |
| empty_move_assign_test<int>(); |
| empty_move_assign_test_<int>(); |
| empty_move_assign_test<X>(); |
| empty_move_assign_test_<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_move_assign_test<int>(); |
| null_move_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_move_assign_test<int>(); |
| new_move_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void move_assignment() |
| { |
| } |
| |
| #endif |
| |
| // nullptr assignment |
| |
| #if !defined( BOOST_NO_CXX11_NULLPTR ) |
| |
| template<class T> static void test_nullptr_assign( boost::local_shared_ptr<T> p1 ) |
| { |
| p1 = nullptr; |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.local_use_count() == 0 ); |
| } |
| |
| template<class T> static void empty_nullptr_assign_test() |
| { |
| test_nullptr_assign( boost::local_shared_ptr<T>() ); |
| test_nullptr_assign( boost::local_shared_ptr<T const>() ); |
| test_nullptr_assign( boost::local_shared_ptr<T volatile>() ); |
| test_nullptr_assign( boost::local_shared_ptr<T const volatile>() ); |
| } |
| |
| template<class T> static void null_nullptr_assign_test() |
| { |
| test_nullptr_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ) ); |
| } |
| |
| template<class T> static void new_nullptr_assign_test() |
| { |
| test_nullptr_assign( boost::local_shared_ptr<T>( new T() ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T const>( new T const() ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T volatile>( new T volatile() ) ); |
| test_nullptr_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ) ); |
| } |
| |
| static void nullptr_assignment() |
| { |
| empty_nullptr_assign_test<incomplete>(); |
| empty_nullptr_assign_test<void>(); |
| empty_nullptr_assign_test<int>(); |
| empty_nullptr_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_nullptr_assign_test<int>(); |
| null_nullptr_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_nullptr_assign_test<int>(); |
| new_nullptr_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void nullptr_assignment() |
| { |
| } |
| |
| #endif |
| |
| // default_reset |
| |
| template<class T> static void test_default_reset( boost::local_shared_ptr<T> p1 ) |
| { |
| p1.reset(); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.local_use_count() == 0 ); |
| } |
| |
| template<class T> static void empty_default_reset_test() |
| { |
| test_default_reset( boost::local_shared_ptr<T>() ); |
| test_default_reset( boost::local_shared_ptr<T const>() ); |
| test_default_reset( boost::local_shared_ptr<T volatile>() ); |
| test_default_reset( boost::local_shared_ptr<T const volatile>() ); |
| } |
| |
| template<class T> static void null_default_reset_test() |
| { |
| test_default_reset( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_default_reset( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ) ); |
| test_default_reset( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ) ); |
| test_default_reset( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ) ); |
| } |
| |
| template<class T> static void new_default_reset_test() |
| { |
| test_default_reset( boost::local_shared_ptr<T>( new T() ) ); |
| test_default_reset( boost::local_shared_ptr<T const>( new T const() ) ); |
| test_default_reset( boost::local_shared_ptr<T volatile>( new T volatile() ) ); |
| test_default_reset( boost::local_shared_ptr<T const volatile>( new T const volatile() ) ); |
| } |
| |
| static void default_reset() |
| { |
| empty_default_reset_test<incomplete>(); |
| empty_default_reset_test<void>(); |
| empty_default_reset_test<int>(); |
| empty_default_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_default_reset_test<int>(); |
| null_default_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_default_reset_test<int>(); |
| new_default_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // shared_ptr copy assignment |
| |
| template<class T> static void empty_shared_ptr_copy_assign_test() |
| { |
| boost::shared_ptr<T> sp1; |
| |
| BOOST_TEST_EQ( sp1.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( sp1.use_count(), 0 ); |
| |
| boost::local_shared_ptr<T> p2; |
| |
| p2 = sp1; |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3; |
| |
| p3 = sp1; |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4; |
| |
| p4 = sp1; |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::shared_ptr<T const> sp2( sp1 ); |
| boost::local_shared_ptr<void const> p5; |
| |
| p5 = sp2; |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_shared_ptr_copy_assign_test_() |
| { |
| boost::shared_ptr<T> sp1; |
| |
| BOOST_TEST_EQ( sp1.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( sp1.use_count(), 0 ); |
| |
| boost::local_shared_ptr<T> p2( static_cast<T*>(0) ); |
| |
| p2 = sp1; |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( static_cast<T const*>(0) ); |
| |
| p3 = sp1; |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( static_cast<T*>(0) ); |
| |
| p4 = sp1; |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::shared_ptr<T const> sp2( sp1 ); |
| boost::local_shared_ptr<void const> p5( static_cast<T const*>(0) ); |
| |
| p5 = sp2; |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T> p2, boost::shared_ptr<U> const & p1 ) |
| { |
| long k = p1.use_count(); |
| |
| p2 = p1; |
| |
| BOOST_TEST( p2.get() == p1.get() ); |
| BOOST_TEST( p2.local_use_count() == 1 ); |
| BOOST_TEST( p1.use_count() == k + 1 ); |
| |
| p2.reset(); |
| |
| BOOST_TEST( p1.use_count() == k ); |
| } |
| |
| template<class T> static void null_shared_ptr_copy_assign_test() |
| { |
| boost::shared_ptr<T> p1( static_cast<T*>(0) ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T volatile>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const volatile>(), p1 ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), p1 ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void const>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void volatile>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void const volatile>(), p1 ); |
| } |
| |
| template<class T> static void new_shared_ptr_copy_assign_test() |
| { |
| boost::shared_ptr<T> p1( new T() ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T volatile>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const volatile>(), p1 ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), p1 ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T>( new T() ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const>( new T const() ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), p1 ); |
| |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void const>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void volatile>(), p1 ); |
| test_nonempty_shared_ptr_copy_assign( boost::local_shared_ptr<void const volatile>(), p1 ); |
| } |
| |
| static void shared_ptr_copy_assignment() |
| { |
| empty_shared_ptr_copy_assign_test<incomplete>(); |
| empty_shared_ptr_copy_assign_test<int>(); |
| empty_shared_ptr_copy_assign_test_<int>(); |
| empty_shared_ptr_copy_assign_test<X>(); |
| empty_shared_ptr_copy_assign_test_<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_shared_ptr_copy_assign_test<int>(); |
| null_shared_ptr_copy_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_shared_ptr_copy_assign_test<int>(); |
| new_shared_ptr_copy_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // shared_ptr_move assignment |
| |
| #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
| |
| template<class T> static void empty_shared_ptr_move_assign_test() |
| { |
| boost::local_shared_ptr<T> p2; |
| |
| p2 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3; |
| |
| p3 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4; |
| |
| p4 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5; |
| |
| p5 = boost::shared_ptr<T const>(); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_shared_ptr_move_assign_test_() |
| { |
| boost::local_shared_ptr<T> p2( static_cast<T*>(0) ); |
| |
| p2 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( static_cast<T const*>(0) ); |
| |
| p3 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( static_cast<T*>(0) ); |
| |
| p4 = boost::shared_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( static_cast<T const*>(0) ); |
| |
| p5 = boost::shared_ptr<T const>(); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U> static void test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T> p2, boost::shared_ptr<U> && p1 ) |
| { |
| U* q = p1.get(); |
| long k = p1.use_count(); |
| |
| p2 = std::move( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), q ); |
| BOOST_TEST_EQ( p2.local_use_count(), 1 ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| BOOST_TEST( p1.use_count() == 0 ); |
| |
| boost::shared_ptr<T> p3( p2 ); |
| |
| BOOST_TEST_EQ( p3.get(), q ); |
| BOOST_TEST_EQ( p3.use_count(), k + 1 ); |
| } |
| |
| template<class T> static void null_shared_ptr_move_assign_test() |
| { |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T volatile>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const volatile>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void const>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void volatile>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void const volatile>(), boost::shared_ptr<T>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_shared_ptr_move_assign_test() |
| { |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T volatile>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const volatile>(), boost::shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), boost::shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T>( new T() ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const>( new T const() ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), boost::shared_ptr<T>( new T() ) ); |
| |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void const>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void volatile>(), boost::shared_ptr<T>( new T() ) ); |
| test_nonempty_shared_ptr_move_assign( boost::local_shared_ptr<void const volatile>(), boost::shared_ptr<T>( new T() ) ); |
| } |
| |
| static void shared_ptr_move_assignment() |
| { |
| empty_shared_ptr_move_assign_test<incomplete>(); |
| empty_shared_ptr_move_assign_test<int>(); |
| empty_shared_ptr_move_assign_test_<int>(); |
| empty_shared_ptr_move_assign_test<X>(); |
| empty_shared_ptr_move_assign_test_<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_shared_ptr_move_assign_test<int>(); |
| null_shared_ptr_move_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_shared_ptr_move_assign_test<int>(); |
| new_shared_ptr_move_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void shared_ptr_move_assignment() |
| { |
| } |
| |
| #endif |
| |
| // unique_ptr assignment |
| |
| #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) && !defined( BOOST_NO_CXX11_SMART_PTR ) |
| |
| template<class T> static void empty_unique_ptr_assign_test() |
| { |
| boost::local_shared_ptr<T> p2; |
| |
| p2 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3; |
| |
| p3 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4; |
| |
| p4 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5; |
| |
| p5 = std::unique_ptr<T const>(); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_unique_ptr_assign_test_() |
| { |
| boost::local_shared_ptr<T> p2( static_cast<T*>(0) ); |
| |
| p2 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p2.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<T const> p3( static_cast<T const*>(0) ); |
| |
| p3 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p3.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p3.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void> p4( static_cast<T*>(0) ); |
| |
| p4 = std::unique_ptr<T>(); |
| |
| BOOST_TEST_EQ( p4.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p4.local_use_count(), 0 ); |
| |
| boost::local_shared_ptr<void const> p5( static_cast<T const*>(0) ); |
| |
| p5 = std::unique_ptr<T const>(); |
| |
| BOOST_TEST_EQ( p5.get(), static_cast<void*>(0) ); |
| BOOST_TEST_EQ( p5.local_use_count(), 0 ); |
| } |
| |
| template<class T, class U, class D> static void test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T> p2, std::unique_ptr<U, D> && p1 ) |
| { |
| U* q = p1.get(); |
| |
| p2 = std::move( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), q ); |
| BOOST_TEST_EQ( p2.local_use_count(), 1 ); |
| |
| BOOST_TEST( p1.get() == 0 ); |
| } |
| |
| template<class T> static void new_unique_ptr_assign_test() |
| { |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>(), std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>( new T() ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>( new T const() ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), std::unique_ptr<T>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void const>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void volatile>(), std::unique_ptr<T>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void const volatile>(), std::unique_ptr<T>( new T() ) ); |
| } |
| |
| template<class T> static void del_unique_ptr_assign_test() |
| { |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>( static_cast<T*>(0) ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>( static_cast<T const*>(0) ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>( static_cast<T volatile*>(0) ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>( static_cast<T const volatile*>(0) ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T>( new T() ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const>( new T const() ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T volatile>( new T volatile() ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<T const volatile>( new T const volatile() ), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void const>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void volatile>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| test_nonempty_unique_ptr_assign( boost::local_shared_ptr<void const volatile>(), std::unique_ptr<T, boost::checked_deleter<T>>( new T() ) ); |
| } |
| |
| static void unique_ptr_assignment() |
| { |
| empty_unique_ptr_assign_test<int>(); |
| empty_unique_ptr_assign_test_<int>(); |
| empty_unique_ptr_assign_test<X>(); |
| empty_unique_ptr_assign_test_<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_unique_ptr_assign_test<int>(); |
| new_unique_ptr_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| del_unique_ptr_assign_test<int>(); |
| del_unique_ptr_assign_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| #else |
| |
| static void unique_ptr_assignment() |
| { |
| } |
| |
| #endif |
| |
| // pointer reset |
| |
| template<class T, class U> static void test_pointer_reset( boost::local_shared_ptr<U> p2 ) |
| { |
| T * q = new T(); |
| |
| p2.reset( q ); |
| |
| BOOST_TEST_EQ( p2.get(), q ); |
| BOOST_TEST_EQ( p2.local_use_count(), 1 ); |
| } |
| |
| template<class T> static void empty_pointer_reset_test() |
| { |
| test_pointer_reset<T>( boost::local_shared_ptr<T>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T volatile>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const volatile>() ); |
| |
| test_pointer_reset<T>( boost::local_shared_ptr<void>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void volatile>() ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const volatile>() ); |
| } |
| |
| template<class T> static void null_pointer_reset_test() |
| { |
| test_pointer_reset<T>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T volatile>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const volatile>( static_cast<T*>(0) ) ); |
| |
| test_pointer_reset<T>( boost::local_shared_ptr<void>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void volatile>( static_cast<T*>(0) ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const volatile>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_pointer_reset_test() |
| { |
| test_pointer_reset<T>( boost::local_shared_ptr<T>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T volatile>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<T const volatile>( new T() ) ); |
| |
| test_pointer_reset<T>( boost::local_shared_ptr<void>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void volatile>( new T() ) ); |
| test_pointer_reset<T>( boost::local_shared_ptr<void const volatile>( new T() ) ); |
| } |
| |
| static void pointer_reset() |
| { |
| empty_pointer_reset_test<int>(); |
| empty_pointer_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_pointer_reset_test<int>(); |
| null_pointer_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_pointer_reset_test<int>(); |
| new_pointer_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // deleter reset |
| |
| template<class T> class deleter |
| { |
| private: |
| |
| bool * called_; |
| |
| public: |
| |
| explicit deleter( bool * called ): called_( called ) {} |
| void operator()( T * p ) { *called_ = true; delete p; } |
| }; |
| |
| template<class T, class U> static void test_deleter_reset( boost::local_shared_ptr<U> p2 ) |
| { |
| T * q = new T(); |
| |
| bool called = false; |
| |
| p2.reset( q, deleter<T>( &called ) ); |
| |
| BOOST_TEST_EQ( p2.get(), q ); |
| BOOST_TEST_EQ( p2.local_use_count(), 1 ); |
| |
| boost::shared_ptr<U> p3( p2 ); |
| |
| BOOST_TEST( boost::get_deleter< deleter<T> >( p3 ) != 0 ); |
| |
| p3.reset(); |
| BOOST_TEST( !called ); |
| |
| p2.reset(); |
| BOOST_TEST( called ); |
| } |
| |
| template<class T> static void empty_deleter_reset_test() |
| { |
| test_deleter_reset<T>( boost::local_shared_ptr<T>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T volatile>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const volatile>() ); |
| |
| test_deleter_reset<T>( boost::local_shared_ptr<void>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void volatile>() ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const volatile>() ); |
| } |
| |
| template<class T> static void null_deleter_reset_test() |
| { |
| test_deleter_reset<T>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T volatile>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const volatile>( static_cast<T*>(0) ) ); |
| |
| test_deleter_reset<T>( boost::local_shared_ptr<void>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void volatile>( static_cast<T*>(0) ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const volatile>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_deleter_reset_test() |
| { |
| test_deleter_reset<T>( boost::local_shared_ptr<T>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T volatile>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<T const volatile>( new T() ) ); |
| |
| test_deleter_reset<T>( boost::local_shared_ptr<void>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void volatile>( new T() ) ); |
| test_deleter_reset<T>( boost::local_shared_ptr<void const volatile>( new T() ) ); |
| } |
| |
| static void deleter_reset() |
| { |
| empty_deleter_reset_test<int>(); |
| empty_deleter_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_deleter_reset_test<int>(); |
| null_deleter_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_deleter_reset_test<int>(); |
| new_deleter_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // allocator reset |
| |
| template<class T, class U> static void test_allocator_reset( boost::local_shared_ptr<U> p2 ) |
| { |
| T * q = new T(); |
| |
| bool called = false; |
| |
| p2.reset( q, deleter<T>( &called ), std::allocator<T>() ); |
| |
| BOOST_TEST_EQ( p2.get(), q ); |
| BOOST_TEST_EQ( p2.local_use_count(), 1 ); |
| |
| boost::shared_ptr<U> p3( p2 ); |
| |
| BOOST_TEST( boost::get_deleter< deleter<T> >( p3 ) != 0 ); |
| |
| p3.reset(); |
| BOOST_TEST( !called ); |
| |
| p2.reset(); |
| BOOST_TEST( called ); |
| } |
| |
| template<class T> static void empty_allocator_reset_test() |
| { |
| test_allocator_reset<T>( boost::local_shared_ptr<T>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T volatile>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const volatile>() ); |
| |
| test_allocator_reset<T>( boost::local_shared_ptr<void>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void volatile>() ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const volatile>() ); |
| } |
| |
| template<class T> static void null_allocator_reset_test() |
| { |
| test_allocator_reset<T>( boost::local_shared_ptr<T>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T volatile>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const volatile>( static_cast<T*>(0) ) ); |
| |
| test_allocator_reset<T>( boost::local_shared_ptr<void>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void volatile>( static_cast<T*>(0) ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const volatile>( static_cast<T*>(0) ) ); |
| } |
| |
| template<class T> static void new_allocator_reset_test() |
| { |
| test_allocator_reset<T>( boost::local_shared_ptr<T>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T volatile>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<T const volatile>( new T() ) ); |
| |
| test_allocator_reset<T>( boost::local_shared_ptr<void>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void volatile>( new T() ) ); |
| test_allocator_reset<T>( boost::local_shared_ptr<void const volatile>( new T() ) ); |
| } |
| |
| static void allocator_reset() |
| { |
| empty_allocator_reset_test<int>(); |
| empty_allocator_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| null_allocator_reset_test<int>(); |
| null_allocator_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_allocator_reset_test<int>(); |
| new_allocator_reset_test<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // aliasing reset |
| |
| struct null_deleter |
| { |
| void operator()( void const volatile* ) {} |
| }; |
| |
| template<class T, class U> void test_aliasing_reset_( boost::local_shared_ptr<T> const & p1, U * p2 ) |
| { |
| boost::local_shared_ptr<U> p3( static_cast<U*>(0), null_deleter() ); |
| |
| p3.reset( p1, p2 ); |
| |
| BOOST_TEST( p3.get() == p2 ); |
| BOOST_TEST( p3.local_use_count() == p1.local_use_count() ); |
| BOOST_TEST( !p3.owner_before( p1 ) && !p1.owner_before( p3 ) ); |
| } |
| |
| template<class T, class U> void test_01_aliasing_reset_() |
| { |
| U u; |
| boost::local_shared_ptr<T> p1; |
| |
| test_aliasing_reset_( p1, &u ); |
| } |
| |
| template<class T, class U> void test_01_aliasing_reset() |
| { |
| test_01_aliasing_reset_<T, U>(); |
| test_01_aliasing_reset_<T const, U>(); |
| test_01_aliasing_reset_<T volatile, U>(); |
| test_01_aliasing_reset_<T const volatile, U>(); |
| |
| test_01_aliasing_reset_<T, U volatile>(); |
| test_01_aliasing_reset_<T const, U volatile>(); |
| test_01_aliasing_reset_<T volatile, U volatile>(); |
| test_01_aliasing_reset_<T const volatile, U volatile>(); |
| } |
| |
| template<class T, class U> void test_10_aliasing_reset_() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| test_aliasing_reset_( p1, static_cast<U*>(0) ); |
| } |
| |
| template<class T, class U> void test_10_aliasing_reset() |
| { |
| test_10_aliasing_reset_<T, U>(); |
| test_10_aliasing_reset_<T const, U>(); |
| test_10_aliasing_reset_<T volatile, U>(); |
| test_10_aliasing_reset_<T const volatile, U>(); |
| |
| test_10_aliasing_reset_<T, U const>(); |
| test_10_aliasing_reset_<T const, U const>(); |
| test_10_aliasing_reset_<T volatile, U const>(); |
| test_10_aliasing_reset_<T const volatile, U const>(); |
| |
| test_10_aliasing_reset_<T, U volatile>(); |
| test_10_aliasing_reset_<T const, U volatile>(); |
| test_10_aliasing_reset_<T volatile, U volatile>(); |
| test_10_aliasing_reset_<T const volatile, U volatile>(); |
| |
| test_10_aliasing_reset_<T, U const volatile>(); |
| test_10_aliasing_reset_<T const, U const volatile>(); |
| test_10_aliasing_reset_<T volatile, U const volatile>(); |
| test_10_aliasing_reset_<T const volatile, U const volatile>(); |
| } |
| |
| template<class T, class U> void test_11_aliasing_reset_() |
| { |
| U u; |
| boost::local_shared_ptr<T> p1( new T() ); |
| |
| test_aliasing_reset_( p1, &u ); |
| } |
| |
| template<class T, class U> void test_11_aliasing_reset() |
| { |
| test_11_aliasing_reset_<T, U>(); |
| test_11_aliasing_reset_<T const, U>(); |
| test_11_aliasing_reset_<T volatile, U>(); |
| test_11_aliasing_reset_<T const volatile, U>(); |
| |
| test_11_aliasing_reset_<T, U volatile>(); |
| test_11_aliasing_reset_<T const, U volatile>(); |
| test_11_aliasing_reset_<T volatile, U volatile>(); |
| test_11_aliasing_reset_<T const volatile, U volatile>(); |
| } |
| |
| static void aliasing_reset() |
| { |
| test_01_aliasing_reset<int, int>(); |
| test_10_aliasing_reset<int, int>(); |
| test_11_aliasing_reset<int, int>(); |
| |
| test_01_aliasing_reset<void, int>(); |
| |
| test_10_aliasing_reset<int, void>(); |
| |
| test_10_aliasing_reset<int, incomplete>(); |
| |
| test_01_aliasing_reset<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing_reset<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing_reset<X, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing_reset<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing_reset<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing_reset<int, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing_reset<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing_reset<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_11_aliasing_reset<X, int>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_01_aliasing_reset<void, X>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing_reset<X, void>(); |
| BOOST_TEST( X::instances == 0 ); |
| |
| test_10_aliasing_reset<X, incomplete>(); |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // element access |
| |
| template<class T> static void empty_element_access_() |
| { |
| boost::local_shared_ptr<T> p1; |
| |
| BOOST_TEST_EQ( p1.operator->(), static_cast<T*>(0) ); |
| BOOST_TEST_EQ( p1.get(), static_cast<T*>(0) ); |
| BOOST_TEST( p1? false: true ); |
| BOOST_TEST( !p1 ); |
| BOOST_TEST_EQ( p1.local_use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_element_access() |
| { |
| empty_element_access_<T>(); |
| empty_element_access_<T const>(); |
| empty_element_access_<T volatile>(); |
| empty_element_access_<T const volatile>(); |
| } |
| |
| template<class T> static void new_element_access_() |
| { |
| { |
| T * p0 = new T(); |
| boost::local_shared_ptr<T> p1( p0 ); |
| |
| BOOST_TEST_EQ( p1.operator->(), p0 ); |
| BOOST_TEST_EQ( p1.get(), p0 ); |
| BOOST_TEST_EQ( &*p1, p0 ); |
| BOOST_TEST( p1? true: false ); |
| BOOST_TEST_NOT( !p1 ); |
| BOOST_TEST_EQ( p1.local_use_count(), 1 ); |
| } |
| |
| { |
| T * p0 = new T[3](); |
| boost::local_shared_ptr<T[]> p1( p0 ); |
| |
| BOOST_TEST_EQ( p1.get(), p0 ); |
| |
| BOOST_TEST_EQ( &p1[0], &p0[0] ); |
| BOOST_TEST_EQ( &p1[1], &p0[1] ); |
| BOOST_TEST_EQ( &p1[2], &p0[2] ); |
| |
| BOOST_TEST( p1? true: false ); |
| BOOST_TEST_NOT( !p1 ); |
| BOOST_TEST_EQ( p1.local_use_count(), 1 ); |
| } |
| |
| { |
| T * p0 = new T[3](); |
| boost::local_shared_ptr<T[3]> p1( p0 ); |
| |
| BOOST_TEST_EQ( p1.get(), p0 ); |
| |
| BOOST_TEST_EQ( &p1[0], &p0[0] ); |
| BOOST_TEST_EQ( &p1[1], &p0[1] ); |
| BOOST_TEST_EQ( &p1[2], &p0[2] ); |
| |
| BOOST_TEST( p1? true: false ); |
| BOOST_TEST_NOT( !p1 ); |
| BOOST_TEST_EQ( p1.local_use_count(), 1 ); |
| } |
| } |
| |
| template<class T> static void new_element_access() |
| { |
| new_element_access_<T>(); |
| new_element_access_<T const>(); |
| new_element_access_<T volatile>(); |
| new_element_access_<T const volatile>(); |
| } |
| |
| static void element_access() |
| { |
| empty_element_access<int>(); |
| empty_element_access<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| empty_element_access<incomplete>(); |
| empty_element_access<void>(); |
| |
| new_element_access<int>(); |
| new_element_access<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // shared_ptr conversion |
| |
| template<class T, class U> static void empty_shared_ptr_conversion_() |
| { |
| boost::local_shared_ptr<T> p1; |
| boost::shared_ptr<U> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), static_cast<U*>(0) ); |
| BOOST_TEST_EQ( p2.use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_shared_ptr_conversion() |
| { |
| empty_shared_ptr_conversion_<T, T>(); |
| empty_shared_ptr_conversion_<T, T const>(); |
| empty_shared_ptr_conversion_<T, T volatile>(); |
| empty_shared_ptr_conversion_<T, T const volatile>(); |
| |
| empty_shared_ptr_conversion_<T const, T const>(); |
| empty_shared_ptr_conversion_<T volatile, T volatile>(); |
| empty_shared_ptr_conversion_<T const volatile, T const volatile>(); |
| |
| empty_shared_ptr_conversion_<T, void>(); |
| empty_shared_ptr_conversion_<T, void const>(); |
| empty_shared_ptr_conversion_<T, void volatile>(); |
| empty_shared_ptr_conversion_<T, void const volatile>(); |
| |
| empty_shared_ptr_conversion_<T const, void const>(); |
| empty_shared_ptr_conversion_<T volatile, void volatile>(); |
| empty_shared_ptr_conversion_<T const volatile, void const volatile>(); |
| } |
| |
| template<class T, class U> static void new_shared_ptr_conversion_() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| boost::shared_ptr<U> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.get(), p1.get() ); |
| BOOST_TEST_EQ( p2.use_count(), 2 ); |
| |
| boost::shared_ptr<U> p3( p1 ); |
| |
| BOOST_TEST_EQ( p3.get(), p1.get() ); |
| BOOST_TEST_EQ( p3.use_count(), 3 ); |
| BOOST_TEST( !(p2 < p3) && !(p3 < p2) ); |
| |
| BOOST_TEST_EQ( p1.local_use_count(), 1 ); |
| |
| p1.reset(); |
| |
| BOOST_TEST_EQ( p2.use_count(), 2 ); |
| BOOST_TEST_EQ( p3.use_count(), 2 ); |
| } |
| |
| template<class T> static void new_shared_ptr_conversion() |
| { |
| new_shared_ptr_conversion_<T, T>(); |
| new_shared_ptr_conversion_<T, T const>(); |
| new_shared_ptr_conversion_<T, T volatile>(); |
| new_shared_ptr_conversion_<T, T const volatile>(); |
| |
| new_shared_ptr_conversion_<T const, T const>(); |
| new_shared_ptr_conversion_<T volatile, T volatile>(); |
| new_shared_ptr_conversion_<T const volatile, T const volatile>(); |
| |
| new_shared_ptr_conversion_<T, void>(); |
| new_shared_ptr_conversion_<T, void const>(); |
| new_shared_ptr_conversion_<T, void volatile>(); |
| new_shared_ptr_conversion_<T, void const volatile>(); |
| |
| new_shared_ptr_conversion_<T const, void const>(); |
| new_shared_ptr_conversion_<T volatile, void volatile>(); |
| new_shared_ptr_conversion_<T const volatile, void const volatile>(); |
| } |
| |
| static void shared_ptr_conversion() |
| { |
| empty_shared_ptr_conversion<void>(); |
| empty_shared_ptr_conversion<incomplete>(); |
| empty_shared_ptr_conversion<int>(); |
| empty_shared_ptr_conversion<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_shared_ptr_conversion<int>(); |
| new_shared_ptr_conversion<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // weak_ptr conversion |
| |
| template<class T, class U> static void empty_weak_ptr_conversion_() |
| { |
| boost::local_shared_ptr<T> p1; |
| boost::weak_ptr<U> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.lock().get(), static_cast<U*>(0) ); |
| BOOST_TEST_EQ( p2.use_count(), 0 ); |
| } |
| |
| template<class T> static void empty_weak_ptr_conversion() |
| { |
| empty_weak_ptr_conversion_<T, T>(); |
| empty_weak_ptr_conversion_<T, T const>(); |
| empty_weak_ptr_conversion_<T, T volatile>(); |
| empty_weak_ptr_conversion_<T, T const volatile>(); |
| |
| empty_weak_ptr_conversion_<T const, T const>(); |
| empty_weak_ptr_conversion_<T volatile, T volatile>(); |
| empty_weak_ptr_conversion_<T const volatile, T const volatile>(); |
| |
| empty_weak_ptr_conversion_<T, void>(); |
| empty_weak_ptr_conversion_<T, void const>(); |
| empty_weak_ptr_conversion_<T, void volatile>(); |
| empty_weak_ptr_conversion_<T, void const volatile>(); |
| |
| empty_weak_ptr_conversion_<T const, void const>(); |
| empty_weak_ptr_conversion_<T volatile, void volatile>(); |
| empty_weak_ptr_conversion_<T const volatile, void const volatile>(); |
| } |
| |
| template<class T, class U> static void new_weak_ptr_conversion_() |
| { |
| boost::local_shared_ptr<T> p1( new T() ); |
| boost::weak_ptr<U> p2( p1 ); |
| |
| BOOST_TEST_EQ( p2.lock().get(), p1.get() ); |
| BOOST_TEST_EQ( p2.use_count(), 1 ); |
| |
| boost::weak_ptr<U> p3( p1 ); |
| |
| BOOST_TEST_EQ( p3.lock().get(), p1.get() ); |
| BOOST_TEST_EQ( p3.use_count(), 1 ); |
| BOOST_TEST( !(p2 < p3) && !(p3 < p2) ); |
| |
| BOOST_TEST_EQ( p1.local_use_count(), 1 ); |
| |
| p1.reset(); |
| |
| BOOST_TEST_EQ( p2.use_count(), 0 ); |
| BOOST_TEST_EQ( p3.use_count(), 0 ); |
| } |
| |
| template<class T> static void new_weak_ptr_conversion() |
| { |
| new_weak_ptr_conversion_<T, T>(); |
| new_weak_ptr_conversion_<T, T const>(); |
| new_weak_ptr_conversion_<T, T volatile>(); |
| new_weak_ptr_conversion_<T, T const volatile>(); |
| |
| new_weak_ptr_conversion_<T const, T const>(); |
| new_weak_ptr_conversion_<T volatile, T volatile>(); |
| new_weak_ptr_conversion_<T const volatile, T const volatile>(); |
| |
| new_weak_ptr_conversion_<T, void>(); |
| new_weak_ptr_conversion_<T, void const>(); |
| new_weak_ptr_conversion_<T, void volatile>(); |
| new_weak_ptr_conversion_<T, void const volatile>(); |
| |
| new_weak_ptr_conversion_<T const, void const>(); |
| new_weak_ptr_conversion_<T volatile, void volatile>(); |
| new_weak_ptr_conversion_<T const volatile, void const volatile>(); |
| } |
| |
| static void weak_ptr_conversion() |
| { |
| empty_weak_ptr_conversion<void>(); |
| empty_weak_ptr_conversion<incomplete>(); |
| empty_weak_ptr_conversion<int>(); |
| empty_weak_ptr_conversion<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| |
| new_weak_ptr_conversion<int>(); |
| new_weak_ptr_conversion<X>(); |
| |
| BOOST_TEST( X::instances == 0 ); |
| } |
| |
| // main |
| |
| int main() |
| { |
| default_constructor(); |
| nullptr_constructor(); |
| pointer_constructor(); |
| deleter_constructor(); |
| copy_constructor(); |
| move_constructor(); |
| aliasing_constructor(); |
| nullptr_deleter_constructor(); |
| allocator_constructor(); |
| nullptr_allocator_constructor(); |
| shared_ptr_copy_constructor(); |
| shared_ptr_move_constructor(); |
| unique_ptr_constructor(); |
| |
| copy_assignment(); |
| move_assignment(); |
| nullptr_assignment(); |
| shared_ptr_copy_assignment(); |
| shared_ptr_move_assignment(); |
| unique_ptr_assignment(); |
| |
| default_reset(); |
| pointer_reset(); |
| deleter_reset(); |
| allocator_reset(); |
| aliasing_reset(); |
| |
| element_access(); |
| shared_ptr_conversion(); |
| weak_ptr_conversion(); |
| // swap_test(); |
| // owner_before_test(); |
| // equal_test(); |
| // operator< ? |
| // casts |
| // get_pointer |
| // operator<< |
| // hash |
| |
| return boost::report_errors(); |
| } |