boostorg/smart_ptr
1
0
Fork 1
mirror of https://github.com/boostorg/smart_ptr.git synced 2025-10-31 15:51:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
694e6822acf32823f7b576f62bdd68486bc27d70
smart_ptr/test/weak_ptr_test.cpp
Peter Dimov 694e6822ac Remove obsolete uses of BOOST_MSVC
2024-09-24 18:25:13 +03:00

1351 lines
31 KiB
C++
Raw Blame History

//
// 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/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/config.hpp>
#include <boost/core/lightweight_test.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;
}
Reference in New Issue View Git Blame Copy Permalink