1366 lines
31 KiB
C++
1366 lines
31 KiB
C++
#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
|
|
|
|
//
|
|
// weak_ptr_test.cpp
|
|
//
|
|
// Copyright (c) 2002-2005 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/detail/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::weak_ptr<int>::element_type T;
|
|
T t;
|
|
f(t);
|
|
}
|
|
|
|
} // namespace n_element_type
|
|
|
|
class incomplete;
|
|
|
|
boost::shared_ptr<incomplete> create_incomplete();
|
|
|
|
struct X
|
|
{
|
|
int dummy;
|
|
};
|
|
|
|
struct Y
|
|
{
|
|
int dummy2;
|
|
};
|
|
|
|
struct Z: public X, public virtual Y
|
|
{
|
|
};
|
|
|
|
namespace n_constructors
|
|
{
|
|
|
|
void default_constructor()
|
|
{
|
|
{
|
|
boost::weak_ptr<int> wp;
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<void> wp;
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<incomplete> wp;
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
}
|
|
}
|
|
|
|
void shared_ptr_constructor()
|
|
{
|
|
{
|
|
boost::shared_ptr<int> sp;
|
|
|
|
boost::weak_ptr<int> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
|
|
boost::weak_ptr<void> wp2(sp);
|
|
BOOST_TEST(wp2.use_count() == sp.use_count());
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(static_cast<int*>(0));
|
|
|
|
{
|
|
boost::weak_ptr<int> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<int> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(new int);
|
|
|
|
{
|
|
boost::weak_ptr<int> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<int> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp;
|
|
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp(static_cast<int*>(0));
|
|
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp(new int);
|
|
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> sp;
|
|
|
|
boost::weak_ptr<incomplete> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
|
|
boost::weak_ptr<void> wp2(sp);
|
|
BOOST_TEST(wp2.use_count() == sp.use_count());
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> sp = create_incomplete();
|
|
|
|
{
|
|
boost::weak_ptr<incomplete> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<incomplete> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp = create_incomplete();
|
|
|
|
boost::weak_ptr<void> wp(sp);
|
|
BOOST_TEST(wp.use_count() == sp.use_count());
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
boost::shared_ptr<void> sp2(wp);
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!(sp < sp2 || sp2 < sp));
|
|
}
|
|
}
|
|
|
|
void copy_constructor()
|
|
{
|
|
{
|
|
boost::weak_ptr<int> wp;
|
|
boost::weak_ptr<int> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<void> wp;
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<incomplete> wp;
|
|
boost::weak_ptr<incomplete> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(static_cast<int*>(0));
|
|
boost::weak_ptr<int> wp(sp);
|
|
|
|
boost::weak_ptr<int> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<int> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(new int);
|
|
boost::weak_ptr<int> wp(sp);
|
|
|
|
boost::weak_ptr<int> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<int> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp(static_cast<int*>(0));
|
|
boost::weak_ptr<void> wp(sp);
|
|
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<void> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> sp(new int);
|
|
boost::weak_ptr<void> wp(sp);
|
|
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<void> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> sp = create_incomplete();
|
|
boost::weak_ptr<incomplete> wp(sp);
|
|
|
|
boost::weak_ptr<incomplete> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<incomplete> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
}
|
|
|
|
void conversion_constructor()
|
|
{
|
|
{
|
|
boost::weak_ptr<int> wp;
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<incomplete> wp;
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<Z> wp;
|
|
|
|
boost::weak_ptr<X> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
|
|
boost::weak_ptr<Y> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(static_cast<int*>(0));
|
|
boost::weak_ptr<int> wp(sp);
|
|
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<void> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> sp(new int);
|
|
boost::weak_ptr<int> wp(sp);
|
|
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<void> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> sp = create_incomplete();
|
|
boost::weak_ptr<incomplete> wp(sp);
|
|
|
|
boost::weak_ptr<void> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<void> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<Z> sp(static_cast<Z*>(0));
|
|
boost::weak_ptr<Z> wp(sp);
|
|
|
|
boost::weak_ptr<X> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<X> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<Z> sp(static_cast<Z*>(0));
|
|
boost::weak_ptr<Z> wp(sp);
|
|
|
|
boost::weak_ptr<Y> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<Y> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<Z> sp(new Z);
|
|
boost::weak_ptr<Z> wp(sp);
|
|
|
|
boost::weak_ptr<X> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<X> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<Z> sp(new Z);
|
|
boost::weak_ptr<Z> wp(sp);
|
|
|
|
boost::weak_ptr<Y> wp2(wp);
|
|
BOOST_TEST(wp2.use_count() == wp.use_count());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
sp.reset();
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
|
|
boost::weak_ptr<Y> wp3(wp);
|
|
BOOST_TEST(wp3.use_count() == wp.use_count());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
}
|
|
}
|
|
|
|
void test()
|
|
{
|
|
default_constructor();
|
|
shared_ptr_constructor();
|
|
copy_constructor();
|
|
conversion_constructor();
|
|
}
|
|
|
|
} // namespace n_constructors
|
|
|
|
namespace n_assignment
|
|
{
|
|
|
|
template<class T> void copy_assignment(boost::shared_ptr<T> & sp)
|
|
{
|
|
BOOST_TEST(sp.unique());
|
|
|
|
boost::weak_ptr<T> p1;
|
|
|
|
p1 = p1;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::weak_ptr<T> p2;
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::weak_ptr<T> p3(p1);
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::weak_ptr<T> p4(sp);
|
|
|
|
p4 = p4;
|
|
BOOST_TEST(p4.use_count() == 1);
|
|
|
|
p1 = p4;
|
|
BOOST_TEST(p1.use_count() == 1);
|
|
|
|
p4 = p2;
|
|
BOOST_TEST(p4.use_count() == 0);
|
|
|
|
sp.reset();
|
|
|
|
p1 = p1;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
p4 = p1;
|
|
BOOST_TEST(p4.use_count() == 0);
|
|
}
|
|
|
|
void conversion_assignment()
|
|
{
|
|
{
|
|
boost::weak_ptr<void> p1;
|
|
|
|
boost::weak_ptr<incomplete> p2;
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::shared_ptr<incomplete> sp = create_incomplete();
|
|
boost::weak_ptr<incomplete> p3(sp);
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 1);
|
|
|
|
sp.reset();
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<X> p1;
|
|
|
|
boost::weak_ptr<Z> p2;
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::shared_ptr<Z> sp(new Z);
|
|
boost::weak_ptr<Z> p3(sp);
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 1);
|
|
|
|
sp.reset();
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::weak_ptr<Y> p1;
|
|
|
|
boost::weak_ptr<Z> p2;
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
boost::shared_ptr<Z> sp(new Z);
|
|
boost::weak_ptr<Z> p3(sp);
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 1);
|
|
|
|
sp.reset();
|
|
|
|
p1 = p3;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
p1 = p2;
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
}
|
|
}
|
|
|
|
template<class T, class U> void shared_ptr_assignment(boost::shared_ptr<U> & sp, T * = 0)
|
|
{
|
|
BOOST_TEST(sp.unique());
|
|
|
|
boost::weak_ptr<T> p1;
|
|
boost::weak_ptr<T> p2(p1);
|
|
boost::weak_ptr<T> p3(sp);
|
|
boost::weak_ptr<T> p4(p3);
|
|
|
|
p1 = sp;
|
|
BOOST_TEST(p1.use_count() == 1);
|
|
|
|
p2 = sp;
|
|
BOOST_TEST(p2.use_count() == 1);
|
|
|
|
p3 = sp;
|
|
BOOST_TEST(p3.use_count() == 1);
|
|
|
|
p4 = sp;
|
|
BOOST_TEST(p4.use_count() == 1);
|
|
|
|
sp.reset();
|
|
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
BOOST_TEST(p2.use_count() == 0);
|
|
BOOST_TEST(p3.use_count() == 0);
|
|
BOOST_TEST(p4.use_count() == 0);
|
|
|
|
p1 = sp;
|
|
}
|
|
|
|
void test()
|
|
{
|
|
{
|
|
boost::shared_ptr<int> p( new int );
|
|
copy_assignment( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> p( new X );
|
|
copy_assignment( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> p( new int );
|
|
copy_assignment( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> p = create_incomplete();
|
|
copy_assignment( p );
|
|
}
|
|
|
|
conversion_assignment();
|
|
|
|
{
|
|
boost::shared_ptr<int> p( new int );
|
|
shared_ptr_assignment<int>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> p( new int );
|
|
shared_ptr_assignment<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> p( new X );
|
|
shared_ptr_assignment<X>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> p( new X );
|
|
shared_ptr_assignment<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> p( new int );
|
|
shared_ptr_assignment<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> p = create_incomplete();
|
|
shared_ptr_assignment<incomplete>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> p = create_incomplete();
|
|
shared_ptr_assignment<void>( p );
|
|
}
|
|
}
|
|
|
|
} // namespace n_assignment
|
|
|
|
namespace n_reset
|
|
{
|
|
|
|
template<class T, class U> void test2( boost::shared_ptr<U> & sp, T * = 0 )
|
|
{
|
|
BOOST_TEST(sp.unique());
|
|
|
|
boost::weak_ptr<T> p1;
|
|
boost::weak_ptr<T> p2(p1);
|
|
boost::weak_ptr<T> p3(sp);
|
|
boost::weak_ptr<T> p4(p3);
|
|
boost::weak_ptr<T> p5(sp);
|
|
boost::weak_ptr<T> p6(p5);
|
|
|
|
p1.reset();
|
|
BOOST_TEST(p1.use_count() == 0);
|
|
|
|
p2.reset();
|
|
BOOST_TEST(p2.use_count() == 0);
|
|
|
|
p3.reset();
|
|
BOOST_TEST(p3.use_count() == 0);
|
|
|
|
p4.reset();
|
|
BOOST_TEST(p4.use_count() == 0);
|
|
|
|
sp.reset();
|
|
|
|
p5.reset();
|
|
BOOST_TEST(p5.use_count() == 0);
|
|
|
|
p6.reset();
|
|
BOOST_TEST(p6.use_count() == 0);
|
|
}
|
|
|
|
void test()
|
|
{
|
|
{
|
|
boost::shared_ptr<int> p( new int );
|
|
test2<int>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<int> p( new int );
|
|
test2<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> p( new X );
|
|
test2<X>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> p( new X );
|
|
test2<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<void> p( new int );
|
|
test2<void>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> p = create_incomplete();
|
|
test2<incomplete>( p );
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<incomplete> p = create_incomplete();
|
|
test2<void>( p );
|
|
}
|
|
}
|
|
|
|
} // namespace n_reset
|
|
|
|
namespace n_use_count
|
|
{
|
|
|
|
void test()
|
|
{
|
|
{
|
|
boost::weak_ptr<X> wp;
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp.expired());
|
|
|
|
boost::weak_ptr<X> wp2;
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp.expired());
|
|
|
|
boost::weak_ptr<X> wp3(wp);
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp.expired());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(wp3.expired());
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(static_cast<X*>(0));
|
|
|
|
boost::weak_ptr<X> wp(sp);
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(!wp.expired());
|
|
|
|
boost::weak_ptr<X> wp2(sp);
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(!wp.expired());
|
|
|
|
boost::weak_ptr<X> wp3(wp);
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(!wp.expired());
|
|
BOOST_TEST(wp3.use_count() == 1);
|
|
BOOST_TEST(!wp3.expired());
|
|
|
|
boost::shared_ptr<X> sp2(sp);
|
|
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!wp.expired());
|
|
BOOST_TEST(wp2.use_count() == 2);
|
|
BOOST_TEST(!wp2.expired());
|
|
BOOST_TEST(wp3.use_count() == 2);
|
|
BOOST_TEST(!wp3.expired());
|
|
|
|
boost::shared_ptr<void> sp3(sp);
|
|
|
|
BOOST_TEST(wp.use_count() == 3);
|
|
BOOST_TEST(!wp.expired());
|
|
BOOST_TEST(wp2.use_count() == 3);
|
|
BOOST_TEST(!wp2.expired());
|
|
BOOST_TEST(wp3.use_count() == 3);
|
|
BOOST_TEST(!wp3.expired());
|
|
|
|
sp.reset();
|
|
|
|
BOOST_TEST(wp.use_count() == 2);
|
|
BOOST_TEST(!wp.expired());
|
|
BOOST_TEST(wp2.use_count() == 2);
|
|
BOOST_TEST(!wp2.expired());
|
|
BOOST_TEST(wp3.use_count() == 2);
|
|
BOOST_TEST(!wp3.expired());
|
|
|
|
sp2.reset();
|
|
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(!wp.expired());
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!wp2.expired());
|
|
BOOST_TEST(wp3.use_count() == 1);
|
|
BOOST_TEST(!wp3.expired());
|
|
|
|
sp3.reset();
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp.expired());
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(wp2.expired());
|
|
BOOST_TEST(wp3.use_count() == 0);
|
|
BOOST_TEST(wp3.expired());
|
|
}
|
|
}
|
|
|
|
} // namespace n_use_count
|
|
|
|
namespace n_swap
|
|
{
|
|
|
|
void test()
|
|
{
|
|
{
|
|
boost::weak_ptr<X> wp;
|
|
boost::weak_ptr<X> wp2;
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
|
|
using std::swap;
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(new X);
|
|
boost::weak_ptr<X> wp;
|
|
boost::weak_ptr<X> wp2(sp);
|
|
boost::weak_ptr<X> wp3(sp);
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
|
|
using std::swap;
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
|
|
sp.reset();
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(new X);
|
|
boost::shared_ptr<X> sp2(new X);
|
|
boost::weak_ptr<X> wp(sp);
|
|
boost::weak_ptr<X> wp2(sp2);
|
|
boost::weak_ptr<X> wp3(sp2);
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
|
|
using std::swap;
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
|
|
sp.reset();
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 1);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 1);
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
|
|
sp2.reset();
|
|
|
|
wp.swap(wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
|
|
swap(wp, wp2);
|
|
|
|
BOOST_TEST(wp.use_count() == 0);
|
|
BOOST_TEST(wp2.use_count() == 0);
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
}
|
|
}
|
|
|
|
} // namespace n_swap
|
|
|
|
namespace n_comparison
|
|
{
|
|
|
|
void test()
|
|
{
|
|
{
|
|
boost::weak_ptr<X> wp;
|
|
BOOST_TEST(!(wp < wp));
|
|
|
|
boost::weak_ptr<X> wp2;
|
|
BOOST_TEST(!(wp < wp2 && wp2 < wp));
|
|
|
|
boost::weak_ptr<X> wp3(wp);
|
|
BOOST_TEST(!(wp3 < wp3));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(new X);
|
|
|
|
boost::weak_ptr<X> wp(sp);
|
|
BOOST_TEST(!(wp < wp));
|
|
|
|
boost::weak_ptr<X> wp2;
|
|
BOOST_TEST(wp < wp2 || wp2 < wp);
|
|
BOOST_TEST(!(wp < wp2 && wp2 < wp));
|
|
|
|
bool b1 = wp < wp2;
|
|
bool b2 = wp2 < wp;
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(wp2 < wp3 || wp3 < wp2);
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(wp4 < wp3 || wp3 < wp4);
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
|
|
sp.reset();
|
|
|
|
BOOST_TEST(b1 == (wp < wp2));
|
|
BOOST_TEST(b2 == (wp2 < wp));
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(wp2 < wp3 || wp3 < wp2);
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(wp4 < wp3 || wp3 < wp4);
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(new X);
|
|
boost::shared_ptr<X> sp2(new X);
|
|
|
|
boost::weak_ptr<X> wp(sp);
|
|
boost::weak_ptr<X> wp2(sp2);
|
|
|
|
BOOST_TEST(wp < wp2 || wp2 < wp);
|
|
BOOST_TEST(!(wp < wp2 && wp2 < wp));
|
|
|
|
bool b1 = wp < wp2;
|
|
bool b2 = wp2 < wp;
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(wp2 < wp3 || wp3 < wp2);
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(wp4 < wp3 || wp3 < wp4);
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
|
|
sp.reset();
|
|
|
|
BOOST_TEST(b1 == (wp < wp2));
|
|
BOOST_TEST(b2 == (wp2 < wp));
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(wp2 < wp3 || wp3 < wp2);
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(wp4 < wp3 || wp3 < wp4);
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
|
|
sp2.reset();
|
|
|
|
BOOST_TEST(b1 == (wp < wp2));
|
|
BOOST_TEST(b2 == (wp2 < wp));
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(wp2 < wp3 || wp3 < wp2);
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(wp4 < wp3 || wp3 < wp4);
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> sp(new X);
|
|
boost::shared_ptr<X> sp2(sp);
|
|
|
|
boost::weak_ptr<X> wp(sp);
|
|
boost::weak_ptr<X> wp2(sp2);
|
|
|
|
BOOST_TEST(!(wp < wp2 || wp2 < wp));
|
|
BOOST_TEST(!(wp < wp2 && wp2 < wp));
|
|
|
|
bool b1 = wp < wp2;
|
|
bool b2 = wp2 < wp;
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(!(wp4 < wp3 || wp3 < wp4));
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
|
|
sp.reset();
|
|
sp2.reset();
|
|
|
|
BOOST_TEST(b1 == (wp < wp2));
|
|
BOOST_TEST(b2 == (wp2 < wp));
|
|
|
|
{
|
|
boost::weak_ptr<X> wp3(wp);
|
|
|
|
BOOST_TEST(!(wp < wp3 || wp3 < wp));
|
|
BOOST_TEST(!(wp < wp3 && wp3 < wp));
|
|
|
|
BOOST_TEST(!(wp2 < wp3 || wp3 < wp2));
|
|
BOOST_TEST(!(wp2 < wp3 && wp3 < wp2));
|
|
|
|
boost::weak_ptr<X> wp4(wp2);
|
|
|
|
BOOST_TEST(!(wp4 < wp3 || wp3 < wp4));
|
|
BOOST_TEST(!(wp4 < wp3 && wp3 < wp4));
|
|
}
|
|
}
|
|
|
|
{
|
|
boost::shared_ptr<X> spx(new X);
|
|
boost::shared_ptr<Y> spy(new Y);
|
|
boost::shared_ptr<Z> spz(new Z);
|
|
|
|
boost::weak_ptr<X> px(spx);
|
|
boost::weak_ptr<Y> py(spy);
|
|
boost::weak_ptr<Z> pz(spz);
|
|
|
|
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::weak_ptr<void> pvx(px);
|
|
BOOST_TEST(!(pvx < pvx));
|
|
|
|
boost::weak_ptr<void> pvy(py);
|
|
BOOST_TEST(!(pvy < pvy));
|
|
|
|
boost::weak_ptr<void> pvz(pz);
|
|
BOOST_TEST(!(pvz < pvz));
|
|
|
|
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));
|
|
|
|
spx.reset();
|
|
spy.reset();
|
|
spz.reset();
|
|
|
|
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_TEST(!(pvx < pvx));
|
|
BOOST_TEST(!(pvy < pvy));
|
|
BOOST_TEST(!(pvz < pvz));
|
|
|
|
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> spz(new Z);
|
|
boost::shared_ptr<X> spx(spz);
|
|
|
|
boost::weak_ptr<Z> pz(spz);
|
|
boost::weak_ptr<X> px(spx);
|
|
boost::weak_ptr<Y> py(spz);
|
|
|
|
BOOST_TEST(!(px < px));
|
|
BOOST_TEST(!(py < py));
|
|
|
|
BOOST_TEST(!(px < py || py < px));
|
|
BOOST_TEST(!(px < pz || pz < px));
|
|
BOOST_TEST(!(py < pz || pz < py));
|
|
|
|
boost::weak_ptr<void> pvx(px);
|
|
boost::weak_ptr<void> pvy(py);
|
|
boost::weak_ptr<void> pvz(pz);
|
|
|
|
BOOST_TEST(!(pvx < pvy || pvy < pvx));
|
|
BOOST_TEST(!(pvx < pvz || pvz < pvx));
|
|
BOOST_TEST(!(pvy < pvz || pvz < pvy));
|
|
|
|
spx.reset();
|
|
spz.reset();
|
|
|
|
BOOST_TEST(!(px < px));
|
|
BOOST_TEST(!(py < py));
|
|
|
|
BOOST_TEST(!(px < py || py < px));
|
|
BOOST_TEST(!(px < pz || pz < px));
|
|
BOOST_TEST(!(py < pz || pz < py));
|
|
|
|
BOOST_TEST(!(pvx < pvy || pvy < pvx));
|
|
BOOST_TEST(!(pvx < pvz || pvz < pvx));
|
|
BOOST_TEST(!(pvy < pvz || pvz < pvy));
|
|
}
|
|
}
|
|
|
|
} // namespace n_comparison
|
|
|
|
namespace n_lock
|
|
{
|
|
|
|
void test()
|
|
{
|
|
}
|
|
|
|
} // namespace n_lock
|
|
|
|
namespace n_map
|
|
{
|
|
|
|
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::weak_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::weak_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
|
|
{
|
|
BOOST_TEST(i->first.use_count() == i->second);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace n_map
|
|
|
|
int main()
|
|
{
|
|
n_element_type::test();
|
|
n_constructors::test();
|
|
n_assignment::test();
|
|
n_reset::test();
|
|
n_use_count::test();
|
|
n_swap::test();
|
|
n_comparison::test();
|
|
n_lock::test();
|
|
|
|
n_map::test();
|
|
|
|
return boost::report_errors();
|
|
}
|
|
|
|
class incomplete
|
|
{
|
|
};
|
|
|
|
boost::shared_ptr<incomplete> create_incomplete()
|
|
{
|
|
boost::shared_ptr<incomplete> px(new incomplete);
|
|
return px;
|
|
}
|