Merge branch 'feature/local_shared_ptr' into develop

test/Jamfile.v2

@@ -230,5 +230,18 @@ import testing ;
           [ run lsp_array_n_test.cpp ]
           [ run lsp_array_cv_test.cpp ]
           [ run lsp_array_cast_test.cpp ]
+
+          [ run get_local_deleter_test.cpp ]
+          [ run get_local_deleter_test2.cpp ]
+          [ run get_local_deleter_test3.cpp ]
+          [ run get_local_deleter_array_test.cpp ]
+          [ run get_local_deleter_array_test2.cpp ]
+
+          [ run make_local_shared_test.cpp ]
+          [ run make_local_shared_esft_test.cpp ]
+          [ run allocate_local_shared_test.cpp ]
+          [ run allocate_local_shared_esft_test.cpp ]
+
+          [ run local_sp_fn_test.cpp ]
         ;
 }

test/allocate_local_shared_esft_test.cpp

@@ -0,0 +1,298 @@
+//  allocate_local_shared_esft_test.cpp
+//
+//  Copyright 2007-2009, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <memory>
+
+class X: public boost::enable_shared_from_this<X>
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+public:
+
+    static int instances;
+
+    explicit X( int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>() );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared_noinit< X >( std::allocator<void>() );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST_EQ( px, qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST_EQ( X::instances, 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    return boost::report_errors();
+}
+
+#endif

test/allocate_local_shared_test.cpp

@@ -0,0 +1,235 @@
+// allocate_local_shared_test.cpp
+//
+// Copyright 2007-2009, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <cstddef>
+
+class X
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+    void * operator new( std::size_t n )
+    {
+        // lack of this definition causes link errors on Comeau C++
+        BOOST_ERROR( "private X::new called" );
+        return ::operator new( n );
+    }
+
+    void operator delete( void * p )
+    {
+        // lack of this definition causes link errors on MSVC
+        BOOST_ERROR( "private X::delete called" );
+        ::operator delete( p );
+    }
+
+public:
+
+    static int instances;
+
+    int v;
+
+    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        boost::local_shared_ptr< int > pi = boost::allocate_local_shared< int >( std::allocator<int>() );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< int > pi = boost::allocate_local_shared_noinit< int >( std::allocator<int>() );
+
+        BOOST_TEST( pi.get() != 0 );
+    }
+
+    {
+        boost::local_shared_ptr< int > pi = boost::allocate_local_shared< int >( std::allocator<int>(), 5 );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 5 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>() );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared_noinit< X >( std::allocator<void>() );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::allocate_local_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif

test/allocate_shared_esft_test.cpp

@@ -62,6 +62,28 @@ int main()
 
     BOOST_TEST( X::instances == 0 );
 
+    {
+        boost::shared_ptr< X > px = boost::allocate_shared_noinit< X >( std::allocator<void>() );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
     {
         boost::shared_ptr< X > px = boost::allocate_shared< X >( std::allocator<void>(), 1 );
         BOOST_TEST( X::instances == 1 );

test/allocate_shared_test.cpp

@@ -61,6 +61,12 @@ int main()
         BOOST_TEST( *pi == 0 );
     }
 
+    {
+        boost::shared_ptr< int > pi = boost::allocate_shared_noinit< int >( std::allocator<int>() );
+
+        BOOST_TEST( pi.get() != 0 );
+    }
+
     {
         boost::shared_ptr< int > pi = boost::allocate_shared< int >( std::allocator<int>(), 5 );
 
@@ -83,6 +89,19 @@ int main()
         BOOST_TEST( X::instances == 0 );
     }
 
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared_noinit< X >( std::allocator<void>() );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
     {
         boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1 );
         boost::weak_ptr<X> wp( pi );

test/get_local_deleter_array_test.cpp

@@ -0,0 +1,151 @@
+//
+// get_local_deleter_array_test2.cpp
+//
+// Copyright 2002, 2011, 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/core/lightweight_test.hpp>
+
+struct deleter
+{
+    int data;
+
+    deleter(): data(0)
+    {
+    }
+
+    void operator()(void *)
+    {
+        BOOST_TEST(data == 17041);
+    }
+};
+
+struct deleter2
+{
+};
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::local_shared_ptr<X[]> p;
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::local_shared_ptr<X[1]> p;
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::local_shared_ptr<X[]> p(new X[1]);
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::local_shared_ptr<X[1]> p(new X[1]);
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        X x[1];
+        boost::local_shared_ptr<X[]> p(x, deleter());
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+
+        deleter * q = boost::get_deleter<deleter>(p);
+
+        BOOST_TEST(q != 0);
+        BOOST_TEST(q->data == 0);
+
+        q->data = 17041;
+
+        deleter const * r = boost::get_deleter<deleter const>(p);
+
+        BOOST_TEST(r == q);
+        BOOST_TEST(r->data == 17041);
+    }
+
+    {
+        X x[1];
+        boost::local_shared_ptr<X[1]> p(x, deleter());
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+
+        deleter * q = boost::get_deleter<deleter>(p);
+
+        BOOST_TEST(q != 0);
+        BOOST_TEST(q->data == 0);
+
+        q->data = 17041;
+
+        deleter const * r = boost::get_deleter<deleter const>(p);
+
+        BOOST_TEST(r == q);
+        BOOST_TEST(r->data == 17041);
+    }
+
+    return boost::report_errors();
+}

test/get_local_deleter_array_test2.cpp

@@ -0,0 +1,74 @@
+//
+// get_local_deleter_test2.cpp
+//
+// Copyright 2002, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct deleter
+{
+};
+
+struct deleter2;
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::local_shared_ptr<X[]> p = boost::make_local_shared<X[]>( 1 );
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::local_shared_ptr<X[1]> p = boost::make_local_shared<X[1]>();
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    return boost::report_errors();
+}
+
+struct deleter2
+{
+};
+
+#endif

test/get_local_deleter_test.cpp

@@ -0,0 +1,95 @@
+//
+// get_local_deleter_test.cpp
+//
+// Copyright 2002, 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/core/lightweight_test.hpp>
+
+struct deleter
+{
+    int data;
+
+    deleter(): data(0)
+    {
+    }
+
+    void operator()(void *)
+    {
+        BOOST_TEST(data == 17041);
+    }
+};
+
+struct deleter2
+{
+};
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::local_shared_ptr<X> p;
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::local_shared_ptr<X> p(new X);
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        X x;
+        boost::local_shared_ptr<X> p(&x, deleter());
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+
+        deleter * q = boost::get_deleter<deleter>(p);
+
+        BOOST_TEST(q != 0);
+        BOOST_TEST(q->data == 0);
+
+        q->data = 17041;
+
+        deleter const * r = boost::get_deleter<deleter const>(p);
+
+        BOOST_TEST(r == q);
+        BOOST_TEST(r->data == 17041);
+    }
+
+    return boost::report_errors();
+}

test/get_local_deleter_test2.cpp

@@ -0,0 +1,43 @@
+//
+// get_local_deleter_test2.cpp
+//
+// 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 <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct deleter;
+
+struct X
+{
+};
+
+static void test_lsp_get_deleter( boost::local_shared_ptr<X> const & p )
+{
+    BOOST_TEST( boost::get_deleter<deleter>( p ) != 0 );
+}
+
+static void test_sp_get_deleter( boost::shared_ptr<X> const & p )
+{
+    BOOST_TEST( boost::get_deleter<deleter>( p ) != 0 );
+}
+
+struct deleter
+{
+    void operator()( X const * p ) { delete p; }
+};
+
+int main()
+{
+    boost::local_shared_ptr<X> p( new X, deleter() );
+
+    test_lsp_get_deleter( p );
+    test_sp_get_deleter( p );
+
+    return boost::report_errors();
+}

test/get_local_deleter_test3.cpp

@@ -0,0 +1,59 @@
+//
+// get_local_deleter_test3.cpp
+//
+// Copyright 2002, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct deleter
+{
+};
+
+struct deleter2;
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::local_shared_ptr<X> p = boost::make_local_shared<X>();
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    return boost::report_errors();
+}
+
+struct deleter2
+{
+};
+
+#endif

test/local_sp_fn_test.cpp

@@ -0,0 +1,43 @@
+//
+// local_sp_fn_test.cpp
+//
+// 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 <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+static void f()
+{
+}
+
+struct null_deleter
+{
+    template<class Y> void operator()( Y* ) {}
+};
+
+int main()
+{
+    boost::local_shared_ptr<void()> pf( f, null_deleter() );
+
+    BOOST_TEST( pf.get() == f );
+    BOOST_TEST_EQ( pf.local_use_count(), 1 );
+    BOOST_TEST( boost::get_deleter<null_deleter>( pf ) != 0 );
+
+    boost::weak_ptr<void()> wp( pf );
+
+    BOOST_TEST( wp.lock().get() == f );
+    BOOST_TEST_EQ( wp.use_count(), 1 );
+
+    pf.reset();
+
+    BOOST_TEST( wp.lock().get() == 0 );
+    BOOST_TEST_EQ( wp.use_count(), 0 );
+
+    return boost::report_errors();
+}

test/local_sp_test.cpp

@@ -9,6 +9,8 @@
 //
 
 #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
@@ -1679,6 +1681,809 @@ 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()
@@ -1702,18 +2507,25 @@ int main()
     nullptr_assignment();
     shared_ptr_copy_assignment();
     shared_ptr_move_assignment();
-    // unique_ptr_assignment();
+    unique_ptr_assignment();
 
     default_reset();
-    // pointer_reset();
-    // deleter_reset();
-    // allocator_reset();
-    // aliasing_reset();
+    pointer_reset();
+    deleter_reset();
+    allocator_reset();
+    aliasing_reset();
 
-    // element_access();
+    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();
 }

test/make_local_shared_esft_test.cpp

@@ -0,0 +1,297 @@
+//  make_local_shared_esft_test.cpp
+//
+//  Copyright 2007-2009, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+
+class X: public boost::enable_shared_from_this<X>
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+public:
+
+    static int instances;
+
+    explicit X( int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0, int = 0 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >();
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared_noinit< X >();
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4, 5 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > px = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    return boost::report_errors();
+}
+
+#endif

test/make_local_shared_test.cpp

@@ -0,0 +1,235 @@
+// make_local_shared_test.cpp
+//
+// Copyright 2007-2009, 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/config.hpp>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+
+int main()
+{
+}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <cstddef>
+
+class X
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+    void * operator new( std::size_t n )
+    {
+        // lack of this definition causes link errors on Comeau C++
+        BOOST_ERROR( "private X::new called" );
+        return ::operator new( n );
+    }
+
+    void operator delete( void * p )
+    {
+        // lack of this definition causes link errors on MSVC
+        BOOST_ERROR( "private X::delete called" );
+        ::operator delete( p );
+    }
+
+public:
+
+    static int instances;
+
+    int v;
+
+    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        boost::local_shared_ptr< int > pi = boost::make_local_shared< int >();
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< int > pi = boost::make_local_shared_noinit< int >();
+
+        BOOST_TEST( pi.get() != 0 );
+    }
+
+    {
+        boost::local_shared_ptr< int > pi = boost::make_local_shared< int >( 5 );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 5 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >();
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared_noinit< X >();
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif

test/make_shared_esft_test.cpp

@@ -61,6 +61,28 @@ int main()
 
     BOOST_TEST( X::instances == 0 );
 
+    {
+        boost::shared_ptr< X > px = boost::make_shared_noinit< X >();
+        BOOST_TEST( X::instances == 1 );
+
+        try
+        {
+            boost::shared_ptr< X > qx = px->shared_from_this();
+
+            BOOST_TEST( px == qx );
+            BOOST_TEST( !( px < qx ) && !( qx < px ) );
+
+            px.reset();
+            BOOST_TEST( X::instances == 1 );
+        }
+        catch( boost::bad_weak_ptr const& )
+        {
+            BOOST_ERROR( "px->shared_from_this() failed" );
+        }
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
     {
         boost::shared_ptr< X > px = boost::make_shared< X >( 1 );
         BOOST_TEST( X::instances == 1 );

test/make_shared_test.cpp

@@ -61,6 +61,12 @@ int main()
         BOOST_TEST( *pi == 0 );
     }
 
+    {
+        boost::shared_ptr< int > pi = boost::make_shared_noinit< int >();
+
+        BOOST_TEST( pi.get() != 0 );
+    }
+
     {
         boost::shared_ptr< int > pi = boost::make_shared< int >( 5 );
 
@@ -83,6 +89,19 @@ int main()
         BOOST_TEST( X::instances == 0 );
     }
 
+    {
+        boost::shared_ptr< X > pi = boost::make_shared_noinit< X >();
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
     {
         boost::shared_ptr< X > pi = boost::make_shared< X >( 1 );
         boost::weak_ptr<X> wp( pi );