generic-library/boost
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
boost/libs/smart_ptr/test/shared_ptr_test.cpp
Edouard DUPIN d0115b733d [DEV] add v1.76.0
2021-10-05 21:37:46 +02:00

3401 lines
71 KiB
C++
Raw Permalink Blame History

#include <boost/config.hpp>
#if defined(BOOST_MSVC)
#pragma warning(disable: 4786) // identifier truncated in debug info
#pragma warning(disable: 4710) // function not inlined
#pragma warning(disable: 4711) // function selected for automatic inline expansion
#pragma warning(disable: 4514) // unreferenced inline removed
#pragma warning(disable: 4355) // 'this' : used in base member initializer list
#if (BOOST_MSVC >= 1310)
#pragma warning(disable: 4675) // resolved overload found with Koenig lookup
#endif
#endif
#if defined(__GNUC__) && __GNUC__ > 4
# pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
#endif
//
// shared_ptr_test.cpp
//
// Copyright (c) 2002, 2003 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/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <map>
#include <vector>
//
namespace n_element_type
{
void f(int &)
{
}
void test()
{
typedef boost::shared_ptr<int>::element_type T;
T t;
f(t);
}
} // namespace n_element_type
namespace n_constructors
{
class incomplete;
void default_constructor()
{
{
boost::shared_ptr<int> pi;
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 0);
}
{
boost::shared_ptr<void> pv;
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 0);
}
{
boost::shared_ptr<incomplete> px;
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 0);
}
}
struct A
{
int dummy;
};
struct X
{
static long instances;
X()
{
++instances;
}
~X()
{
--instances;
}
private:
X(X const &);
X & operator= (X const &);
};
long X::instances = 0;
// virtual inheritance stresses the implementation
struct Y: public A, public virtual X
{
static long instances;
Y()
{
++instances;
}
~Y()
{
--instances;
}
private:
Y(Y const &);
Y & operator= (Y const &);
};
long Y::instances = 0;
template<class T> void pc0_test(T * p)
{
BOOST_TEST(p == 0);
boost::shared_ptr<T> pt(p);
BOOST_TEST(pt? false: true);
BOOST_TEST(!pt);
BOOST_TEST(pt.get() == 0);
BOOST_TEST(pt.use_count() == 1);
BOOST_TEST(pt.unique());
}
void pointer_constructor()
{
pc0_test(static_cast<int*>(0));
#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
pc0_test(static_cast<int const*>(0));
pc0_test(static_cast<int volatile*>(0));
pc0_test(static_cast<int const volatile*>(0));
#endif
{
boost::shared_ptr<int const> pi(static_cast<int*>(0));
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
{
boost::shared_ptr<int volatile> pi(static_cast<int*>(0));
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
{
boost::shared_ptr<void> pv(static_cast<int*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
boost::shared_ptr<void const> pv(static_cast<int*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
pc0_test(static_cast<X*>(0));
pc0_test(static_cast<X const*>(0));
pc0_test(static_cast<X volatile*>(0));
pc0_test(static_cast<X const volatile*>(0));
{
boost::shared_ptr<X const> px(static_cast<X*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
}
{
boost::shared_ptr<X> px(static_cast<Y*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
}
{
boost::shared_ptr<X const> px(static_cast<Y*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
}
{
boost::shared_ptr<void> pv(static_cast<X*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
boost::shared_ptr<void const> pv(static_cast<X*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
int * p = new int(7);
boost::shared_ptr<int> pi(p);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == p);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(*pi == 7);
}
{
int * p = new int(7);
boost::shared_ptr<int const> pi(p);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == p);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(*pi == 7);
}
{
int * p = new int(7);
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == p);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
int * p = new int(7);
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == p);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
BOOST_TEST(X::instances == 0);
{
X * p = new X;
boost::shared_ptr<X> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
}
BOOST_TEST(X::instances == 0);
{
X * p = new X;
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
}
BOOST_TEST(X::instances == 0);
{
X * p = new X;
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == p);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
}
BOOST_TEST(X::instances == 0);
{
X * p = new X;
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == p);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
{
Y * p = new Y;
boost::shared_ptr<X> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
{
Y * p = new Y;
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
int m = 0;
void deleter(int * p)
{
BOOST_TEST(p == 0);
}
void deleter2(int * p)
{
BOOST_TEST(p == &m);
++*p;
}
struct deleter3
{
void operator()(incomplete * p)
{
BOOST_TEST(p == 0);
}
};
// Borland C++ 5.5.1 fails on static_cast<incomplete*>(0)
incomplete * p0 = 0;
void deleter_constructor()
{
{
boost::shared_ptr<int> pi(static_cast<int*>(0), deleter);
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
{
boost::shared_ptr<void> pv(static_cast<int*>(0), &deleter);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
boost::shared_ptr<void const> pv(static_cast<int*>(0), deleter);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
boost::shared_ptr<incomplete> px(p0, deleter3());
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
}
{
boost::shared_ptr<void> pv(p0, deleter3());
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
{
boost::shared_ptr<void const> pv(p0, deleter3());
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
BOOST_TEST(m == 0);
{
boost::shared_ptr<int> pi(&m, deleter2);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == &m);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
BOOST_TEST(m == 1);
{
boost::shared_ptr<int const> pi(&m, &deleter2);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == &m);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
BOOST_TEST(m == 2);
{
boost::shared_ptr<void> pv(&m, deleter2);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == &m);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
BOOST_TEST(m == 3);
{
boost::shared_ptr<void const> pv(&m, &deleter2);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == &m);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
}
BOOST_TEST(m == 4);
}
void copy_constructor()
{
{
boost::shared_ptr<int> pi;
boost::shared_ptr<int> pi2(pi);
BOOST_TEST(pi2 == pi);
BOOST_TEST(pi2? false: true);
BOOST_TEST(!pi2);
BOOST_TEST(pi2.get() == 0);
BOOST_TEST(pi2.use_count() == pi.use_count());
boost::shared_ptr<void> pi3(pi);
BOOST_TEST(pi3 == pi);
BOOST_TEST(pi3? false: true);
BOOST_TEST(!pi3);
BOOST_TEST(pi3.get() == 0);
BOOST_TEST(pi3.use_count() == pi.use_count());
boost::shared_ptr<void> pi4(pi3);
BOOST_TEST(pi4 == pi3);
BOOST_TEST(pi4? false: true);
BOOST_TEST(!pi4);
BOOST_TEST(pi4.get() == 0);
BOOST_TEST(pi4.use_count() == pi3.use_count());
}
{
boost::shared_ptr<void> pv;
boost::shared_ptr<void> pv2(pv);
BOOST_TEST(pv2 == pv);
BOOST_TEST(pv2? false: true);
BOOST_TEST(!pv2);
BOOST_TEST(pv2.get() == 0);
BOOST_TEST(pv2.use_count() == pv.use_count());
}
{
boost::shared_ptr<incomplete> px;
boost::shared_ptr<incomplete> px2(px);
BOOST_TEST(px2 == px);
BOOST_TEST(px2? false: true);
BOOST_TEST(!px2);
BOOST_TEST(px2.get() == 0);
BOOST_TEST(px2.use_count() == px.use_count());
boost::shared_ptr<void> px3(px);
BOOST_TEST(px3 == px);
BOOST_TEST(px3? false: true);
BOOST_TEST(!px3);
BOOST_TEST(px3.get() == 0);
BOOST_TEST(px3.use_count() == px.use_count());
}
{
boost::shared_ptr<int> pi(static_cast<int*>(0));
boost::shared_ptr<int> pi2(pi);
BOOST_TEST(pi2 == pi);
BOOST_TEST(pi2? false: true);
BOOST_TEST(!pi2);
BOOST_TEST(pi2.get() == 0);
BOOST_TEST(pi2.use_count() == 2);
BOOST_TEST(!pi2.unique());
BOOST_TEST(pi2.use_count() == pi.use_count());
BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
boost::shared_ptr<void> pi3(pi);
BOOST_TEST(pi3 == pi);
BOOST_TEST(pi3? false: true);
BOOST_TEST(!pi3);
BOOST_TEST(pi3.get() == 0);
BOOST_TEST(pi3.use_count() == 3);
BOOST_TEST(!pi3.unique());
BOOST_TEST(pi3.use_count() == pi.use_count());
BOOST_TEST(!(pi < pi3 || pi3 < pi)); // shared ownership test
boost::shared_ptr<void> pi4(pi2);
BOOST_TEST(pi4 == pi2);
BOOST_TEST(pi4? false: true);
BOOST_TEST(!pi4);
BOOST_TEST(pi4.get() == 0);
BOOST_TEST(pi4.use_count() == 4);
BOOST_TEST(!pi4.unique());
BOOST_TEST(pi4.use_count() == pi2.use_count());
BOOST_TEST(!(pi2 < pi4 || pi4 < pi2)); // shared ownership test
BOOST_TEST(pi3.use_count() == pi4.use_count());
BOOST_TEST(!(pi3 < pi4 || pi4 < pi3)); // shared ownership test
}
{
boost::shared_ptr<X> px(static_cast<X*>(0));
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2 == px);
BOOST_TEST(px2? false: true);
BOOST_TEST(!px2);
BOOST_TEST(px2.get() == 0);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(!px2.unique());
BOOST_TEST(px2.use_count() == px.use_count());
BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
boost::shared_ptr<void> px3(px);
BOOST_TEST(px3 == px);
BOOST_TEST(px3? false: true);
BOOST_TEST(!px3);
BOOST_TEST(px3.get() == 0);
BOOST_TEST(px3.use_count() == 3);
BOOST_TEST(!px3.unique());
BOOST_TEST(px3.use_count() == px.use_count());
BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
boost::shared_ptr<void> px4(px2);
BOOST_TEST(px4 == px2);
BOOST_TEST(px4? false: true);
BOOST_TEST(!px4);
BOOST_TEST(px4.get() == 0);
BOOST_TEST(px4.use_count() == 4);
BOOST_TEST(!px4.unique());
BOOST_TEST(px4.use_count() == px2.use_count());
BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
BOOST_TEST(px3.use_count() == px4.use_count());
BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
}
{
int * p = new int(7);
boost::shared_ptr<int> pi(p);
boost::shared_ptr<int> pi2(pi);
BOOST_TEST(pi2 == pi);
BOOST_TEST(pi2? true: false);
BOOST_TEST(!!pi2);
BOOST_TEST(pi2.get() == p);
BOOST_TEST(pi2.use_count() == 2);
BOOST_TEST(!pi2.unique());
BOOST_TEST(*pi2 == 7);
BOOST_TEST(pi2.use_count() == pi.use_count());
BOOST_TEST(!(pi < pi2 || pi2 < pi)); // shared ownership test
}
{
int * p = new int(7);
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv.get() == p);
boost::shared_ptr<void> pv2(pv);
BOOST_TEST(pv2 == pv);
BOOST_TEST(pv2? true: false);
BOOST_TEST(!!pv2);
BOOST_TEST(pv2.get() == p);
BOOST_TEST(pv2.use_count() == 2);
BOOST_TEST(!pv2.unique());
BOOST_TEST(pv2.use_count() == pv.use_count());
BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
}
BOOST_TEST(X::instances == 0);
{
X * p = new X;
boost::shared_ptr<X> px(p);
BOOST_TEST(px.get() == p);
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2 == px);
BOOST_TEST(px2? true: false);
BOOST_TEST(!!px2);
BOOST_TEST(px2.get() == p);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(!px2.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(px2.use_count() == px.use_count());
BOOST_TEST(!(px < px2 || px2 < px)); // shared ownership test
boost::shared_ptr<void> px3(px);
BOOST_TEST(px3 == px);
BOOST_TEST(px3? true: false);
BOOST_TEST(!!px3);
BOOST_TEST(px3.get() == p);
BOOST_TEST(px3.use_count() == 3);
BOOST_TEST(!px3.unique());
BOOST_TEST(px3.use_count() == px.use_count());
BOOST_TEST(!(px < px3 || px3 < px)); // shared ownership test
boost::shared_ptr<void> px4(px2);
BOOST_TEST(px4 == px2);
BOOST_TEST(px4? true: false);
BOOST_TEST(!!px4);
BOOST_TEST(px4.get() == p);
BOOST_TEST(px4.use_count() == 4);
BOOST_TEST(!px4.unique());
BOOST_TEST(px4.use_count() == px2.use_count());
BOOST_TEST(!(px2 < px4 || px4 < px2)); // shared ownership test
BOOST_TEST(px3.use_count() == px4.use_count());
BOOST_TEST(!(px3 < px4 || px4 < px3)); // shared ownership test
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
{
Y * p = new Y;
boost::shared_ptr<Y> py(p);
BOOST_TEST(py.get() == p);
boost::shared_ptr<X> px(py);
BOOST_TEST(px == py);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(!px.unique());
BOOST_TEST(px.use_count() == py.use_count());
BOOST_TEST(!(px < py || py < px)); // shared ownership test
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
boost::shared_ptr<void const> pv(px);
BOOST_TEST(pv == px);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == px.get());
BOOST_TEST(pv.use_count() == 3);
BOOST_TEST(!pv.unique());
BOOST_TEST(pv.use_count() == px.use_count());
BOOST_TEST(!(px < pv || pv < px)); // shared ownership test
boost::shared_ptr<void const> pv2(py);
BOOST_TEST(pv2 == py);
BOOST_TEST(pv2? true: false);
BOOST_TEST(!!pv2);
BOOST_TEST(pv2.get() == py.get());
BOOST_TEST(pv2.use_count() == 4);
BOOST_TEST(!pv2.unique());
BOOST_TEST(pv2.use_count() == py.use_count());
BOOST_TEST(!(py < pv2 || pv2 < py)); // shared ownership test
BOOST_TEST(pv.use_count() == pv2.use_count());
BOOST_TEST(!(pv < pv2 || pv2 < pv)); // shared ownership test
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
void weak_ptr_constructor()
{
{
boost::weak_ptr<Y> wp;
BOOST_TEST(wp.use_count() == 0);
try
{
boost::shared_ptr<Y> p2(wp);
BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
}
catch(boost::bad_weak_ptr const&)
{
}
try
{
boost::shared_ptr<X> p3(wp);
BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
}
catch(boost::bad_weak_ptr const&)
{
}
}
{
boost::shared_ptr<Y> p;
boost::weak_ptr<Y> wp(p);
if(wp.use_count() != 0) // 0 allowed but not required
{
boost::shared_ptr<Y> p2(wp);
BOOST_TEST(p2.use_count() == wp.use_count());
BOOST_TEST(p2.get() == 0);
boost::shared_ptr<X> p3(wp);
BOOST_TEST(p3.use_count() == wp.use_count());
BOOST_TEST(p3.get() == 0);
}
}
{
boost::shared_ptr<Y> p(new Y);
boost::weak_ptr<Y> wp(p);
{
boost::shared_ptr<Y> p2(wp);
BOOST_TEST(p2? true: false);
BOOST_TEST(!!p2);
BOOST_TEST(p2.get() == p.get());
BOOST_TEST(p2.use_count() == 2);
BOOST_TEST(!p2.unique());
BOOST_TEST(p2.use_count() == wp.use_count());
BOOST_TEST(p.use_count() == p2.use_count());
BOOST_TEST(!(p < p2 || p2 < p)); // shared ownership test
boost::shared_ptr<X> p3(wp);
BOOST_TEST(p3? true: false);
BOOST_TEST(!!p3);
BOOST_TEST(p3.get() == p.get());
BOOST_TEST(p3.use_count() == 3);
BOOST_TEST(!p3.unique());
BOOST_TEST(p3.use_count() == wp.use_count());
BOOST_TEST(p.use_count() == p3.use_count());
}
p.reset();
BOOST_TEST(wp.use_count() == 0);
try
{
boost::shared_ptr<Y> p2(wp);
BOOST_ERROR("shared_ptr<Y> p2(wp) failed to throw");
}
catch(boost::bad_weak_ptr const&)
{
}
try
{
boost::shared_ptr<X> p3(wp);
BOOST_ERROR("shared_ptr<X> p3(wp) failed to throw");
}
catch(boost::bad_weak_ptr const&)
{
}
}
}
#if defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB < 306)
# define BOOST_OLD_AUTO_PTR
#endif
void auto_ptr_constructor()
{
#if !defined( BOOST_NO_AUTO_PTR )
{
std::auto_ptr<int> p;
boost::shared_ptr<int> pi(p);
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<int> p;
boost::shared_ptr<int const> pi(p);
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<int> p;
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<int> p;
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<X> p;
boost::shared_ptr<X> px(p);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<X> p;
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<Y> p;
boost::shared_ptr<X> px(p);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<Y> p;
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<Y> p;
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<Y> p;
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(p.get() == 0);
}
{
std::auto_ptr<int> p(new int(7));
int * q = p.get();
boost::shared_ptr<int> pi(p);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == q);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(*pi == 7);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
{
std::auto_ptr<int> p(new int(7));
int * q = p.get();
boost::shared_ptr<int const> pi(p);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == q);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
BOOST_TEST(*pi == 7);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
{
std::auto_ptr<int> p(new int(7));
int * q = p.get();
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == q);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
{
std::auto_ptr<int> p(new int(7));
int * q = p.get();
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == q);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
{
std::auto_ptr<X> p(new X);
X * q = p.get();
boost::shared_ptr<X> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == q);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
{
std::auto_ptr<X> p(new X);
X * q = p.get();
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == q);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
{
std::auto_ptr<X> p(new X);
X * q = p.get();
boost::shared_ptr<void> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == q);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
{
std::auto_ptr<X> p(new X);
X * q = p.get();
boost::shared_ptr<void const> pv(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == q);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
{
std::auto_ptr<Y> p(new Y);
Y * q = p.get();
boost::shared_ptr<X> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == q);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
{
std::auto_ptr<Y> p(new Y);
Y * q = p.get();
boost::shared_ptr<X const> px(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == q);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p.get() == 0);
#endif
}
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
#endif // #if !defined( BOOST_NO_AUTO_PTR )
}
void test()
{
default_constructor();
pointer_constructor();
deleter_constructor();
copy_constructor();
weak_ptr_constructor();
auto_ptr_constructor();
}
} // namespace n_constructors
namespace n_assignment
{
class incomplete;
struct A
{
int dummy;
};
struct X
{
static long instances;
X()
{
++instances;
}
~X()
{
--instances;
}
private:
X(X const &);
X & operator= (X const &);
};
long X::instances = 0;
struct Y: public A, public virtual X
{
static long instances;
Y()
{
++instances;
}
~Y()
{
--instances;
}
private:
Y(Y const &);
Y & operator= (Y const &);
};
long Y::instances = 0;
void copy_assignment()
{
{
boost::shared_ptr<incomplete> p1;
p1 = p1;
BOOST_TEST(p1 == p1);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<incomplete> p2;
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<incomplete> p3(p1);
p1 = p3;
BOOST_TEST(p1 == p3);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
}
{
boost::shared_ptr<void> p1;
p1 = p1;
BOOST_TEST(p1 == p1);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<void> p2;
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<void> p3(p1);
p1 = p3;
BOOST_TEST(p1 == p3);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<void> p4(new int);
BOOST_TEST(p4.use_count() == 1);
p1 = p4;
BOOST_TEST(p1 == p4);
BOOST_TEST(!(p1 < p4 || p4 < p1));
BOOST_TEST(p1.use_count() == 2);
BOOST_TEST(p4.use_count() == 2);
p1 = p3;
BOOST_TEST(p1 == p3);
BOOST_TEST(p4.use_count() == 1);
}
{
boost::shared_ptr<X> p1;
p1 = p1;
BOOST_TEST(p1 == p1);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<X> p2;
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<X> p3(p1);
p1 = p3;
BOOST_TEST(p1 == p3);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(X::instances == 0);
boost::shared_ptr<X> p4(new X);
BOOST_TEST(X::instances == 1);
p1 = p4;
BOOST_TEST(X::instances == 1);
BOOST_TEST(p1 == p4);
BOOST_TEST(!(p1 < p4 || p4 < p1));
BOOST_TEST(p1.use_count() == 2);
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(X::instances == 1);
p4 = p3;
BOOST_TEST(p4 == p3);
BOOST_TEST(X::instances == 0);
}
}
void conversion_assignment()
{
{
boost::shared_ptr<void> p1;
boost::shared_ptr<incomplete> p2;
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
boost::shared_ptr<int> p4(new int);
BOOST_TEST(p4.use_count() == 1);
boost::shared_ptr<void> p5(p4);
BOOST_TEST(p4.use_count() == 2);
p1 = p4;
BOOST_TEST(p1 == p4);
BOOST_TEST(!(p1 < p5 || p5 < p1));
BOOST_TEST(p1.use_count() == 3);
BOOST_TEST(p4.use_count() == 3);
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p4.use_count() == 2);
}
{
boost::shared_ptr<X> p1;
boost::shared_ptr<Y> p2;
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
boost::shared_ptr<Y> p4(new Y);
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
BOOST_TEST(p4.use_count() == 1);
boost::shared_ptr<X> p5(p4);
BOOST_TEST(p4.use_count() == 2);
p1 = p4;
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
BOOST_TEST(p1 == p4);
BOOST_TEST(!(p1 < p5 || p5 < p1));
BOOST_TEST(p1.use_count() == 3);
BOOST_TEST(p4.use_count() == 3);
p1 = p2;
BOOST_TEST(p1 == p2);
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
BOOST_TEST(p4.use_count() == 2);
p4 = p2;
p5 = p2;
BOOST_TEST(p4 == p2);
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
}
void auto_ptr_assignment()
{
#if !defined( BOOST_NO_AUTO_PTR )
{
boost::shared_ptr<int> p1;
std::auto_ptr<int> p2;
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
int * p = new int;
std::auto_ptr<int> p3(p);
p1 = p3;
BOOST_TEST(p1.get() == p);
BOOST_TEST(p1.use_count() == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p3.get() == 0);
#endif
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
}
{
boost::shared_ptr<void> p1;
std::auto_ptr<int> p2;
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
int * p = new int;
std::auto_ptr<int> p3(p);
p1 = p3;
BOOST_TEST(p1.get() == p);
BOOST_TEST(p1.use_count() == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p3.get() == 0);
#endif
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
}
{
boost::shared_ptr<X> p1;
std::auto_ptr<Y> p2;
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
Y * p = new Y;
std::auto_ptr<Y> p3(p);
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
p1 = p3;
BOOST_TEST(p1.get() == p);
BOOST_TEST(p1.use_count() == 1);
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
#if !defined(BOOST_OLD_AUTO_PTR)
BOOST_TEST(p3.get() == 0);
#endif
p1 = p2;
BOOST_TEST(p1? false: true);
BOOST_TEST(!p1);
BOOST_TEST(p1.get() == 0);
BOOST_TEST(p1.use_count() == 1);
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
#endif // #if !defined( BOOST_NO_AUTO_PTR )
}
void test()
{
copy_assignment();
conversion_assignment();
auto_ptr_assignment();
}
} // namespace n_assignment
namespace n_reset
{
class incomplete;
incomplete * p0 = 0;
void deleter(incomplete *)
{
}
struct X
{
static long instances;
X()
{
++instances;
}
~X()
{
--instances;
}
private:
X(X const &);
X & operator= (X const &);
};
long X::instances = 0;
void plain_reset()
{
{
boost::shared_ptr<int> pi;
pi.reset();
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 0);
}
{
boost::shared_ptr<int> pi(static_cast<int*>(0));
pi.reset();
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 0);
}
{
boost::shared_ptr<int> pi(new int);
pi.reset();
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 0);
}
{
boost::shared_ptr<incomplete> px;
px.reset();
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 0);
}
{
boost::shared_ptr<incomplete> px(p0, deleter);
px.reset();
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 0);
}
{
boost::shared_ptr<X> px;
px.reset();
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 0);
}
{
BOOST_TEST(X::instances == 0);
boost::shared_ptr<X> px(new X);
BOOST_TEST(X::instances == 1);
px.reset();
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 0);
BOOST_TEST(X::instances == 0);
}
{
boost::shared_ptr<void> pv;
pv.reset();
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 0);
}
{
BOOST_TEST(X::instances == 0);
boost::shared_ptr<void> pv(new X);
BOOST_TEST(X::instances == 1);
pv.reset();
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 0);
BOOST_TEST(X::instances == 0);
}
}
struct A
{
int dummy;
};
struct Y: public A, public virtual X
{
static long instances;
Y()
{
++instances;
}
~Y()
{
--instances;
}
private:
Y(Y const &);
Y & operator= (Y const &);
};
long Y::instances = 0;
void pointer_reset()
{
{
boost::shared_ptr<int> pi;
pi.reset(static_cast<int*>(0));
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
int * p = new int;
pi.reset(p);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == p);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
pi.reset(static_cast<int*>(0));
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
}
{
boost::shared_ptr<X> px;
px.reset(static_cast<X*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 0);
X * p = new X;
px.reset(p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
px.reset(static_cast<X*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
Y * q = new Y;
px.reset(q);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == q);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
px.reset(static_cast<Y*>(0));
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
{
boost::shared_ptr<void> pv;
pv.reset(static_cast<X*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 0);
X * p = new X;
pv.reset(p);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == p);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
pv.reset(static_cast<X*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
Y * q = new Y;
pv.reset(q);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == q);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 1);
BOOST_TEST(Y::instances == 1);
pv.reset(static_cast<Y*>(0));
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
BOOST_TEST(X::instances == 0);
BOOST_TEST(Y::instances == 0);
}
}
void * deleted = 0;
void deleter2(void * p)
{
deleted = p;
}
void deleter_reset()
{
{
boost::shared_ptr<int> pi;
pi.reset(static_cast<int*>(0), deleter2);
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
deleted = &pi;
int m = 0;
pi.reset(&m, deleter2);
BOOST_TEST(deleted == 0);
BOOST_TEST(pi? true: false);
BOOST_TEST(!!pi);
BOOST_TEST(pi.get() == &m);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
pi.reset(static_cast<int*>(0), deleter2);
BOOST_TEST(deleted == &m);
BOOST_TEST(pi? false: true);
BOOST_TEST(!pi);
BOOST_TEST(pi.get() == 0);
BOOST_TEST(pi.use_count() == 1);
BOOST_TEST(pi.unique());
pi.reset();
BOOST_TEST(deleted == 0);
}
{
boost::shared_ptr<X> px;
px.reset(static_cast<X*>(0), deleter2);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
deleted = &px;
X x;
px.reset(&x, deleter2);
BOOST_TEST(deleted == 0);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == &x);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
px.reset(static_cast<X*>(0), deleter2);
BOOST_TEST(deleted == &x);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
Y y;
px.reset(&y, deleter2);
BOOST_TEST(deleted == 0);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(px.get() == &y);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
px.reset(static_cast<Y*>(0), deleter2);
BOOST_TEST(deleted == &y);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
px.reset();
BOOST_TEST(deleted == 0);
}
{
boost::shared_ptr<void> pv;
pv.reset(static_cast<X*>(0), deleter2);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
deleted = &pv;
X x;
pv.reset(&x, deleter2);
BOOST_TEST(deleted == 0);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == &x);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
pv.reset(static_cast<X*>(0), deleter2);
BOOST_TEST(deleted == &x);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
Y y;
pv.reset(&y, deleter2);
BOOST_TEST(deleted == 0);
BOOST_TEST(pv? true: false);
BOOST_TEST(!!pv);
BOOST_TEST(pv.get() == &y);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
pv.reset(static_cast<Y*>(0), deleter2);
BOOST_TEST(deleted == &y);
BOOST_TEST(pv? false: true);
BOOST_TEST(!pv);
BOOST_TEST(pv.get() == 0);
BOOST_TEST(pv.use_count() == 1);
BOOST_TEST(pv.unique());
pv.reset();
BOOST_TEST(deleted == 0);
}
{
boost::shared_ptr<incomplete> px;
px.reset(p0, deleter2);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
deleted = &px;
px.reset(p0, deleter2);
BOOST_TEST(deleted == 0);
}
}
void test()
{
plain_reset();
pointer_reset();
deleter_reset();
}
} // namespace n_reset
namespace n_access
{
struct X
{
};
void test()
{
{
boost::shared_ptr<X> px;
BOOST_TEST(px.get() == 0);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
using boost::get_pointer;
#endif
BOOST_TEST(get_pointer(px) == px.get());
}
{
boost::shared_ptr<X> px(static_cast<X*>(0));
BOOST_TEST(px.get() == 0);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
using boost::get_pointer;
#endif
BOOST_TEST(get_pointer(px) == px.get());
}
{
boost::shared_ptr<X> px(static_cast<X*>(0), boost::checked_deleter<X>());
BOOST_TEST(px.get() == 0);
BOOST_TEST(px? false: true);
BOOST_TEST(!px);
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
using boost::get_pointer;
#endif
BOOST_TEST(get_pointer(px) == px.get());
}
{
X * p = new X;
boost::shared_ptr<X> px(p);
BOOST_TEST(px.get() == p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(&*px == px.get());
BOOST_TEST(px.operator ->() == px.get());
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
using boost::get_pointer;
#endif
BOOST_TEST(get_pointer(px) == px.get());
}
{
X * p = new X;
boost::shared_ptr<X> px(p, boost::checked_deleter<X>());
BOOST_TEST(px.get() == p);
BOOST_TEST(px? true: false);
BOOST_TEST(!!px);
BOOST_TEST(&*px == px.get());
BOOST_TEST(px.operator ->() == px.get());
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
using boost::get_pointer;
#endif
BOOST_TEST(get_pointer(px) == px.get());
}
}
} // namespace n_access
namespace n_use_count
{
struct X
{
};
void test()
{
{
boost::shared_ptr<X> px(static_cast<X*>(0));
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(!px2.unique());
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(!px.unique());
}
{
boost::shared_ptr<X> px(new X);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(!px2.unique());
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(!px.unique());
}
{
boost::shared_ptr<X> px(new X, boost::checked_deleter<X>());
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px.unique());
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(!px2.unique());
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(!px.unique());
}
}
} // namespace n_use_count
namespace n_swap
{
struct X
{
};
void test()
{
{
boost::shared_ptr<X> px;
boost::shared_ptr<X> px2;
px.swap(px2);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px2.get() == 0);
using std::swap;
swap(px, px2);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px2.get() == 0);
}
{
X * p = new X;
boost::shared_ptr<X> px;
boost::shared_ptr<X> px2(p);
boost::shared_ptr<X> px3(px2);
px.swap(px2);
BOOST_TEST(px.get() == p);
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(px2.get() == 0);
BOOST_TEST(px3.get() == p);
BOOST_TEST(px3.use_count() == 2);
using std::swap;
swap(px, px2);
BOOST_TEST(px.get() == 0);
BOOST_TEST(px2.get() == p);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(px3.get() == p);
BOOST_TEST(px3.use_count() == 2);
}
{
X * p1 = new X;
X * p2 = new X;
boost::shared_ptr<X> px(p1);
boost::shared_ptr<X> px2(p2);
boost::shared_ptr<X> px3(px2);
px.swap(px2);
BOOST_TEST(px.get() == p2);
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(px2.get() == p1);
BOOST_TEST(px2.use_count() == 1);
BOOST_TEST(px3.get() == p2);
BOOST_TEST(px3.use_count() == 2);
using std::swap;
swap(px, px2);
BOOST_TEST(px.get() == p1);
BOOST_TEST(px.use_count() == 1);
BOOST_TEST(px2.get() == p2);
BOOST_TEST(px2.use_count() == 2);
BOOST_TEST(px3.get() == p2);
BOOST_TEST(px3.use_count() == 2);
}
}
} // namespace n_swap
namespace n_comparison
{
struct X
{
int dummy;
};
struct Y
{
int dummy2;
};
struct Z: public X, public virtual Y
{
};
void test()
{
{
boost::shared_ptr<X> px;
BOOST_TEST(px == px);
BOOST_TEST(!(px != px));
BOOST_TEST(!(px < px));
boost::shared_ptr<X> px2;
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(px == px2);
BOOST_TEST(!(px != px2));
BOOST_TEST(!(px < px2 && px2 < px));
}
{
boost::shared_ptr<X> px;
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2 == px2);
BOOST_TEST(!(px2 != px2));
BOOST_TEST(!(px2 < px2));
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(px == px2);
BOOST_TEST(!(px != px2));
BOOST_TEST(!(px < px2 && px2 < px));
}
{
boost::shared_ptr<X> px;
boost::shared_ptr<X> px2(new X);
BOOST_TEST(px2 == px2);
BOOST_TEST(!(px2 != px2));
BOOST_TEST(!(px2 < px2));
BOOST_TEST(px.get() != px2.get());
BOOST_TEST(px != px2);
BOOST_TEST(!(px == px2));
BOOST_TEST(px < px2 || px2 < px);
BOOST_TEST(!(px < px2 && px2 < px));
}
{
boost::shared_ptr<X> px(new X);
boost::shared_ptr<X> px2(new X);
BOOST_TEST(px.get() != px2.get());
BOOST_TEST(px != px2);
BOOST_TEST(!(px == px2));
BOOST_TEST(px < px2 || px2 < px);
BOOST_TEST(!(px < px2 && px2 < px));
}
{
boost::shared_ptr<X> px(new X);
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2 == px2);
BOOST_TEST(!(px2 != px2));
BOOST_TEST(!(px2 < px2));
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(px == px2);
BOOST_TEST(!(px != px2));
BOOST_TEST(!(px < px2 || px2 < px));
}
{
boost::shared_ptr<X> px(new X);
boost::shared_ptr<Y> py(new Y);
boost::shared_ptr<Z> pz(new Z);
BOOST_TEST(px.get() != pz.get());
BOOST_TEST(px != pz);
BOOST_TEST(!(px == pz));
BOOST_TEST(py.get() != pz.get());
BOOST_TEST(py != pz);
BOOST_TEST(!(py == pz));
BOOST_TEST(px < py || py < px);
BOOST_TEST(px < pz || pz < px);
BOOST_TEST(py < pz || pz < py);
BOOST_TEST(!(px < py && py < px));
BOOST_TEST(!(px < pz && pz < px));
BOOST_TEST(!(py < pz && pz < py));
boost::shared_ptr<void> pvx(px);
BOOST_TEST(pvx == pvx);
BOOST_TEST(!(pvx != pvx));
BOOST_TEST(!(pvx < pvx));
boost::shared_ptr<void> pvy(py);
boost::shared_ptr<void> pvz(pz);
BOOST_TEST(pvx < pvy || pvy < pvx);
BOOST_TEST(pvx < pvz || pvz < pvx);
BOOST_TEST(pvy < pvz || pvz < pvy);
BOOST_TEST(!(pvx < pvy && pvy < pvx));
BOOST_TEST(!(pvx < pvz && pvz < pvx));
BOOST_TEST(!(pvy < pvz && pvz < pvy));
}
{
boost::shared_ptr<Z> pz(new Z);
boost::shared_ptr<X> px(pz);
BOOST_TEST(px == px);
BOOST_TEST(!(px != px));
BOOST_TEST(!(px < px));
boost::shared_ptr<Y> py(pz);
BOOST_TEST(px.get() == pz.get());
BOOST_TEST(px == pz);
BOOST_TEST(!(px != pz));
BOOST_TEST(py.get() == pz.get());
BOOST_TEST(py == pz);
BOOST_TEST(!(py != pz));
BOOST_TEST(!(px < py || py < px));
BOOST_TEST(!(px < pz || pz < px));
BOOST_TEST(!(py < pz || pz < py));
boost::shared_ptr<void> pvx(px);
boost::shared_ptr<void> pvy(py);
boost::shared_ptr<void> pvz(pz);
// pvx and pvy aren't equal...
BOOST_TEST(pvx.get() != pvy.get());
BOOST_TEST(pvx != pvy);
BOOST_TEST(!(pvx == pvy));
// ... but they share ownership ...
BOOST_TEST(!(pvx < pvy || pvy < pvx));
// ... with pvz
BOOST_TEST(!(pvx < pvz || pvz < pvx));
BOOST_TEST(!(pvy < pvz || pvz < pvy));
}
}
} // namespace n_comparison
namespace n_static_cast
{
struct X
{
};
struct Y: public X
{
};
void test()
{
{
boost::shared_ptr<void> pv;
boost::shared_ptr<int> pi = boost::static_pointer_cast<int>(pv);
BOOST_TEST(pi.get() == 0);
boost::shared_ptr<X> px = boost::static_pointer_cast<X>(pv);
BOOST_TEST(px.get() == 0);
}
{
boost::shared_ptr<int> pi(new int);
boost::shared_ptr<void> pv(pi);
boost::shared_ptr<int> pi2 = boost::static_pointer_cast<int>(pv);
BOOST_TEST(pi.get() == pi2.get());
BOOST_TEST(!(pi < pi2 || pi2 < pi));
BOOST_TEST(pi.use_count() == 3);
BOOST_TEST(pv.use_count() == 3);
BOOST_TEST(pi2.use_count() == 3);
}
{
boost::shared_ptr<X> px(new X);
boost::shared_ptr<void> pv(px);
boost::shared_ptr<X> px2 = boost::static_pointer_cast<X>(pv);
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(!(px < px2 || px2 < px));
BOOST_TEST(px.use_count() == 3);
BOOST_TEST(pv.use_count() == 3);
BOOST_TEST(px2.use_count() == 3);
}
{
boost::shared_ptr<X> px(new Y);
boost::shared_ptr<Y> py = boost::static_pointer_cast<Y>(px);
BOOST_TEST(px.get() == py.get());
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(py.use_count() == 2);
boost::shared_ptr<X> px2(py);
BOOST_TEST(!(px < px2 || px2 < px));
}
}
} // namespace n_static_cast
namespace n_const_cast
{
struct X;
void test()
{
{
boost::shared_ptr<void const volatile> px;
boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
BOOST_TEST(px2.get() == 0);
}
{
boost::shared_ptr<int const volatile> px;
boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
BOOST_TEST(px2.get() == 0);
}
{
boost::shared_ptr<X const volatile> px;
boost::shared_ptr<X> px2 = boost::const_pointer_cast<X>(px);
BOOST_TEST(px2.get() == 0);
}
{
boost::shared_ptr<void const volatile> px(new int);
boost::shared_ptr<void> px2 = boost::const_pointer_cast<void>(px);
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(!(px < px2 || px2 < px));
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(px2.use_count() == 2);
}
{
boost::shared_ptr<int const volatile> px(new int);
boost::shared_ptr<int> px2 = boost::const_pointer_cast<int>(px);
BOOST_TEST(px.get() == px2.get());
BOOST_TEST(!(px < px2 || px2 < px));
BOOST_TEST(px.use_count() == 2);
BOOST_TEST(px2.use_count() == 2);
}
}
} // namespace n_const_cast
#if !defined( BOOST_NO_RTTI )
namespace n_dynamic_cast
{
struct V
{
virtual ~V() {}
};
struct W: public V
{
};
void test()
{
{
boost::shared_ptr<V> pv;
boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
BOOST_TEST(pw.get() == 0);
}
{
boost::shared_ptr<V> pv(static_cast<V*>(0));
boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
BOOST_TEST(pw.get() == 0);
boost::shared_ptr<V> pv2(pw);
BOOST_TEST(pv < pv2 || pv2 < pv);
}
{
boost::shared_ptr<V> pv(static_cast<W*>(0));
boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
BOOST_TEST(pw.get() == 0);
boost::shared_ptr<V> pv2(pw);
BOOST_TEST(pv < pv2 || pv2 < pv);
}
{
boost::shared_ptr<V> pv(new V);
boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
BOOST_TEST(pw.get() == 0);
boost::shared_ptr<V> pv2(pw);
BOOST_TEST(pv < pv2 || pv2 < pv);
}
{
boost::shared_ptr<V> pv(new W);
boost::shared_ptr<W> pw = boost::dynamic_pointer_cast<W>(pv);
BOOST_TEST(pw.get() == pv.get());
BOOST_TEST(pv.use_count() == 2);
BOOST_TEST(pw.use_count() == 2);
boost::shared_ptr<V> pv2(pw);
BOOST_TEST(!(pv < pv2 || pv2 < pv));
}
}
} // namespace n_dynamic_cast
#endif
namespace n_map
{
struct X
{
};
void test()
{
std::vector< boost::shared_ptr<int> > vi;
{
boost::shared_ptr<int> pi1(new int);
boost::shared_ptr<int> pi2(new int);
boost::shared_ptr<int> pi3(new int);
vi.push_back(pi1);
vi.push_back(pi1);
vi.push_back(pi1);
vi.push_back(pi2);
vi.push_back(pi1);
vi.push_back(pi2);
vi.push_back(pi1);
vi.push_back(pi3);
vi.push_back(pi3);
vi.push_back(pi2);
vi.push_back(pi1);
}
std::vector< boost::shared_ptr<X> > vx;
{
boost::shared_ptr<X> px1(new X);
boost::shared_ptr<X> px2(new X);
boost::shared_ptr<X> px3(new X);
vx.push_back(px2);
vx.push_back(px2);
vx.push_back(px1);
vx.push_back(px2);
vx.push_back(px1);
vx.push_back(px1);
vx.push_back(px1);
vx.push_back(px2);
vx.push_back(px1);
vx.push_back(px3);
vx.push_back(px2);
}
std::map< boost::shared_ptr<void>, long > m;
{
for(std::vector< boost::shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i)
{
++m[*i];
}
}
{
for(std::vector< boost::shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i)
{
++m[*i];
}
}
{
for(std::map< boost::shared_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
{
BOOST_TEST(i->first.use_count() == i->second + 1);
}
}
}
} // namespace n_map
namespace n_transitive
{
struct X
{
X(): next() {}
boost::shared_ptr<X> next;
};
void test()
{
boost::shared_ptr<X> p(new X);
p->next = boost::shared_ptr<X>(new X);
BOOST_TEST(!p->next->next);
p = p->next;
BOOST_TEST(!p->next);
}
} // namespace n_transitive
namespace n_report_1
{
class foo
{
public:
foo(): m_self(this)
{
}
void suicide()
{
m_self.reset();
}
private:
boost::shared_ptr<foo> m_self;
};
void test()
{
foo * foo_ptr = new foo;
foo_ptr->suicide();
}
} // namespace n_report_1
// Test case by Per Kristensen
namespace n_report_2
{
class foo
{
public:
void setWeak(boost::shared_ptr<foo> s)
{
w = s;
}
private:
boost::weak_ptr<foo> w;
};
class deleter
{
public:
deleter(): lock(0)
{
}
~deleter()
{
BOOST_TEST(lock == 0);
}
void operator() (foo * p)
{
++lock;
delete p;
--lock;
}
private:
int lock;
};
void test()
{
boost::shared_ptr<foo> s(new foo, deleter());
s->setWeak(s);
s.reset();
}
} // namespace n_report_2
namespace n_spt_incomplete
{
class file;
boost::shared_ptr<file> fopen(char const * name, char const * mode);
void fread(boost::shared_ptr<file> f, void * data, long size);
int file_instances = 0;
void test()
{
BOOST_TEST(file_instances == 0);
{
boost::shared_ptr<file> pf = fopen("name", "mode");
BOOST_TEST(file_instances == 1);
fread(pf, 0, 17041);
}
BOOST_TEST(file_instances == 0);
}
} // namespace n_spt_incomplete
namespace n_spt_pimpl
{
class file
{
private:
class impl;
boost::shared_ptr<impl> pimpl_;
public:
file(char const * name, char const * mode);
// compiler generated members are fine and useful
void read(void * data, long size);
long total_size() const;
};
int file_instances = 0;
void test()
{
BOOST_TEST(file_instances == 0);
{
file f("name", "mode");
BOOST_TEST(file_instances == 1);
f.read(0, 152);
file f2(f);
BOOST_TEST(file_instances == 1);
f2.read(0, 894);
BOOST_TEST(f.total_size() == 152+894);
{
file f3("name2", "mode2");
BOOST_TEST(file_instances == 2);
}
BOOST_TEST(file_instances == 1);
}
BOOST_TEST(file_instances == 0);
}
} // namespace n_spt_pimpl
namespace n_spt_abstract
{
class X
{
public:
virtual void f(int) = 0;
virtual int g() = 0;
protected:
~X() {}
};
boost::shared_ptr<X> createX();
int X_instances = 0;
void test()
{
BOOST_TEST(X_instances == 0);
{
boost::shared_ptr<X> px = createX();
BOOST_TEST(X_instances == 1);
px->f(18);
px->f(152);
BOOST_TEST(px->g() == 170);
}
BOOST_TEST(X_instances == 0);
}
} // namespace n_spt_abstract
namespace n_spt_preventing_delete
{
int X_instances = 0;
class X
{
private:
X()
{
++X_instances;
}
~X()
{
--X_instances;
}
class deleter;
friend class deleter;
class deleter
{
public:
void operator()(X * p) { delete p; }
};
public:
static boost::shared_ptr<X> create()
{
boost::shared_ptr<X> px(new X, X::deleter());
return px;
}
};
void test()
{
BOOST_TEST(X_instances == 0);
{
boost::shared_ptr<X> px = X::create();
BOOST_TEST(X_instances == 1);
}
BOOST_TEST(X_instances == 0);
}
} // namespace n_spt_preventing_delete
namespace n_spt_array
{
int X_instances = 0;
struct X
{
X()
{
++X_instances;
}
~X()
{
--X_instances;
}
};
void test()
{
BOOST_TEST(X_instances == 0);
{
boost::shared_ptr<X> px(new X[4], boost::checked_array_deleter<X>());
BOOST_TEST(X_instances == 4);
}
BOOST_TEST(X_instances == 0);
}
} // namespace n_spt_array
namespace n_spt_static
{
class X
{
public:
X()
{
}
private:
void operator delete(void *)
{
// Comeau 4.3.0.1 wants a definition
BOOST_ERROR("n_spt_static::X::operator delete() called.");
}
};
struct null_deleter
{
void operator()(void const *) const
{
}
};
static X x;
void test()
{
boost::shared_ptr<X> px(&x, null_deleter());
}
} // namespace n_spt_static
namespace n_spt_intrusive
{
int X_instances = 0;
struct X
{
long count;
X(): count(0)
{
++X_instances;
}
~X()
{
--X_instances;
}
};
void intrusive_ptr_add_ref(X * p)
{
++p->count;
}
void intrusive_ptr_release(X * p)
{
if(--p->count == 0) delete p;
}
template<class T> struct intrusive_deleter
{
void operator()(T * p)
{
if(p != 0) intrusive_ptr_release(p);
}
};
boost::shared_ptr<X> make_shared_from_intrusive(X * p)
{
if(p != 0) intrusive_ptr_add_ref(p);
boost::shared_ptr<X> px(p, intrusive_deleter<X>());
return px;
}
void test()
{
BOOST_TEST(X_instances == 0);
{
X * p = new X;
BOOST_TEST(X_instances == 1);
BOOST_TEST(p->count == 0);
boost::shared_ptr<X> px = make_shared_from_intrusive(p);
BOOST_TEST(px.get() == p);
BOOST_TEST(p->count == 1);
boost::shared_ptr<X> px2(px);
BOOST_TEST(px2.get() == p);
BOOST_TEST(p->count == 1);
}
BOOST_TEST(X_instances == 0);
}
} // namespace n_spt_intrusive
namespace n_spt_another_sp
{
template<class T> class another_ptr: private boost::shared_ptr<T>
{
private:
typedef boost::shared_ptr<T> base_type;
public:
explicit another_ptr(T * p = 0): base_type(p)
{
}
void reset()
{
base_type::reset();
}
T * get() const
{
return base_type::get();
}
};
class event_handler
{
public:
virtual ~event_handler() {}
virtual void begin() = 0;
virtual void handle(int event) = 0;
virtual void end() = 0;
};
int begin_called = 0;
int handle_called = 0;
int end_called = 0;
class event_handler_impl: public event_handler
{
public:
virtual void begin()
{
++begin_called;
}
virtual void handle(int event)
{
handle_called = event;
}
virtual void end()
{
++end_called;
}
};
another_ptr<event_handler> get_event_handler()
{
another_ptr<event_handler> p(new event_handler_impl);
return p;
}
boost::shared_ptr<event_handler> current_handler;
void install_event_handler(boost::shared_ptr<event_handler> p)
{
p->begin();
current_handler = p;
}
void handle_event(int event)
{
current_handler->handle(event);
}
void remove_event_handler()
{
current_handler->end();
current_handler.reset();
}
template<class P> class smart_pointer_deleter
{
private:
P p_;
public:
smart_pointer_deleter(P const & p): p_(p)
{
}
void operator()(void const *)
{
p_.reset();
}
};
void test()
{
another_ptr<event_handler> p = get_event_handler();
boost::shared_ptr<event_handler> q(p.get(), smart_pointer_deleter< another_ptr<event_handler> >(p));
p.reset();
BOOST_TEST(begin_called == 0);
install_event_handler(q);
BOOST_TEST(begin_called == 1);
BOOST_TEST(handle_called == 0);
handle_event(17041);
BOOST_TEST(handle_called == 17041);
BOOST_TEST(end_called == 0);
remove_event_handler();
BOOST_TEST(end_called == 1);
}
} // namespace n_spt_another_sp
namespace n_spt_shared_from_this
{
class X
{
public:
virtual void f() = 0;
protected:
~X() {}
};
class Y
{
public:
virtual boost::shared_ptr<X> getX() = 0;
protected:
~Y() {}
};
class impl: public X, public Y
{
private:
boost::weak_ptr<impl> weak_this;
impl(impl const &);
impl & operator=(impl const &);
impl() {}
public:
static boost::shared_ptr<impl> create()
{
boost::shared_ptr<impl> pi(new impl);
pi->weak_this = pi;
return pi;
}
virtual void f() {}
virtual boost::shared_ptr<X> getX()
{
boost::shared_ptr<X> px = weak_this.lock();
return px;
}
};
void test()
{
boost::shared_ptr<Y> py = impl::create();
BOOST_TEST(py.get() != 0);
BOOST_TEST(py.use_count() == 1);
boost::shared_ptr<X> px = py->getX();
BOOST_TEST(px.get() != 0);
BOOST_TEST(py.use_count() == 2);
#if !defined( BOOST_NO_RTTI )
boost::shared_ptr<Y> py2 = boost::dynamic_pointer_cast<Y>(px);
BOOST_TEST(py.get() == py2.get());
BOOST_TEST(!(py < py2 || py2 < py));
BOOST_TEST(py.use_count() == 3);
#endif
}
} // namespace n_spt_shared_from_this
namespace n_spt_wrap
{
void test()
{
}
} // namespace n_spt_wrap
int main()
{
n_element_type::test();
n_constructors::test();
n_assignment::test();
n_reset::test();
n_access::test();
n_use_count::test();
n_swap::test();
n_comparison::test();
n_static_cast::test();
n_const_cast::test();
#if !defined( BOOST_NO_RTTI )
n_dynamic_cast::test();
#endif
n_map::test();
n_transitive::test();
n_report_1::test();
n_report_2::test();
n_spt_incomplete::test();
n_spt_pimpl::test();
n_spt_abstract::test();
n_spt_preventing_delete::test();
n_spt_array::test();
n_spt_static::test();
n_spt_intrusive::test();
n_spt_another_sp::test();
n_spt_shared_from_this::test();
n_spt_wrap::test();
return boost::report_errors();
}
namespace n_spt_incomplete
{
class file
{
public:
file(): fread_called(false)
{
++file_instances;
}
~file()
{
BOOST_TEST(fread_called);
--file_instances;
}
bool fread_called;
};
boost::shared_ptr<file> fopen(char const *, char const *)
{
boost::shared_ptr<file> pf(new file);
return pf;
}
void fread(boost::shared_ptr<file> pf, void *, long)
{
pf->fread_called = true;
}
} // namespace n_spt_incomplete
namespace n_spt_pimpl
{
class file::impl
{
private:
impl(impl const &);
impl & operator=(impl const &);
long total_size_;
public:
impl(char const *, char const *): total_size_(0)
{
++file_instances;
}
~impl()
{
--file_instances;
}
void read(void *, long size)
{
total_size_ += size;
}
long total_size() const
{
return total_size_;
}
};
file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
{
}
void file::read(void * data, long size)
{
pimpl_->read(data, size);
}
long file::total_size() const
{
return pimpl_->total_size();
}
} // namespace n_spt_pimpl
namespace n_spt_abstract
{
class X_impl: public X
{
private:
X_impl(X_impl const &);
X_impl & operator=(X_impl const &);
int n_;
public:
X_impl(): n_(0)
{
++X_instances;
}
~X_impl()
{
--X_instances;
}
virtual void f(int n)
{
n_ += n;
}
virtual int g()
{
return n_;
}
};
boost::shared_ptr<X> createX()
{
boost::shared_ptr<X> px(new X_impl);
return px;
}
} // namespace n_spt_abstract
Reference in New Issue View Git Blame Copy Permalink