feedc0de/boost_smart_ptr
1
0
Fork 0
forked from boostorg/smart_ptr
Code Pull Requests Activity

Add tests for the weak_ptr aliasing constructors

Browse Source
This commit is contained in:
Peter Dimov
2019-04-21 22:44:09 +03:00
parent 513cd15378
commit eb8a91cb46
3 changed files with 303 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test/Jamfile
View File

@ -306,3 +306,6 @@ run abi_test_main.cpp abi_test_nt : : : : abi_test_mt_nt ;
run abi_test_main.cpp abi_test_mt/<cxxstd>0x : : : <cxxstd>98 : abi_test_03_11 ;
run abi_test_main.cpp abi_test_mt/<cxxstd>98 : : : <cxxstd>0x : abi_test_11_03 ;
run weak_ptr_alias_test.cpp ;
run weak_ptr_alias_move_test.cpp ;

97
test/weak_ptr_alias_move_test.cpp Normal file
View File

@ -0,0 +1,97 @@
// weak_ptr_alias_move_test.cpp
//
// Copyright 2007, 2019 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/core/lightweight_test.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/config.hpp>
#include <memory>
#include <cstddef>
#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
class incomplete;
struct X
{
int v_;
explicit X( int v ): v_( v )
{
}
~X()
{
v_ = 0;
}
};
template<class P1, class P2> bool share_ownership( P1 const& p1, P2 const& p2 )
{
return !p1.owner_before( p2 ) && !p2.owner_before( p1 );
}
int main()
{
{
boost::shared_ptr<float> p( new float );
boost::weak_ptr<float> p2( p );
int m2 = 0;
boost::weak_ptr<int const volatile> p3( std::move( p2 ), &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
BOOST_TEST( p2.empty() );
}
{
boost::shared_ptr<incomplete> p;
boost::weak_ptr<incomplete> p2( p );
int m2 = 0;
boost::weak_ptr<int const volatile> p3( std::move( p2 ), &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
BOOST_TEST( p2.empty() );
}
{
boost::shared_ptr<X> p( new X( 5 ) );
boost::weak_ptr<X> p2( p );
boost::weak_ptr<int const volatile> p3( std::move( p2 ), &p2.lock()->v_ );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == &p->v_ );
BOOST_TEST( p2.empty() );
p.reset();
BOOST_TEST( p3.expired() );
}
return boost::report_errors();
}
#else // defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
int main()
{
return 0;
}
#endif

203
test/weak_ptr_alias_test.cpp Normal file
View File

@ -0,0 +1,203 @@
// weak_ptr_alias_test.cpp
//
// Copyright 2007, 2019 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/core/lightweight_test.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <cstddef>
//
class incomplete;
struct X
{
int v_;
explicit X( int v ): v_( v )
{
}
~X()
{
v_ = 0;
}
};
template<class P1, class P2> bool share_ownership( P1 const& p1, P2 const& p2 )
{
return !p1.owner_before( p2 ) && !p2.owner_before( p1 );
}
int main()
{
{
boost::shared_ptr<double> p( new double );
float m = 0;
boost::weak_ptr<float> p2( p, &m );
BOOST_TEST( p2.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p2 ) );
BOOST_TEST( p2.lock().get() == &m );
{
int m2 = 0;
boost::weak_ptr<int> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<int const> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<int volatile> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<void> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<void> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<void const volatile> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
{
int m2 = 0;
boost::weak_ptr<void const volatile> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == &m2 );
}
}
{
boost::shared_ptr<incomplete> p;
float m = 0;
boost::weak_ptr<float> p2( p, &m );
BOOST_TEST( p2.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p2 ) );
{
int m2 = 0;
boost::weak_ptr<int> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<int const> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<int volatile> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<void> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<void> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<void const volatile> p3( p, &m2 );
BOOST_TEST( p3.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
{
int m2 = 0;
boost::weak_ptr<void const volatile> p3( p2, &m2 );
BOOST_TEST( p3.use_count() == p2.use_count() );
BOOST_TEST( share_ownership( p2, p3 ) );
BOOST_TEST( p3.lock().get() == 0 );
}
}
{
boost::shared_ptr<X> p( new X( 5 ) );
boost::weak_ptr<int const> p2( p, &p->v_ );
BOOST_TEST( p2.use_count() == p.use_count() );
BOOST_TEST( share_ownership( p, p2 ) );
BOOST_TEST( p2.lock().get() == &p->v_ );
p.reset();
BOOST_TEST( p2.expired() );
}
return boost::report_errors();
}