From aeadd6aeff450f3a43a6089c09e8c4830b2d7928 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Sun, 4 Jun 2017 21:24:20 +0300 Subject: [PATCH 1/4] Initial commit of local_shared_ptr --- .../smart_ptr/detail/local_counted_base.hpp | 109 ++++ include/boost/smart_ptr/local_shared_ptr.hpp | 517 ++++++++++++++++++ test/Jamfile.v2 | 2 + test/local_sp_test.cpp | 275 ++++++++++ 4 files changed, 903 insertions(+) create mode 100644 include/boost/smart_ptr/detail/local_counted_base.hpp create mode 100644 include/boost/smart_ptr/local_shared_ptr.hpp create mode 100644 test/local_sp_test.cpp diff --git a/include/boost/smart_ptr/detail/local_counted_base.hpp b/include/boost/smart_ptr/detail/local_counted_base.hpp new file mode 100644 index 0000000..f0b5378 --- /dev/null +++ b/include/boost/smart_ptr/detail/local_counted_base.hpp @@ -0,0 +1,109 @@ +#ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/local_counted_base.hpp +// +// http://www.boost.org/libs/smart_ptr/ +// +// Copyright 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 +#include +#include +#include + +namespace boost +{ + +namespace detail +{ + +class local_counted_base +{ +private: + + local_counted_base( local_counted_base const & ); + local_counted_base & operator= ( local_counted_base const & ); + +private: + + // not 'int' or 'unsigned' to avoid aliasing and enable optimizations + enum count_type { min_ = 0, initial_ = 1, max_ = UINT_MAX }; + + count_type local_use_count_; + +public: + + BOOST_CONSTEXPR local_counted_base() BOOST_NOEXCEPT: local_use_count_( initial_ ) + { + } + + virtual ~local_counted_base() BOOST_NOEXCEPT + { + } + + void add_ref() + { +#if defined( __has_builtin ) +# if __has_builtin( __builtin_assume ) + + __builtin_assume( local_use_count_ >= 1 ); + +# endif +#endif + + local_use_count_ = static_cast( local_use_count_ + 1 ); + } + + void release() + { + local_use_count_ = static_cast( local_use_count_ - 1 ); + + if( local_use_count_ == 0 ) + { + delete this; + } + } + + long local_use_count() const BOOST_NOEXCEPT + { + return local_use_count_; + } +}; + +class local_counted_impl: public local_counted_base +{ +private: + + boost::shared_ptr pn_; + +public: + + template explicit local_counted_impl( boost::shared_ptr const& pn ): pn_( pn ) + { + } + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template explicit local_counted_impl( boost::shared_ptr&& pn ): pn_( std::move(pn) ) + { + } + +#endif +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED diff --git a/include/boost/smart_ptr/local_shared_ptr.hpp b/include/boost/smart_ptr/local_shared_ptr.hpp new file mode 100644 index 0000000..1d8e592 --- /dev/null +++ b/include/boost/smart_ptr/local_shared_ptr.hpp @@ -0,0 +1,517 @@ +#ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED +#define BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED + +// local_shared_ptr.hpp +// +// http://www.boost.org/libs/smart_ptr/ +// +// Copyright 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 +#include + +namespace boost +{ + +namespace detail +{ + +} // namespace detail + +// +// local_shared_ptr +// +// as shared_ptr, but local to a thread. +// reference count manipulations are non-atomic. +// + +template class local_shared_ptr +{ +private: + + typedef local_shared_ptr this_type; + +public: + + typedef typename boost::detail::sp_element::type element_type; + +private: + + element_type * px; + boost::detail::local_counted_base * pn; + + template friend class local_shared_ptr; + +public: + + // destructor + + ~local_shared_ptr() + { + if( pn ) + { + pn->release(); + } + } + + // constructors + + BOOST_CONSTEXPR local_shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 ) + { + } + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + BOOST_CONSTEXPR local_shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 ) + { + } + +#endif + + template + explicit local_shared_ptr( Y * p ): px( p ), + pn( new boost::detail::local_counted_impl( shared_ptr( p ) ) ) + { + } + + template local_shared_ptr( Y * p, D d ): px( p ), + pn( new boost::detail::local_counted_impl( shared_ptr( p, d ) ) ) + { + } + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + template local_shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), + pn( new boost::detail::local_counted_impl( shared_ptr( p, d ) ) ) + { + } + +#endif + + template local_shared_ptr( Y * p, D d, A a ): px( p ), + pn( new boost::detail::local_counted_impl( shared_ptr( p, d, a ) ) ) + { + } + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + template local_shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), + pn( new boost::detail::local_counted_impl( shared_ptr( p, d, a ) ) ) + { + } + +#endif + + // construction from shared_ptr + + template local_shared_ptr( shared_ptr const & r, + typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) + : px( r.get() ), pn( new boost::detail::local_counted_impl( r ) ) + { + boost::detail::sp_assert_convertible< Y, T >(); + } + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template local_shared_ptr( shared_ptr && r, + typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) + : px( r.get() ), pn( new boost::detail::local_counted_impl( std::move(r) ) ) + { + boost::detail::sp_assert_convertible< Y, T >(); + } + +#endif + + // construction from unique_ptr + +#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template< class Y, class D > + local_shared_ptr( std::unique_ptr< Y, D > && r ) + : px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr( std::move(r) ) ) ) + { + boost::detail::sp_assert_convertible< Y, T >(); + } + +#endif + + template< class Y, class D > + local_shared_ptr( boost::movelib::unique_ptr< Y, D > r ); // ! + // : px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr( std::move(r) ) ) ) + //{ + // boost::detail::sp_assert_convertible< Y, T >(); + //} + + // copy constructor + + local_shared_ptr( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn ) + { + if( pn ) + { + pn->add_ref(); + } + } + + // move constructor + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + local_shared_ptr( local_shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn ) + { + r.px = 0; + r.pn = 0; + } + +#endif + + // converting copy constructor + + template local_shared_ptr( local_shared_ptr const & r, + typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT + : px( r.px ), pn( r.pn ) + { + boost::detail::sp_assert_convertible< Y, T >(); + + if( pn ) + { + pn->add_ref(); + } + } + + // converting move constructor + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template local_shared_ptr( local_shared_ptr && r, + typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT + : px( r.px ), pn( r.pn ) + { + boost::detail::sp_assert_convertible< Y, T >(); + + r.px = 0; + r.pn = 0; + } + +#endif + + // aliasing + + template + local_shared_ptr( local_shared_ptr const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn ) + { + if( pn ) + { + pn->add_ref(); + } + } + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template + local_shared_ptr( local_shared_ptr && r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn ) + { + r.px = 0; + r.pn = 0; + } + +#endif + + // assignment + + local_shared_ptr & operator=( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT + { + local_shared_ptr( r ).swap( *this ); + return *this; + } + + template local_shared_ptr & operator=( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT + { + local_shared_ptr( r ).swap( *this ); + return *this; + } + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + local_shared_ptr & operator=( local_shared_ptr && r ) BOOST_SP_NOEXCEPT + { + local_shared_ptr( std::move( r ) ).swap( *this ); + return *this; + } + + template + local_shared_ptr & operator=( local_shared_ptr && r ) BOOST_SP_NOEXCEPT + { + local_shared_ptr( std::move( r ) ).swap( *this ); + return *this; + } + +#endif + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + local_shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT + { + local_shared_ptr().swap(*this); + return *this; + } + +#endif + +#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template + local_shared_ptr & operator=( std::unique_ptr && r ) + { + local_shared_ptr( std::move(r) ).swap( *this ); + return *this; + } + +#endif + + template + local_shared_ptr & operator=( boost::movelib::unique_ptr r ); // ! + + // reset + + void reset() BOOST_SP_NOEXCEPT + { + local_shared_ptr().swap( *this ); + } + + template void reset( Y * p ) // Y must be complete + { + local_shared_ptr( p ).swap( *this ); + } + + template void reset( Y * p, D d ) + { + local_shared_ptr( p, d ).swap( *this ); + } + + template void reset( Y * p, D d, A a ) + { + local_shared_ptr( p, d, a ).swap( *this ); + } + + template void reset( local_shared_ptr const & r, element_type * p ) + { + local_shared_ptr( r, p ).swap( *this ); + } + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + + template void reset( local_shared_ptr && r, element_type * p ) + { + local_shared_ptr( std::move( r ), p ).swap( *this ); + } + +#endif + + // accessors + + typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT + { + return *px; + } + + typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT + { + return px; + } + + // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT) + typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const + { + BOOST_ASSERT( px != 0 ); + BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) ); + + return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] ); + } + + element_type * get() const BOOST_NOEXCEPT + { + return px; + } + + // implicit conversion to "bool" +#include + + long local_use_count() const BOOST_SP_NOEXCEPT + { + return pn? pn->local_use_count(): 0; + } + + // swap + + void swap( local_shared_ptr & r ) BOOST_SP_NOEXCEPT + { + std::swap( px, r.px ); + std::swap( pn, r.pn ); + } + + // owner_before + + template bool owner_before( local_shared_ptr const & r ) const BOOST_SP_NOEXCEPT + { + return std::less< boost::detail::local_counted_base* >()( pn, r.pn ); + } +}; + +template inline bool operator==( local_shared_ptr const & a, local_shared_ptr const & b ) BOOST_SP_NOEXCEPT +{ + return a.get() == b.get(); +} + +template inline bool operator!=( local_shared_ptr const & a, local_shared_ptr const & b ) BOOST_SP_NOEXCEPT +{ + return a.get() != b.get(); +} + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +template inline bool operator==( local_shared_ptr const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT +{ + return p.get() == 0; +} + +template inline bool operator==( boost::detail::sp_nullptr_t, local_shared_ptr const & p ) BOOST_SP_NOEXCEPT +{ + return p.get() == 0; +} + +template inline bool operator!=( local_shared_ptr const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT +{ + return p.get() != 0; +} + +template inline bool operator!=( boost::detail::sp_nullptr_t, local_shared_ptr const & p ) BOOST_SP_NOEXCEPT +{ + return p.get() != 0; +} + +#endif + +template inline void swap( local_shared_ptr & a, local_shared_ptr & b ) BOOST_SP_NOEXCEPT +{ + a.swap( b ); +} + +template local_shared_ptr static_pointer_cast( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT +{ + (void) static_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = static_cast< E* >( r.get() ); + return local_shared_ptr( r, p ); +} + +template local_shared_ptr const_pointer_cast( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT +{ + (void) const_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = const_cast< E* >( r.get() ); + return local_shared_ptr( r, p ); +} + +template local_shared_ptr dynamic_pointer_cast( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT +{ + (void) dynamic_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = dynamic_cast< E* >( r.get() ); + return p? local_shared_ptr( r, p ): local_shared_ptr(); +} + +template local_shared_ptr reinterpret_pointer_cast( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT +{ + (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = reinterpret_cast< E* >( r.get() ); + return local_shared_ptr( r, p ); +} + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +template local_shared_ptr static_pointer_cast( local_shared_ptr && r ) BOOST_SP_NOEXCEPT +{ + (void) static_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = static_cast< E* >( r.get() ); + return local_shared_ptr( std::move(r), p ); +} + +template local_shared_ptr const_pointer_cast( local_shared_ptr && r ) BOOST_SP_NOEXCEPT +{ + (void) const_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = const_cast< E* >( r.get() ); + return local_shared_ptr( std::move(r), p ); +} + +template local_shared_ptr dynamic_pointer_cast( local_shared_ptr && r ) BOOST_SP_NOEXCEPT +{ + (void) dynamic_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = dynamic_cast< E* >( r.get() ); + return p? local_shared_ptr( std::move(r), p ): local_shared_ptr(); +} + +template local_shared_ptr reinterpret_pointer_cast( local_shared_ptr && r ) BOOST_SP_NOEXCEPT +{ + (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) ); + + typedef typename local_shared_ptr::element_type E; + + E * p = reinterpret_cast< E* >( r.get() ); + return local_shared_ptr( std::move(r), p ); +} + +#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +// get_pointer() enables boost::mem_fn to recognize local_shared_ptr + +template inline typename local_shared_ptr::element_type * get_pointer( local_shared_ptr const & p ) BOOST_SP_NOEXCEPT +{ + return p.get(); +} + +// operator<< + +#if !defined(BOOST_NO_IOSTREAM) + +template std::basic_ostream & operator<< ( std::basic_ostream & os, local_shared_ptr const & p ) +{ + os << p.get(); + return os; +} + +#endif // !defined(BOOST_NO_IOSTREAM) + +// hash_value + +template< class T > struct hash; + +template< class T > std::size_t hash_value( local_shared_ptr const & p ) BOOST_NOEXCEPT +{ + return boost::hash< typename local_shared_ptr::element_type* >()( p.get() ); +} + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 2c82726..f5b69b9 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -210,5 +210,7 @@ import testing ; [ compile make_shared_msvc_test.cpp ] [ compile lwm_win32_cs_test.cpp ] + + [ run local_sp_test.cpp ] ; } diff --git a/test/local_sp_test.cpp b/test/local_sp_test.cpp new file mode 100644 index 0000000..36ee0a1 --- /dev/null +++ b/test/local_sp_test.cpp @@ -0,0 +1,275 @@ +// +// 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 +#include + +struct X +{ + static long instances; + + X() + { + ++instances; + } + + ~X() + { + --instances; + } + +private: + + X( X const & ); + X & operator=( X const & ); +}; + +long X::instances = 0; + +class incomplete; + +static void default_constructor() +{ + { + boost::local_shared_ptr p; + + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); + } + + { + boost::local_shared_ptr p; + + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); + } + + { + boost::local_shared_ptr p; + + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); + } + + BOOST_TEST( X::instances == 0 ); + + { + boost::local_shared_ptr p; + + BOOST_TEST( X::instances == 0 ); + + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); + } +} + +template static void pc0_test_() +{ + boost::local_shared_ptr p( static_cast( 0 ) ); + + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 1 ); +} + +template static void pc0_test() +{ + pc0_test_(); + pc0_test_(); + pc0_test_(); + pc0_test_(); + + pc0_test_(); + pc0_test_(); + pc0_test_(); + + pc0_test_(); + pc0_test_(); + pc0_test_(); + pc0_test_(); +} + +template static void pc1_test_() +{ + boost::local_shared_ptr p( new U() ); + + BOOST_TEST( p? true: false ); + BOOST_TEST( !!p ); + BOOST_TEST( p.get() != 0 ); + BOOST_TEST( p.local_use_count() == 1 ); +} + +template static void pc1_test() +{ + pc1_test_(); + pc1_test_(); + pc1_test_(); + pc1_test_(); + + pc1_test_(); + pc1_test_(); + pc1_test_(); + + pc1_test_(); + pc1_test_(); + pc1_test_(); + pc1_test_(); +} + +static void pointer_constructor() +{ + pc0_test(); + pc0_test(); + + pc1_test(); + + BOOST_TEST( X::instances == 0 ); + + pc1_test(); + + BOOST_TEST( X::instances == 0 ); +} + +int m = 0; + +void deleter2( int * p ) +{ + BOOST_TEST( p == &m ); + ++*p; +} + +template static void deleter2_test_() +{ + { + m = 0; + boost::local_shared_ptr 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_(); + deleter2_test_(); + deleter2_test_(); + deleter2_test_(); + + deleter2_test_(); + deleter2_test_(); + deleter2_test_(); + deleter2_test_(); +} + +template static void test_empty( boost::local_shared_ptr const & p ) +{ + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); +} + +template static void empty_copy_test() +{ + boost::local_shared_ptr p1; + test_empty( p1 ); + + boost::local_shared_ptr p2( p1 ); + test_empty( p2 ); + + boost::local_shared_ptr p3( p1 ); + test_empty( p3 ); + + boost::local_shared_ptr p4( p1 ); + test_empty( p4 ); + + boost::local_shared_ptr p5( p3 ); + test_empty( p5 ); +} + +template static void test_nonempty_copy( boost::local_shared_ptr const & p1 ) +{ + long k = p1.local_use_count(); + + { + boost::local_shared_ptr 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 static void null_copy_test() +{ + boost::local_shared_ptr p1( static_cast(0) ); + + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); +} + +template static void new_copy_test() +{ + boost::local_shared_ptr p1( new T() ); + + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); + test_nonempty_copy( p1 ); +} + +static void copy_constructor() +{ + empty_copy_test(); + empty_copy_test(); + empty_copy_test(); + + null_copy_test(); + null_copy_test(); + + new_copy_test(); + new_copy_test(); +} + +int main() +{ + default_constructor(); + pointer_constructor(); + deleter_constructor(); + copy_constructor(); + + return boost::report_errors(); +} From b18f68324fcbcfccefd1875a5d80225c57ec3f32 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Mon, 5 Jun 2017 16:38:41 +0300 Subject: [PATCH 2/4] Add more tests --- test/local_sp_test.cpp | 205 +++++++++++++++++++++++++++++++++++------ 1 file changed, 178 insertions(+), 27 deletions(-) diff --git a/test/local_sp_test.cpp b/test/local_sp_test.cpp index 36ee0a1..d3388f7 100644 --- a/test/local_sp_test.cpp +++ b/test/local_sp_test.cpp @@ -35,33 +35,29 @@ long X::instances = 0; class incomplete; +template static void test_empty( boost::local_shared_ptr const & p ) +{ + BOOST_TEST( p? false: true ); + BOOST_TEST( !p ); + BOOST_TEST( p.get() == 0 ); + BOOST_TEST( p.local_use_count() == 0 ); +} + static void default_constructor() { { boost::local_shared_ptr p; - - BOOST_TEST( p? false: true ); - BOOST_TEST( !p ); - BOOST_TEST( p.get() == 0 ); - BOOST_TEST( p.local_use_count() == 0 ); + test_empty( p ); } { boost::local_shared_ptr p; - - BOOST_TEST( p? false: true ); - BOOST_TEST( !p ); - BOOST_TEST( p.get() == 0 ); - BOOST_TEST( p.local_use_count() == 0 ); + test_empty( p ); } { boost::local_shared_ptr p; - - BOOST_TEST( p? false: true ); - BOOST_TEST( !p ); - BOOST_TEST( p.get() == 0 ); - BOOST_TEST( p.local_use_count() == 0 ); + test_empty( p ); } BOOST_TEST( X::instances == 0 ); @@ -71,13 +67,42 @@ static void default_constructor() BOOST_TEST( X::instances == 0 ); - BOOST_TEST( p? false: true ); - BOOST_TEST( !p ); - BOOST_TEST( p.get() == 0 ); - BOOST_TEST( p.local_use_count() == 0 ); + test_empty( p ); } } +static void nullptr_constructor() +{ +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + { + boost::local_shared_ptr p( nullptr ); + test_empty( p ); + } + + { + boost::local_shared_ptr p( nullptr ); + test_empty( p ); + } + + { + boost::local_shared_ptr p( nullptr ); + test_empty( p ); + } + + BOOST_TEST( X::instances == 0 ); + + { + boost::local_shared_ptr p( nullptr ); + + BOOST_TEST( X::instances == 0 ); + + test_empty( p ); + } + +#endif +} + template static void pc0_test_() { boost::local_shared_ptr p( static_cast( 0 ) ); @@ -182,14 +207,6 @@ static void deleter_constructor() deleter2_test_(); } -template static void test_empty( boost::local_shared_ptr const & p ) -{ - BOOST_TEST( p? false: true ); - BOOST_TEST( !p ); - BOOST_TEST( p.get() == 0 ); - BOOST_TEST( p.local_use_count() == 0 ); -} - template static void empty_copy_test() { boost::local_shared_ptr p1; @@ -256,20 +273,154 @@ static void copy_constructor() empty_copy_test(); empty_copy_test(); empty_copy_test(); + BOOST_TEST( X::instances == 0 ); null_copy_test(); null_copy_test(); + BOOST_TEST( X::instances == 0 ); new_copy_test(); new_copy_test(); + BOOST_TEST( X::instances == 0 ); +} + +template void test_aliasing_( boost::local_shared_ptr const & p1, U * p2 ) +{ + boost::local_shared_ptr 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 void test_01_aliasing_() +{ + U u; + boost::local_shared_ptr p1; + + test_aliasing_( p1, &u ); +} + +template void test_01_aliasing() +{ + test_01_aliasing_(); + test_01_aliasing_(); + test_01_aliasing_(); + test_01_aliasing_(); + + test_01_aliasing_(); + test_01_aliasing_(); + test_01_aliasing_(); + test_01_aliasing_(); +} + +template void test_10_aliasing_() +{ + boost::local_shared_ptr p1( new T() ); + test_aliasing_( p1, static_cast(0) ); +} + +template void test_10_aliasing() +{ + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); + test_10_aliasing_(); +} + +template void test_11_aliasing_() +{ + U u; + boost::local_shared_ptr p1( new T() ); + + test_aliasing_( p1, &u ); +} + +template void test_11_aliasing() +{ + test_11_aliasing_(); + test_11_aliasing_(); + test_11_aliasing_(); + test_11_aliasing_(); + + test_11_aliasing_(); + test_11_aliasing_(); + test_11_aliasing_(); + test_11_aliasing_(); +} + +static void aliasing_constructor() +{ + test_01_aliasing(); + test_10_aliasing(); + test_11_aliasing(); + + test_01_aliasing(); + + test_10_aliasing(); + + test_10_aliasing(); + + test_01_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_10_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_11_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_01_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_10_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_11_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_01_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_10_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_11_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_01_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_10_aliasing(); + BOOST_TEST( X::instances == 0 ); + + test_10_aliasing(); + BOOST_TEST( X::instances == 0 ); } int main() { default_constructor(); + nullptr_constructor(); pointer_constructor(); deleter_constructor(); copy_constructor(); + aliasing_constructor(); return boost::report_errors(); } From 8d9c4df71afb448fc1a0b6246e049628fbf760e6 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Sun, 11 Jun 2017 20:35:51 +0300 Subject: [PATCH 3/4] Add more tests --- include/boost/smart_ptr/local_shared_ptr.hpp | 14 +- test/local_sp_test.cpp | 736 +++++++++++++++++++ 2 files changed, 748 insertions(+), 2 deletions(-) diff --git a/include/boost/smart_ptr/local_shared_ptr.hpp b/include/boost/smart_ptr/local_shared_ptr.hpp index 1d8e592..21cae2e 100644 --- a/include/boost/smart_ptr/local_shared_ptr.hpp +++ b/include/boost/smart_ptr/local_shared_ptr.hpp @@ -110,18 +110,28 @@ public: template local_shared_ptr( shared_ptr const & r, typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) - : px( r.get() ), pn( new boost::detail::local_counted_impl( r ) ) + : px( r.get() ), pn( 0 ) { boost::detail::sp_assert_convertible< Y, T >(); + + if( r.use_count() != 0 ) + { + pn = new boost::detail::local_counted_impl( r ); + } } #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) template local_shared_ptr( shared_ptr && r, typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) - : px( r.get() ), pn( new boost::detail::local_counted_impl( std::move(r) ) ) + : px( r.get() ), pn( 0 ) { boost::detail::sp_assert_convertible< Y, T >(); + + if( r.use_count() != 0 ) + { + pn = new boost::detail::local_counted_impl( std::move(r) ); + } } #endif diff --git a/test/local_sp_test.cpp b/test/local_sp_test.cpp index d3388f7..fbe441d 100644 --- a/test/local_sp_test.cpp +++ b/test/local_sp_test.cpp @@ -43,6 +43,8 @@ template static void test_empty( boost::local_shared_ptr const & p ) BOOST_TEST( p.local_use_count() == 0 ); } +// default constructor + static void default_constructor() { { @@ -71,6 +73,8 @@ static void default_constructor() } } +// nullptr_constructor + static void nullptr_constructor() { #if !defined( BOOST_NO_CXX11_NULLPTR ) @@ -103,6 +107,8 @@ static void nullptr_constructor() #endif } +// pointer constructor + template static void pc0_test_() { boost::local_shared_ptr p( static_cast( 0 ) ); @@ -171,6 +177,8 @@ static void pointer_constructor() BOOST_TEST( X::instances == 0 ); } +// deleter constructor + int m = 0; void deleter2( int * p ) @@ -207,6 +215,121 @@ static void deleter_constructor() deleter2_test_(); } +// nullptr_deleter_constructor + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +void deleter3( boost::detail::sp_nullptr_t ) +{ + ++m; +} + +template static void deleter3_test_() +{ + { + m = 0; + boost::local_shared_ptr 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_(); + deleter3_test_(); + deleter3_test_(); + deleter3_test_(); + + deleter3_test_(); + deleter3_test_(); + deleter3_test_(); + deleter3_test_(); +} + +#else + +static void nullptr_deleter_constructor() +{ +} + +#endif + +// allocator constructor + +template static void allocator_test_() +{ + { + m = 0; + boost::local_shared_ptr p( &m, deleter2, std::allocator() ); + + 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_(); + allocator_test_(); + allocator_test_(); + allocator_test_(); + + allocator_test_(); + allocator_test_(); + allocator_test_(); + allocator_test_(); +} + +// nullptr_allocator_constructor + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +template static void allocator3_test_() +{ + { + m = 0; + boost::local_shared_ptr p( nullptr, deleter3, std::allocator() ); + + 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_(); + allocator3_test_(); + allocator3_test_(); + allocator3_test_(); + + allocator3_test_(); + allocator3_test_(); + allocator3_test_(); + allocator3_test_(); +} + +#else + +static void nullptr_allocator_constructor() +{ +} + +#endif + +// copy constructor + template static void empty_copy_test() { boost::local_shared_ptr p1; @@ -273,17 +396,106 @@ static void copy_constructor() empty_copy_test(); empty_copy_test(); empty_copy_test(); + BOOST_TEST( X::instances == 0 ); null_copy_test(); null_copy_test(); + BOOST_TEST( X::instances == 0 ); new_copy_test(); new_copy_test(); + BOOST_TEST( X::instances == 0 ); } +// move constructor + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +template static void empty_move_test() +{ + boost::local_shared_ptr p2(( boost::local_shared_ptr() )); + test_empty( p2 ); + + boost::local_shared_ptr p3(( boost::local_shared_ptr() )); + test_empty( p3 ); + + boost::local_shared_ptr p4(( boost::local_shared_ptr() )); + test_empty( p4 ); + + boost::local_shared_ptr p5( std::move(p3) ); + test_empty( p5 ); +} + +template static void test_nonempty_move( boost::local_shared_ptr && p1 ) +{ + U* q = p1.get(); + long k = p1.local_use_count(); + + boost::local_shared_ptr 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 static void null_move_test() +{ + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move( boost::local_shared_ptr( static_cast(0) ) ); +} + +template static void new_move_test() +{ + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); + test_nonempty_move( boost::local_shared_ptr( new T() ) ); +} + +static void move_constructor() +{ + empty_move_test(); + empty_move_test(); + empty_move_test(); + + BOOST_TEST( X::instances == 0 ); + + null_move_test(); + null_move_test(); + + BOOST_TEST( X::instances == 0 ); + + new_move_test(); + new_move_test(); + + BOOST_TEST( X::instances == 0 ); +} + +#else + +static void move_constructor() +{ +} + +#endif + +// aliasing constructor + template void test_aliasing_( boost::local_shared_ptr const & p1, U * p2 ) { boost::local_shared_ptr p3( p1, p2 ); @@ -413,6 +625,506 @@ static void aliasing_constructor() BOOST_TEST( X::instances == 0 ); } +// shared_ptr copy constructor + +template static void empty_shared_ptr_copy_test() +{ + boost::shared_ptr p1; + + boost::local_shared_ptr p2( p1 ); + test_empty( p2 ); + + boost::local_shared_ptr p3( p1 ); + test_empty( p3 ); + + boost::local_shared_ptr p4( p1 ); + test_empty( p4 ); + + boost::local_shared_ptr p5( p3 ); + test_empty( p5 ); +} + +template static void test_nonempty_shared_ptr_copy( boost::shared_ptr const & p1 ) +{ + long k = p1.use_count(); + + { + boost::local_shared_ptr 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 static void null_shared_ptr_copy_test() +{ + boost::shared_ptr p1( static_cast(0) ); + + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); +} + +template static void new_shared_ptr_copy_test() +{ + boost::shared_ptr p1( new T() ); + + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); + test_nonempty_shared_ptr_copy( p1 ); +} + +static void shared_ptr_copy_constructor() +{ + empty_shared_ptr_copy_test(); + empty_shared_ptr_copy_test(); + empty_shared_ptr_copy_test(); + + BOOST_TEST( X::instances == 0 ); + + null_shared_ptr_copy_test(); + null_shared_ptr_copy_test(); + + BOOST_TEST( X::instances == 0 ); + + new_shared_ptr_copy_test(); + new_shared_ptr_copy_test(); + + BOOST_TEST( X::instances == 0 ); +} + +// shared_ptr_move constructor + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +template static void empty_shared_ptr_move_test() +{ + boost::local_shared_ptr p2(( boost::shared_ptr() )); + test_empty( p2 ); + + boost::local_shared_ptr p3(( boost::shared_ptr() )); + test_empty( p3 ); + + boost::local_shared_ptr p4(( boost::shared_ptr() )); + test_empty( p4 ); + + boost::local_shared_ptr p5( std::move(p3) ); + test_empty( p5 ); +} + +template static void test_nonempty_shared_ptr_move( boost::shared_ptr && p1 ) +{ + U* q = p1.get(); + + boost::local_shared_ptr 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 static void null_shared_ptr_move_test() +{ + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( static_cast(0) ) ); +} + +template static void new_shared_ptr_move_test() +{ + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); + test_nonempty_shared_ptr_move( boost::shared_ptr( new T() ) ); +} + +static void shared_ptr_move_constructor() +{ + empty_shared_ptr_move_test(); + empty_shared_ptr_move_test(); + empty_shared_ptr_move_test(); + + BOOST_TEST( X::instances == 0 ); + + null_shared_ptr_move_test(); + null_shared_ptr_move_test(); + + BOOST_TEST( X::instances == 0 ); + + new_shared_ptr_move_test(); + new_shared_ptr_move_test(); + + BOOST_TEST( X::instances == 0 ); +} + +#else + +static void shared_ptr_move_constructor() +{ +} + +#endif + +// copy assignment + +template static void empty_copy_assign_test() +{ + boost::local_shared_ptr p1; + test_empty( p1 ); + + boost::local_shared_ptr p2; + + p2 = p1; + test_empty( p2 ); + + boost::local_shared_ptr p3; + + p3 = p1; + test_empty( p3 ); + + boost::local_shared_ptr p4; + + p4 = p1; + test_empty( p4 ); + + boost::local_shared_ptr p5; + + p5 = p3; + test_empty( p5 ); +} + +template static void empty_copy_assign_test_() +{ + boost::local_shared_ptr p1; + test_empty( p1 ); + + boost::local_shared_ptr p2( static_cast(0) ); + + p2 = p1; + test_empty( p2 ); + + boost::local_shared_ptr p3( static_cast(0) ); + + p3 = p1; + test_empty( p3 ); + + boost::local_shared_ptr p4( static_cast(0) ); + + p4 = p1; + test_empty( p4 ); + + boost::local_shared_ptr p5( static_cast(0) ); + + p5 = p3; + test_empty( p5 ); +} + +template static void test_nonempty_copy_assign( boost::local_shared_ptr p2, boost::local_shared_ptr 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 static void null_copy_assign_test() +{ + boost::local_shared_ptr p1( static_cast(0) ); + + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); +} + +template static void new_copy_assign_test() +{ + boost::local_shared_ptr p1( new T() ); + + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( static_cast(0) ), p1 ); + + test_nonempty_copy_assign( boost::local_shared_ptr( new T() ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( new T const() ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( new T volatile() ), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr( new T const volatile() ), p1 ); + + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); + test_nonempty_copy_assign( boost::local_shared_ptr(), p1 ); +} + +static void copy_assignment() +{ + empty_copy_assign_test(); + empty_copy_assign_test(); + empty_copy_assign_test_(); + empty_copy_assign_test(); + empty_copy_assign_test_(); + + BOOST_TEST( X::instances == 0 ); + + null_copy_assign_test(); + null_copy_assign_test(); + + BOOST_TEST( X::instances == 0 ); + + new_copy_assign_test(); + new_copy_assign_test(); + + BOOST_TEST( X::instances == 0 ); +} + +// move assignment + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +template static void empty_move_assign_test() +{ + boost::local_shared_ptr p2; + + p2 = boost::local_shared_ptr(); + test_empty( p2 ); + + boost::local_shared_ptr p3; + + p3 = boost::local_shared_ptr(); + test_empty( p3 ); + + boost::local_shared_ptr p4; + + p4 = boost::local_shared_ptr(); + test_empty( p4 ); + + boost::local_shared_ptr p5; + + p5 = std::move( p3 ); + test_empty( p5 ); +} + +template static void empty_move_assign_test_() +{ + boost::local_shared_ptr p2( static_cast(0) ); + + p2 = boost::local_shared_ptr(); + test_empty( p2 ); + + boost::local_shared_ptr p3( static_cast(0) ); + + p3 = boost::local_shared_ptr(); + test_empty( p3 ); + + boost::local_shared_ptr p4( static_cast(0) ); + + p4 = boost::local_shared_ptr(); + test_empty( p4 ); + + boost::local_shared_ptr p5( static_cast(0) ); + + p5 = std::move( p3 ); + test_empty( p5 ); +} + +template static void test_nonempty_move_assign( boost::local_shared_ptr p2, boost::local_shared_ptr && 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 static void null_move_assign_test() +{ + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( static_cast(0) ) ); + + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( static_cast(0) ) ); +} + +template static void new_move_assign_test() +{ + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( static_cast(0) ), boost::local_shared_ptr( new T() ) ); + + test_nonempty_move_assign( boost::local_shared_ptr( new T() ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( new T const() ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( new T volatile() ), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr( new T const volatile() ), boost::local_shared_ptr( new T() ) ); + + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); + test_nonempty_move_assign( boost::local_shared_ptr(), boost::local_shared_ptr( new T() ) ); +} + +static void move_assignment() +{ + empty_move_assign_test(); + empty_move_assign_test(); + empty_move_assign_test_(); + empty_move_assign_test(); + empty_move_assign_test_(); + + BOOST_TEST( X::instances == 0 ); + + null_move_assign_test(); + null_move_assign_test(); + + BOOST_TEST( X::instances == 0 ); + + new_move_assign_test(); + new_move_assign_test(); + + BOOST_TEST( X::instances == 0 ); +} + +#else + +static void move_assignment() +{ +} + +#endif + +// nullptr assignment + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +template static void test_nullptr_assign( boost::local_shared_ptr p1 ) +{ + p1 = nullptr; + + BOOST_TEST( p1.get() == 0 ); + BOOST_TEST( p1.local_use_count() == 0 ); +} + +template static void empty_nullptr_assign_test() +{ + test_nullptr_assign( boost::local_shared_ptr() ); + test_nullptr_assign( boost::local_shared_ptr() ); + test_nullptr_assign( boost::local_shared_ptr() ); + test_nullptr_assign( boost::local_shared_ptr() ); +} + +template static void null_nullptr_assign_test() +{ + test_nullptr_assign( boost::local_shared_ptr( static_cast(0) ) ); + test_nullptr_assign( boost::local_shared_ptr( static_cast(0) ) ); + test_nullptr_assign( boost::local_shared_ptr( static_cast(0) ) ); + test_nullptr_assign( boost::local_shared_ptr( static_cast(0) ) ); +} + +template static void new_nullptr_assign_test() +{ + test_nullptr_assign( boost::local_shared_ptr( new T() ) ); + test_nullptr_assign( boost::local_shared_ptr( new T const() ) ); + test_nullptr_assign( boost::local_shared_ptr( new T volatile() ) ); + test_nullptr_assign( boost::local_shared_ptr( new T const volatile() ) ); +} + +static void nullptr_assignment() +{ + empty_nullptr_assign_test(); + empty_nullptr_assign_test(); + empty_nullptr_assign_test(); + empty_nullptr_assign_test(); + + BOOST_TEST( X::instances == 0 ); + + null_nullptr_assign_test(); + null_nullptr_assign_test(); + + BOOST_TEST( X::instances == 0 ); + + new_nullptr_assign_test(); + new_nullptr_assign_test(); + + BOOST_TEST( X::instances == 0 ); +} + +#else + +static void nullptr_assignment() +{ +} + +#endif + +// main + int main() { default_constructor(); @@ -420,7 +1132,31 @@ int main() 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(); + + // pointer_reset(); + // deleter_reset(); + // allocator_reset(); + // aliasing_reset(); + + // element_access(); + // swap_test(); + // owner_before_test(); + // equal_test(); return boost::report_errors(); } From 8f2e6d04de82ba42e8191518e4ad231af433219a Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Mon, 12 Jun 2017 00:19:07 +0300 Subject: [PATCH 4/4] Add more tests --- include/boost/smart_ptr/local_shared_ptr.hpp | 10 +- test/local_sp_test.cpp | 115 ++++++++++++++++++- 2 files changed, 122 insertions(+), 3 deletions(-) diff --git a/include/boost/smart_ptr/local_shared_ptr.hpp b/include/boost/smart_ptr/local_shared_ptr.hpp index 21cae2e..0f42550 100644 --- a/include/boost/smart_ptr/local_shared_ptr.hpp +++ b/include/boost/smart_ptr/local_shared_ptr.hpp @@ -141,10 +141,16 @@ public: #if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) template< class Y, class D > - local_shared_ptr( std::unique_ptr< Y, D > && r ) - : px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr( std::move(r) ) ) ) + local_shared_ptr( std::unique_ptr< Y, D > && r, + typename boost::detail::sp_enable_if_convertible::type = boost::detail::sp_empty() ) + : px( r.get() ), pn( 0 ) { boost::detail::sp_assert_convertible< Y, T >(); + + if( px ) + { + pn = new boost::detail::local_counted_impl( shared_ptr( std::move(r) ) ); + } } #endif diff --git a/test/local_sp_test.cpp b/test/local_sp_test.cpp index fbe441d..69cbb30 100644 --- a/test/local_sp_test.cpp +++ b/test/local_sp_test.cpp @@ -790,6 +790,119 @@ static void shared_ptr_move_constructor() #endif +// unique_ptr_constructor + +#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +template static void test_null_unique_ptr( std::unique_ptr && p1 ) +{ + boost::local_shared_ptr p2( std::move( p1 ) ); + + BOOST_TEST( p1.get() == 0 ); + + BOOST_TEST( p2.get() == 0 ); + BOOST_TEST( p2.local_use_count() == 0 ); +} + +template static void null_unique_ptr_test() +{ + test_null_unique_ptr( std::unique_ptr() ); + + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + + test_null_unique_ptr( std::unique_ptr() ); + + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); + test_null_unique_ptr( std::unique_ptr() ); +} + +template static void test_nonempty_unique_ptr( std::unique_ptr && p1 ) +{ + U * q = p1.get(); + + boost::local_shared_ptr p2( std::move(p1) ); + + BOOST_TEST( p2.get() == q ); + BOOST_TEST( p2.local_use_count() == 1 ); + + BOOST_TEST( p1.get() == 0 ); +} + +template static void new_unique_ptr_test() +{ + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); + test_nonempty_unique_ptr( std::unique_ptr( new T() ) ); +} + +template static void test_deleter_unique_ptr() +{ + m = 0; + + test_nonempty_unique_ptr( std::unique_ptr( &m, deleter2 ) ); + + BOOST_TEST( m == 1 ); +} + +template static void deleter_unique_ptr_test() +{ + test_deleter_unique_ptr(); + test_deleter_unique_ptr(); + test_deleter_unique_ptr(); + test_deleter_unique_ptr(); +} + +static void unique_ptr_constructor() +{ + null_unique_ptr_test(); + null_unique_ptr_test(); + + BOOST_TEST( X::instances == 0 ); + + new_unique_ptr_test(); + new_unique_ptr_test(); + + BOOST_TEST( X::instances == 0 ); + + deleter_unique_ptr_test(); + deleter_unique_ptr_test(); +} + +#else + +static void unique_ptr_constructor() +{ +} + +#endif + // copy assignment template static void empty_copy_assign_test() @@ -1139,7 +1252,7 @@ int main() nullptr_allocator_constructor(); shared_ptr_copy_constructor(); shared_ptr_move_constructor(); - // unique_ptr_constructor(); + unique_ptr_constructor(); copy_assignment(); move_assignment();