EQ2EMu/EQ2/source/depends/boost_1_72_0/libs/smart_ptr/test/weak_ptr_test.cpp

#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;
}