// -*- C++ -*-

/***************************************************************************

 *

 * 2.smartptr.weak.cpp - test exercising class template weak_ptr

 *

 * $Id: 2.smartptr.weak.cpp 354223 2005-12-05 23:29:59Z sebor $

 *

 ***************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed under the Apache License, Version 2.0 (the

 * "License");  you may  not use this file except  in compliance with the

 * License.    You    may   obtain   a   copy   of    the   License    at

 * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

 * applicable law  or agreed to  in writing,  software  distributed under

 * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

 * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

 * for the specific language governing permissions  and limitations under

 * the License.

 *

 **************************************************************************/

#include <cassert>

#include <tr1/_smartptr.h>

#include<rw/_exception.h>

#include <driver.h>

#include"std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

int failures=0;

/**************************************************************************/

template <class T>

struct Base

{

    static int n_dtors;

    virtual ~Base () {

        ++n_dtors;

    }

};

template <class T>

int Base<T>::n_dtors;

template <class T>

struct Derived: Base<T>

{

    static int n_dtors;

    virtual ~Derived () {

        ++n_dtors;

    }

};

template <class T>

int Derived<T>::n_dtors;

template <class T>

struct Derived2: Base<T>

{

    static int n_dtors;

    virtual ~Derived2 () {

        ++n_dtors;

    }

};

template <class T>

int Derived2<T>::n_dtors;

template <class T>

struct Deleter

{

    static int n_def_ctors;

    static int n_cpy_ctors;

    static int n_dtors;

    static int n_funcalls;

    Deleter () {

        ++n_def_ctors;

    }

    Deleter (const Deleter&) {

        ++n_cpy_ctors;

    }

    virtual ~Deleter () {

        ++n_dtors;

    }

    void operator()(T *p) {

        ++n_funcalls;

        delete p;

    }

private:

    void operator=(Deleter&);   // not defined

};

template <class T>

int Deleter<T>::n_def_ctors;

template <class T>

int Deleter<T>::n_cpy_ctors;

template <class T>

int Deleter<T>::n_dtors;

template <class T>

int Deleter<T>::n_funcalls;

/**************************************************************************/

static void

test_ctor ()

{

    rw_info (0, "tr.util.smartptr.weak.cons", 0,

             "weak_ptr constructors");

    {   // default ctor

        std::tr1::weak_ptr<char> weak;

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0!=weak.use_count ())

          {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing");

          }

    }

    {   // shared_ptr converting ctor

        std::tr1::shared_ptr<char> shared;

        std::tr1::weak_ptr<char>   weak (shared);

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0 != weak.use_count ())

          {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing");

          }

    }

    {   // shared_ptr converting ctor

        std::tr1::shared_ptr<char> shared;

        std::tr1::weak_ptr<void>   weak (shared);

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0!=weak.use_count ())

          {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing");

          }

    }

    {   // shared_ptr converting ctor

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared (p);

        std::tr1::weak_ptr<int>   weak (shared);

        rw_assert (shared.use_count () == weak.use_count (), 0, __LINE__, "");

        if(shared.use_count () != weak.use_count ())

          {

            failures++;

            std_log(LOG_FILENAME_LINE,"Reason:Failing");

          }

    }

    {   // shared_ptr converting ctor

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared0 (p);

        std::tr1::shared_ptr<int> shared1 (shared0);

        std::tr1::weak_ptr<int>   weak (shared1);

        rw_assert (shared1.use_count () == weak.use_count (), 0, __LINE__, "");

        if(shared1.use_count () != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {   // shared_ptr converting ctor

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared (p);

        std::tr1::weak_ptr<void>  weak (shared);

        shared.reset ();

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0 != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {   // shared_ptr converting ctor

        Derived<int>* const p = new Derived<int>;

        std::tr1::shared_ptr<Derived<int> > shared (p);

        std::tr1::weak_ptr<Base<int> >      weak (shared);

        shared.reset ();

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0 != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

}

/**************************************************************************/

static void

test_copy_ctor ()

{

    rw_info (0, "tr.util.smartptr.weak.copy", 0,

             "weak_ptr copy constructors");

    {

        // weak_ptr (const weak_ptr&)

        std::tr1::weak_ptr<void> weak;

        std::tr1::weak_ptr<void> copy (weak);

        rw_assert (0 == weak.use_count (), 0, __LINE__, "");

        if(0 != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (0 == copy.use_count (), 0, __LINE__, "");

        if(0 != copy.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // weak_ptr (const weak_ptr&)

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared (p);

        std::tr1::weak_ptr<int>   weak (shared);

        std::tr1::weak_ptr<int>   copy (weak);

        rw_assert (weak.use_count () == shared.use_count (), 0, __LINE__, "");

        if(weak.use_count () != shared.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // weak_ptr (const weak_ptr&)

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared0 (p);

        std::tr1::shared_ptr<int> shared1 (shared0);

        std::tr1::weak_ptr<int>   weak (shared1);

        std::tr1::weak_ptr<int>   copy (weak);

        rw_assert (weak.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(weak.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // weak_ptr (const weak_ptr&)

        int* const p = new int (__LINE__);

        std::tr1::shared_ptr<int> shared0 (p);

        std::tr1::shared_ptr<int> shared1 (shared0);

        std::tr1::weak_ptr<int>   weak (shared1);

        std::tr1::weak_ptr<void>  copy (weak);

        rw_assert (weak.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(weak.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // weak_ptr (const weak_ptr&)

        Derived<int>* const p = new Derived<int>;

        std::tr1::shared_ptr<Derived<int> > shared0 (p);

        std::tr1::shared_ptr<Derived<int> > shared1 (shared0);

        std::tr1::weak_ptr<Derived<int> >   weak (shared1);

        std::tr1::weak_ptr<Base<int> >      copy (weak);

        rw_assert (weak.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(weak.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared1.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared1.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        shared1.reset ();

        rw_assert (copy.use_count () == weak.use_count (), 0, __LINE__, "");

        if(copy.use_count () != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared0.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared0.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        shared0.reset ();

        rw_assert (copy.use_count () == weak.use_count (), 0, __LINE__, "");

        if(copy.use_count () != weak.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (copy.use_count () == shared0.use_count (), 0, __LINE__, "");

        if(copy.use_count () != shared0.use_count ())

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

}

/**************************************************************************/

static void

test_dtor ()

{

    rw_info (0, "tr.util.smartptr.weak.dest", 0,

             "weak_ptr destructor");

    {

        // ~weak_ptr()

        const int base_dtors = Base<int>::n_dtors;

        {

            std::tr1::weak_ptr<Base<int> > weak;

        }

        rw_assert (base_dtors == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // ~weak_ptr()

        const int base_dtors = Base<int>::n_dtors;

        Base<int>* const p = new Base<int>;

        std::tr1::shared_ptr<Base<int> > shared (p);

        {

            std::tr1::weak_ptr<Base<int> > weak (shared);

        }

        rw_assert (base_dtors == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // ~weak_ptr()

        const int base_dtors    = Base<int>::n_dtors;

        const int derived_dtors = Derived<int>::n_dtors;

        Derived<int>* const p = new Derived<int>;

        std::tr1::shared_ptr<Derived<int> > shared (p);

        {

            std::tr1::weak_ptr<Base<int> > weak (shared);

        }

        rw_assert (base_dtors    == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors   != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (derived_dtors == Derived<int>::n_dtors, 0, __LINE__, "");

        if(derived_dtors != Derived<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // ~weak_ptr()

        const int base_dtors    = Base<int>::n_dtors;

        const int derived_dtors = Derived<int>::n_dtors;

        Derived<int>* const p = new Derived<int>;

        std::tr1::shared_ptr<Derived<int> > shared (p);

        {

            std::tr1::weak_ptr<Base<int> > weak (shared);

            std::tr1::weak_ptr<Base<int> > copy (shared);

        }

        rw_assert (base_dtors    == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors   != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (derived_dtors == Derived<int>::n_dtors, 0, __LINE__, "");

        if(derived_dtors != Derived<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // ~weak_ptr()

        const int base_dtors    = Base<int>::n_dtors;

        const int derived_dtors = Derived<int>::n_dtors;

        Derived<int>* const p = new Derived<int>;

        std::tr1::shared_ptr<Derived<int> > shared (p);

        {

            std::tr1::weak_ptr<Base<int> > weak (shared);

            shared.reset ();

        }

        rw_assert (base_dtors + 1    == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors + 1    != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (derived_dtors + 1 == Derived<int>::n_dtors, 0, __LINE__, "");

        if(derived_dtors + 1 != Derived<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

    {

        // ~weak_ptr()

        const int base_dtors    = Base<int>::n_dtors;

        const int derived_dtors = Derived<int>::n_dtors;

        std::tr1::weak_ptr<Derived<int> > weak;

        {

            Derived<int>* const p = new Derived<int>;

            std::tr1::shared_ptr<Derived<int> > shared (p);

            weak = shared;

        }

        rw_assert (base_dtors + 1    == Base<int>::n_dtors, 0, __LINE__, "");

        if(base_dtors + 1   != Base<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

        rw_assert (derived_dtors + 1 == Derived<int>::n_dtors, 0, __LINE__, "");

        if(derived_dtors + 1 != Derived<int>::n_dtors)

        {

         failures++;

         std_log(LOG_FILENAME_LINE,"Reason: Failing");

         }

    }

}

/**************************************************************************/

static void