---

test-smart_pointer.cc

/*
*  Name:      test-smart_pointer.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for smart pointer
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <memory>
#include <mpcl/memory/alloc_smart_pointer.hh>
#include <mpcl/memory/smart_pointer.hh>
#include <mpcl/util/general-functions.hh>
#include <mpcl/test.h>
#include <vector>


using mpcl::memory::TAllocSmartPointer;
using mpcl::memory::TSmartPointer;
using std::allocator;
using std::vector;


//
//  L O C A L   T Y P E S
//

class TMother
{

  protected:

    int   iMother;


  public:

    TMother (void) :
      iMother (0)  {}

};  // TMother


class TFather
{

  protected:

    int&   riValue;

    
  public:

    TFather (int& riVALUE) :
      riValue (riVALUE)
    {
      riValue += 1;
    }
    
    virtual ~TFather (void)
    {
      riValue -= 1;
    }

    virtual bool isFather (void) const
    {
      return true;
    }

};  // class TFather


class TSon       :
  public TMother ,
  public TFather
{

  public:

    int   iAnotherValue;


  public:

    TSon (int& riVALUE)       :
      TMother       ()        ,
      TFather       (riVALUE) ,
      iAnotherValue (0)
    {
      riValue += 10;
    }
    
    ~TSon (void)
    {
      riValue -= 10;
    }

    bool isFather (void) const
    {
      return false;
    }

};  // class TSon


//
//  L O C A L   V A R I A B L E S
//

// <DELETE>
// static int                                           _iValue;
// static TFather*                                      _ptNewFather;
// static allocator<TFather>                       _tFatherAllocator;
// static TAllocSmartPointer<TFather>             _qtFather (_tFatherAllocator);
// </DELETE>
static vector<int*>                       _tIntArray;
static vector<TSmartPointer<int> >        _tIntSmartPointerVector;
static vector<TAllocSmartPointer<int> >   _tIntAllocSmartPointerVector;


//
//  L O C A L   F U N C T I O N S
//

static void _Insert (int* piSOURCE)
{
  _tIntArray.push_back (piSOURCE);
}


static void _InsertAllocSmartPointer (int* piSOURCE)
{
  _tIntAllocSmartPointerVector.push_back (TAllocSmartPointer<int> (piSOURCE));
}


static void _InsertSmartPointer (int* piSOURCE)
{
  _tIntSmartPointerVector.push_back (TSmartPointer<int> (piSOURCE));
}


static TFather* _ReturnPointerToFather (TFather* ptFATHER)
{
  return ptFATHER;
}


static TAllocSmartPointer<TFather>
_ReturnAllocSmartPointerToFather (TAllocSmartPointer<TFather>& rqtFATHER)
{

// <FIXME>
//   static allocator<int>                 _tIntAllocator;
//   static int                                 _iValue (0);
//   static int*                                _piNewValue (_tIntAllocator.allocate (1));
//   static TAllocSmartPointer<TFather>   _qtFather (new (_piNewValue) TFather (_iValue));
// </FIXME>
// <DEBUG>
//   if ( !_iValue )
//   {
//     std::cerr << "#_ReturnAllocSmartPointerToFather: new (" << _ptNewFather << ") TFather (" << _iValue << ")" << std::endl;
//     _iValue = 1;
//   }
// </DEBUG>
  return rqtFATHER;

}  // _ReturnAllocSmartPointerToFather()


static TSmartPointer<TFather>
_ReturnSmartPointerToFather (TSmartPointer<TFather>& rqtFATHER)
{
  return rqtFATHER;
}


static TAllocSmartPointer<TFather>&
_ReturnAllocSmartPointerReferenceToFather (TAllocSmartPointer<TFather>& rqtFATHER)
{

// <DELETE>
//   static allocator<TFather>             _tFatherAllocator;
//   static int                                 _iValue (0);
//   static TFather*                            _ptNewFather (_tFatherAllocator.allocate (1));
//   static TAllocSmartPointer<TFather>   _qtFather ((_tFatherAllocator.construct (_ptNewFather, _iValue), _ptNewFather), _tFatherAllocator);
// </DELETE>
// <DEBUG>
//   if ( !_iValue )
//   {
//     std::cerr << "#_ReturnAllocSmartPointerReferenceToFather: new (" << _ptNewFather << ") TFather (" << _iValue << ")" << std::endl;
//     _iValue = 1;
//   }  
// </DEBUG>
  return rqtFATHER;

}  // _ReturnAllocSmartPointerReferenceToFather()


static TSmartPointer<TFather>&
_ReturnSmartPointerReferenceToFather (TSmartPointer<TFather>& rqtFATHER)
{
  return rqtFATHER;
}


static int _TestAllocators (void)
{

  TEST_INIT ("tests for class 'TAllocSmartPointer'");

  TAllocSmartPointer<int, allocator>   qtInt;
  allocator<int>                       tIntAllocator;
  int*                                 ptInt = tIntAllocator.allocate (1);

  tIntAllocator.construct (ptInt, 1);
  qtInt = ptInt;
  TEST_NUMBERS (1, *qtInt);
  qtInt = NULL;
  
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestAllocators()


static int _TestAssigns (void)
{

  typedef
    TSmartPointer<int>
    QTInt;

  typedef
    TSmartPointer<const int>
    QKTInt;

  TEST_INIT ("tests for assigns");

  int   iValue = 100;

  //
  //  Test for destructors and assigns.
  //
  {
    TSmartPointer<TFather>   qtFather;
    TSmartPointer<TSon>      qtSon1;
    TSmartPointer<TSon>      qtSon2;
    TSmartPointer<int>       qiInt;
    TSon*                    ptSon = NULL;

    //
    //  Creates a new TFather instance:
    //
    //    iValue += 1;
    //    ( 101 == iValue );
    //
    qtFather = new TFather (iValue);
    TEST_NUMBERS (101, iValue);

    //
    //  Creates a new TSon instance:
    //
    //    iValue += 1;
    //    iValue += 10;
    //    ( 112 == iValue );
    //
    qtSon1 = new TSon (iValue);
    TEST_NUMBERS (112,   iValue);
    TEST_NUMBERS (true,  qtFather->isFather());
    TEST_NUMBERS (false, qtSon1->isFather());

    //
    //  Tries  to mutate a  TFather instance  into a  TSon instance.  This test
    //  ensures that there is no success.
    //
    try
    {
      qtFather.dynamicCast<TSon*>();
      TEST_FAIL;
    }
    catch (const mpcl::TConstraintException&)
    {
      TEST_PASS;
    }

    //
    //  Destroys the TFather instance (in qtFather):
    //
    //    iValue -= 1;
    //    ( 111 == iValue );
    //
    qtFather = NULL;
    TEST_NUMBERS (111, iValue);

    //
    //  Copies qtSon1 on qtSon1, so there is no change.
    //
    qtSon1 = qtSon1;
    TEST_NUMBERS (111,   iValue);
    TEST_NUMBERS (false, qtSon1->isFather());
    TEST_NUMBERS (1,     qtSon1.references());
    TEST_NUMBERS (true,  ( qtSon1 == qtSon1 ));

    //
    //  Creates a new TSon instance:
    //
    //    iValue += 1;
    //    iValue += 10;
    //    ( 122 == iValue );
    //
    qtSon2 = new TSon (iValue);
    TEST_NUMBERS (122, iValue);

    //
    //  Does a dynamic cast, so there is no change.
    //
    ptSon = qtSon1.dynamicCast<TSon*>();
    TEST_NUMBERS (122,   iValue);
    TEST_NUMBERS (false, ptSon->isFather());
    TEST_NUMBERS (false, qtSon2->isFather());
    TEST_NUMBERS (1,     qtSon2.references());
  }
  TEST_NUMBERS (100, iValue);

  //
  //  Tests conversion constructors.
  //
  {
    QTInt    qtInt;
    QKTInt   qktInt;

    qtInt  = new int (1);
    qktInt = new int (2);
    TEST_NUMBERS (*qtInt,                       1);
    TEST_NUMBERS (*qktInt,                      2);
    TEST_NUMBERS ((*QKTInt (qtInt)),            1);
    TEST_NUMBERS ((*QKTInt (qktInt)),           2);
    TEST_NUMBERS (QKTInt (qtInt).references(),  2);
    TEST_NUMBERS (QKTInt (qktInt).references(), 2);
    TEST_NUMBERS (true,                         ( qktInt.constCast<int*>() != NULL ));
    {
      QTInt   qtInnerInt;
      
      qtInnerInt = new int (3);
      qtInt      = qtInnerInt;
      TEST_NUMBERS (*qtInt,                  3);
      TEST_NUMBERS (*qtInnerInt,             3);
      TEST_NUMBERS (qtInt.references(),      2);
      TEST_NUMBERS (qtInnerInt.references(), 2);
      TEST_NUMBERS (qtInnerInt,              qtInt);
    }
    TEST_NUMBERS (*qtInt,             3);
    TEST_NUMBERS (qtInt.references(), 1);
    qtInt = new int (4);
    TEST_NUMBERS (*qtInt,             4);
    TEST_NUMBERS (qtInt.references(), 1);
  }
  
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestAssigns()


static int _TestBenchmarks (void)
{

  vector<int*>::iterator        I;
  int*                          piNewInt;
  TFather*                      ptAllocFather;
  TAllocSmartPointer<TFather>   qtAllocFather;
  TSmartPointer<TFather>        qtFather;
  allocator<TFather>            tFatherAllocator;
  allocator<int>                tIntAllocator;
  int                           iValue   = 0;
  TFather*                      ptFather = new TFather (iValue);

  TEST_INIT ("benchmarks for smart pointers insertion/returning");

  //
  //  Initializes common data.
  //
  ptAllocFather = tFatherAllocator.allocate (1);
  tFatherAllocator.construct (ptAllocFather, iValue);
  qtAllocFather = ptAllocFather;
  qtFather      = new TFather (iValue);

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 100000 ) ;++J)
  {
    _Insert (new int (J));
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("C++ standard pointer insertion");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 100000 ) ;++J)
  {
    _InsertSmartPointer (new int (J));
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TSmartPointer insertion");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 100000 ) ;++J)
  {
    piNewInt = tIntAllocator.allocate (1);
    tIntAllocator.construct (piNewInt, J);
    _InsertAllocSmartPointer (piNewInt);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TAllocSmartPointer insertion");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 400000 ) ;++J)
  {
    _ReturnPointerToFather (ptFather);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("C++ standard pointer returning");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 400000 ) ;++J)
  {
    _ReturnSmartPointerToFather (qtFather);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TSmartPointer returning");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 400000 ) ;++J)
  {
    _ReturnAllocSmartPointerToFather (qtAllocFather);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TAllocSmartPointer returning");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 400000 ) ;++J)
  {
    _ReturnSmartPointerReferenceToFather (qtFather);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TSmartPointer reference returning");

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 400000 ) ;++J)
  {
    _ReturnAllocSmartPointerReferenceToFather (qtAllocFather);
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TAllocSmartPointer reference returning");

  //
  //  Clean not smart-pointer managed objects.
  //
  delete ptFather;
  for (I = _tIntArray.begin(); ( I != _tIntArray.end() ) ;++I)
  {
    delete *I;
  }

  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestBenchmarks()


static int _TestCastings (void)
{

  int                            iValue;
  TFather*                       ptFather;
  TSon*                          ptSon;
  TSmartPointer<TFather>   qtFather (new TFather (iValue));
  TSmartPointer<TFather>   qtSon (new TSon (iValue));
  TSmartPointer<TFather>   qtAnotherFather (qtFather);
  
  TEST_INIT ("test for castings");
  TEST_NUMBERS (true, qtAnotherFather->isFather());
  qtAnotherFather = qtSon;
  TEST_NUMBERS (false, qtAnotherFather->isFather());

  //
  //  Converts from a TFather instance  to a  TSon instance which must throw an
  //  exception.
  //
  try
  {
    //
    //  Converts from TFather* to TSon* (error).
    //
    qtAnotherFather = qtFather;
    ptSon           = qtAnotherFather.dynamicCast<TSon*>();
    TEST_FAIL;
  }
  catch (const mpcl::TConstraintException&)
  {
    TEST_PASS;
  }

  try
  {
    //
    //  Converts a TSon instance to a TFather instance, which is ok.
    //
    qtAnotherFather = qtSon;
    ptFather        = qtAnotherFather.get();
    TEST_PASS;
  }
  catch (const mpcl::TConstraintException&)
  {
    TEST_FAIL;
  }

  //
  //  Benchmarks old castings.
  //
  TEST_START_WATCH;
  for (size_t J = 0; ( J < 1000000 ) ;++J)
  {
    ptSon = (TSon*) ptFather;
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("C++ standard casting");

  //
  //  Benchmarks down-castings.
  //
  TEST_START_WATCH;
  qtAnotherFather = qtSon;
  for (size_t J = 0; ( J < 1000000 ) ;++J)
  {
    ptSon = qtAnotherFather.dynamicCast<TSon*>();
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("TSmartPointer casting");
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestCastings()


static int _TestContainers (void)
{

  TEST_INIT ("test for smart pointers and containers");

  vector<TSmartPointer<TFather> >   tFatherSmartPointerVector1;
  vector<TSmartPointer<TFather> >   tFatherSmartPointerVector2;
  int                               iValue = 0;

  TEST_START_WATCH;
  for (size_t J = 0; ( J < 100000 ) ;++J)
  {
    tFatherSmartPointerVector1.push_back (TSmartPointer<TFather> (new TFather (iValue)));
    tFatherSmartPointerVector2.push_back (TSmartPointer<TFather> (tFatherSmartPointerVector1.back()));
    tFatherSmartPointerVector1.push_back (TSmartPointer<TFather> (new TSon (iValue)));
    tFatherSmartPointerVector2.push_back (TSmartPointer<TFather> (tFatherSmartPointerVector1.back()));
  }
  TEST_STOP_WATCH;
  TEST_DISPLAY_WATCH ("container with 400.000 items");
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestContainers()


static int _TestCopyConstructors (TSmartPointer<int> qiSOURCE, int iREAL_VALUE)
{

  TEST_INIT ("test for copy constructors");
  TEST_NUMBERS (iREAL_VALUE, *qiSOURCE);
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // _TestCopyConstructors()


int main (void)
{

  TEST_INIT ("tests for class 'TSmartPointer'");

  TSmartPointer<int>   qiAnotherInteger;
  TSmartPointer<int>   qiOtherInteger;
  TSmartPointer<int>   qiMyInteger (new int (10));

//   _iValue      = 0;
//   _ptNewFather = _tFatherAllocator.allocate (1);
//   _tFatherAllocator.construct (_ptNewFather, _iValue);
//   _qtFather = _ptNewFather;
// // <DEBUG>
//   std::cerr << "#main: _iValue = " << _iValue << std::endl;
// //   std::cerr << "#main: qiMyInteger is bound to " << qiMyInteger.get() << std::endl;
//   std::cerr << "#main: construct (" << _ptNewFather << ")" << std::endl;
//   std::cerr << "#main: construct (" << _qtFather.get() << ")" << std::endl;
// // </DEBUG>

//   _qtFather    = NULL;
//   _ptNewFather = _tFatherAllocator.allocate (1);
//   _tFatherAllocator.construct (_ptNewFather, _iValue);
//   _qtFather = _ptNewFather;
// // <DEBUG>
//   std::cerr << "#main: _iValue = " << _iValue << std::endl;
// //   std::cerr << "#main: qiMyInteger is bound to " << qiMyInteger.get() << std::endl;
//   std::cerr << "#main: construct (" << _ptNewFather << ")" << std::endl;
//   std::cerr << "#main: construct (" << _qtFather.get() << ")" << std::endl;
// // </DEBUG>

//   _qtFather    = NULL;
//   _ptNewFather = _tFatherAllocator.allocate (1);
//   _tFatherAllocator.construct (_ptNewFather, _iValue);
//   _qtFather = _ptNewFather;
// // <DEBUG>
//   std::cerr << "#main: _iValue = " << _iValue << std::endl;
// //   std::cerr << "#main: qiMyInteger is bound to " << qiMyInteger.get() << std::endl;
//   std::cerr << "#main: construct (" << _ptNewFather << ")" << std::endl;
//   std::cerr << "#main: construct (" << _qtFather.get() << ")" << std::endl;
// // </DEBUG>

  TEST_NUMBERS (10, *qiMyInteger);
  TEST_NUMBERS (1,  qiMyInteger.references());
  *qiMyInteger = 11;
  TEST_NUMBERS (11, *qiMyInteger);
  qiOtherInteger   = qiMyInteger;
  qiAnotherInteger = qiOtherInteger;
  TEST_NUMBERS (3,  qiMyInteger.references());
  TEST_NUMBERS (11, *qiMyInteger);
  TEST_NUMBERS (11, *qiOtherInteger);
  TEST_NUMBERS (11, *qiAnotherInteger);

  *qiAnotherInteger = 9;
  TEST_NUMBERS (9,           *qiMyInteger);
  TEST_NUMBERS (9,           *qiOtherInteger);
  TEST_NUMBERS (9,           *qiAnotherInteger);
  TEST_NUMBERS (qiMyInteger, qiMyInteger);
  TEST_NUMBERS (qiMyInteger, qiOtherInteger);
  TEST_NUMBERS (qiMyInteger, qiAnotherInteger);
  TEST_NUMBERS (3,           qiMyInteger.references());

  qiOtherInteger = new int (100);
  TEST_NUMBERS (9,   *qiMyInteger);
  TEST_NUMBERS (100, *qiOtherInteger);
  TEST_NUMBERS (9,   *qiAnotherInteger);
  TEST_NUMBERS (2,   qiMyInteger.references());

  qiAnotherInteger = qiOtherInteger;
  TEST_NUMBERS (9,              *qiMyInteger);
  TEST_NUMBERS (100,            *qiOtherInteger);
  TEST_NUMBERS (100,            *qiAnotherInteger);
  TEST_NUMBERS (qiMyInteger,    qiMyInteger);
  TEST_NUMBERS (qiOtherInteger, qiOtherInteger);
  TEST_NUMBERS (qiOtherInteger, qiAnotherInteger);
  TEST_NUMBERS (1,              qiMyInteger.references());
  TEST_NUMBERS (2,              qiOtherInteger.references());

  *qiAnotherInteger = 101;
  TEST_NUMBERS (  9, *qiMyInteger);
  TEST_NUMBERS (101, *qiOtherInteger);
  TEST_NUMBERS (101, *qiAnotherInteger);
  TEST_NUMBERS (qiMyInteger,    qiMyInteger);
  TEST_NUMBERS (qiOtherInteger, qiOtherInteger);
  TEST_NUMBERS (qiOtherInteger, qiAnotherInteger);

  qiMyInteger = new int (1000);
  qiMyInteger = new int (1001);
  qiMyInteger = new int (1002);
  TEST_NUMBERS (1002,           *qiMyInteger);
  TEST_NUMBERS (101,            *qiOtherInteger);
  TEST_NUMBERS (101,            *qiAnotherInteger);
  TEST_NUMBERS (qiMyInteger,    qiMyInteger);
  TEST_NUMBERS (qiOtherInteger, qiOtherInteger);
  TEST_NUMBERS (qiOtherInteger, qiAnotherInteger);
  TEST_NUMBERS (1,              qiMyInteger.references());
 
  TEST_FUNCTION (_TestAllocators());
  TEST_FUNCTION (_TestAssigns());
  TEST_FUNCTION (_TestBenchmarks());
  TEST_FUNCTION (_TestCastings());
  TEST_FUNCTION (_TestContainers());
  TEST_FUNCTION (_TestCopyConstructors (qiMyInteger,      1002));
  TEST_FUNCTION (_TestCopyConstructors (qiOtherInteger,   101));
  TEST_FUNCTION (_TestCopyConstructors (qiAnotherInteger, 101));

  qiMyInteger = NULL;
  TEST_NUMBERS (true,  !qiMyInteger);
  TEST_NUMBERS (false, !qiAnotherInteger);

  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // main()

---