weak_ptr_test.cpp

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);