TestSharedPtr.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/**
   @file TestShardesPtr.cpp
   @relates SharedPtr
   @brief Test usage of shared pointers
   @ingroup g_tests
   @author woelk
*/

#include <Base/Common/SharedPtr.hh>

#include <iostream>
#include <vector>

using namespace BIAS;
using namespace std;


const bool verbose = false;

/** \cond POORLY_NAMED_TEST_CLASSES **/
/* some parent*/
class parent 
{
public: 
  parent() : data(0.0) {}
  parent(const double d) : data(d) {}
  virtual ~parent() {}
  double data;
  virtual void printData()
  { cout << "parent::printData: "<<data<<endl; }
};

/* comse child */
class child : public parent
{
public:
  child() : parent() {}
  child(const double d) : parent(d) {}
  virtual ~child() {}
  virtual void printData()
  { cout << "child::printData: "<<data<<endl; }
};


ostream& operator<<(ostream& os, const parent & f)
{ os << "parent = "<<f.data; return os; }


ostream& operator<<(ostream& os, const child & f)
{ os << "child = "<<f.data; return os; }



// compile tests
void TestConstructors()
{
  SharedPtr<parent> empty;
  SharedPtr<parent> empty2(empty);
  SharedPtr<parent> filled(new parent);
  SharedPtr<parent> filled2(filled);
  SharedPtr<parent> equal = filled;

#ifdef TEST_COMPILE_TIME_ERROR_Delete
  delete equal; // does not compile, this should never be possible
#endif
}


// compile tests
void TestAccess()
{
  const double value(2.0);
  SharedPtr<parent> sp(new parent(value));
  if ((*sp).data != value) { BIASABORT; }
  if (sp->data != value) { BIASABORT; }
  if (verbose) {
    cout << "Get: "<<Get(sp)<<endl;
    cout << "RefCount: "<<RefCount(sp)<<endl;
  }

  SharedPtr<int> foo(NULL);
  if (verbose) cout << foo << "\t" << foo << "  rc "<<RefCount(foo)<<endl;
  foo = SharedPtr<int>(new int);
  if (verbose) cout << foo << "\t" << *foo << "  rc "<<RefCount(foo)<<endl;
  *foo += 2;
  if (verbose) cout << foo << "\t" << *foo << "  rc "<<RefCount(foo)<<endl;
}


// compile tests
void TestConversionToBool()
{
  // create two SharedPtr , one filled and the other empty
  SharedPtr<parent> parent1, parent2(new parent);
  
  // test if(ptr)
  if (parent1){ BIASABORT; }
  if (parent2){} else { BIASABORT; }

  // test if (!ptr)
  if (!parent1){} else { BIASABORT; }
  if (!parent2){ BIASABORT; }
}


void TestComparison()
{
  parent *raw_1 = new parent(1.0);
  parent *raw_2 = new parent(2.0);

  child *raw_child = new child(3.0);

  SharedPtr<parent> shared_1(raw_1), shared_2(raw_2);
  SharedPtr<parent> shared_1b(shared_1), shared_2b(shared_2);
  SharedPtr<parent> shared_parent_from_raw_child(raw_child);
  
  SharedPtr<int> shared_int(new int);

  // comparison of shared pointers
  if (shared_1 == shared_1b) {} else { BIASABORT; }
  if (shared_1 != shared_1b) { BIASABORT; } 
  if (shared_1 == shared_2) { BIASABORT; }
  if (shared_1 != shared_2) {} else { BIASABORT; } 
  
  // comparison to raw pointers is done on raw pointer basis
  if (raw_1 == Get(shared_1)) {} else { BIASABORT; } 
  if (raw_1 != Get(shared_1)) { BIASABORT; }
  
  // comparison between apples and oranges, compiler error
#ifdef TEST_COMPILE_TIME_ERROR_CompareApplesAnOrangesEqual
  if (shared_int == shared_1) { BIASABORT; }
#endif
#ifdef TEST_COMPILE_TIME_ERROR_CompareApplesAnOrangesNotEqual
  if (shared_int != shared_1) {} else { BIASABORT; }
#endif
  
  // no need to cleanup, the shared pointer take care of it 
}


void TestSorting()
{
  SharedPtr<int> ptr1(new int(1));
  SharedPtr<int> ptr2(new int(2));
  
  // comparing the pointers
  if (Get(ptr1)==Get(ptr2)){ BIASABORT; }
  if (Get(ptr1)<Get(ptr2)){
    if (!(ptr1<ptr2)) { BIASABORT; }
    if (ptr1>=ptr2) { BIASABORT; }
  } else {
    if (!(ptr1>ptr2)) { BIASABORT; }
    if (ptr1<=ptr2) { BIASABORT; }
  }

  // comparing the values
  if (*ptr1>=*ptr2) { BIASABORT; }
}


void TestReferenceCounting()
{
  SharedPtr<int> ptr1;
  // new scope to test reference counting
  {
    SharedPtr<int> ptr2(new int);
    if (verbose) cout << "reference count is "<<RefCount(ptr2)<<" expected 1\n";
    if (RefCount(ptr2)!=1u) { BIASABORT; }
    // assign reference ptr2 to ptr1 should increas ereference counter 
    ptr1 = ptr2;
    if (RefCount(ptr2)!=2u) { BIASABORT; }
    if (RefCount(ptr1)!=2u) { BIASABORT; }
    // copy constructor should increase reference counter
    SharedPtr<int> ptr3(ptr1);
    if (RefCount(ptr2)!=3u) { BIASABORT; }
    if (RefCount(ptr1)!=3u) { BIASABORT; }
  }
  // ptr2 and ptr 3 have left their scope and desctructors should have been 
  // executed, resulting in a reference count of 1
  if (RefCount(ptr1)!=1u) { BIASABORT; }
}



void TestStream()
{
  SharedPtr<int> ptr1(new int(2));
  cout << "ptr1: "<<ptr1<<" = "<<*ptr1<<endl;
  SharedPtr<int> ptr2;
  cout << "ptr2: "<<ptr2<<endl;
}


void TestConst()
{
  // can do anything with variabel pointer to variable value
  SharedPtr<int> var(new int(2));
  *var = 3;
  var =  SharedPtr<int>(new int(5));
  
  // variable pointer to const value
  SharedPtr<const int> var_ptr_2_const(new int(2));
  var_ptr_2_const =  SharedPtr<int>(new int(7)); // allowed, can change ptr
#ifdef TEST_COMPILE_TIME_ERROR_DereferencePtr2Const
  // dereferencing a ptr to const is not allowed
  *var_ptr_2_const = 8; // compiler error, not allowed
#endif

  // const pointer to variable value
  const SharedPtr<int> const_ptr_2_var(new int(2));
#ifdef TEST_COMPILE_TIME_ERROR_InitFromGenericPointer
  // initializiation without explicit cast to SharedPtr is not allowed
  const_ptr_2_var = new int(7); // compiler error, not allowed
#endif
  *const_ptr_2_var = 8; // allowed, can change value

  // const pointer to const value
  const SharedPtr<const int> const_ptr_2_const(new int(2));
#ifdef TEST_COMPILE_TIME_ERROR_InitFromGenericPointerConst
  // assignemnt of const ptr to const value only allowed in constructor
  const_ptr_2_const = new int(6); // compiler error, not allowed
#endif
#ifdef TEST_COMPILE_TIME_ERROR_DereferenceConstPtr2Const
  // cannot dereference conmst ptr to const value
  *const_ptr_2_const = 7; // compiler error, not allowed
#endif
  
  // assignment of a pointer to a changeable to a pointer to const
  SharedPtr<const int> foo(var);
  SharedPtr<const int> foo2 = var;

#ifdef TEST_COMPILE_TIME_ERROR_ConstCast
  // compiler error, try to cast away constness
  SharedPtr<int> foo2(var_ptr_2_const); 
#endif
}


void TestSTL()
{
  std::vector<SharedPtr<int> > vec(1);
  SharedPtr<int> foo = SharedPtr<int>(new int(3));
  vec.push_back(foo);
  vec.push_back(foo);
  if (verbose) {
    for (unsigned i=0; i<vec.size(); i++){
      cout << i << ": "<<(vec[i])<<"\tref count: "<<RefCount(vec[i])<<endl;
    }
  }
  std::vector<SharedPtr<int> > vec2(5, foo);
  foo = SharedPtr<int>(NULL);
  if (verbose) {
    for (unsigned i=0; i<vec2.size(); i++){
      cout << i << ": "<<(vec2[i])<<"\tref count: "<<RefCount(vec2[i])<<endl;
    }
  }
}


/* needed for TestCast */
class Father { 
public: 
  virtual double get() {return a;} 
  virtual ~Father(){}
protected: 
  double a; 
};

/* child */
class Child : public Father { 
public: 
  virtual double get() {return b;} 
  virtual ~Child(){}
  double b; 
};

/* child2 */
class Child2 : public Father { 
public:  
  virtual double get() {return c;} 
  virtual ~Child2(){}
  double c;  
};

void TestCast()
{
  SharedPtr<Father> f = SharedPtr<Father>(new Father), f2;
  SharedPtr<Child> c = SharedPtr<Child>(new Child), c2;
  SharedPtr<Child2> cc = SharedPtr<Child2>(new Child2);

  /// this cast succeeds
  f2 = DynamicCast<Father>(c);
  if (f2) {} else { BIASABORT; }
  /// this cast fails
  c2 = DynamicCast<Child>(cc);
  if (c2) { BIASABORT; }

  if (verbose) {
    cout << "ref count cast f2: "<<RefCount(f2)<<" (expected 2)"<<endl;
    cout << "ref count cast c : "<<RefCount(c) <<" (expected 2)"<<endl;
    cout << "ref count cast f : "<<RefCount(f) <<" (expected 1)"<<endl;
    cout << "ref count cast c2: "<<RefCount(c2)<<" (expected 0)"<<endl;
    cout << "ref count cast c : "<<RefCount(cc)<<" (expected 1)"<<endl;
  }

  SharedPtr<const Father> f3 = SharedPtr<Father>(new Father);
  // should be successfull
  f2 = ConstCast<Father>(f3);
  if (f2) {} else { BIASABORT; };
  f3 = ConstCast<const Father>(f);
  if (f3) {} else { BIASABORT; };

#ifdef TEST_COMPILE_TIME_ERROR_ConstCastTypeMismatch
  // type mismatch: fails, compile time error
  f2 = ConstCast<Father>(c);
#endif

}

void TestAutomaticCast()
{
  SharedPtr<Father> father;
  SharedPtr<const Father> const_father;
  SharedPtr<Child> child = SharedPtr<Child>(new Child);
  SharedPtr<const Child> const_child  = SharedPtr<const Child>(new Child);
  
  father = child;
  const_father = child;
  const_father = const_child;

#ifdef TEST_COMPILE_TIME_ERROR_AutocastConst
  child = const_father;
#endif
}
/** \endcond **/

int main()
{
  TestConstructors();
  TestAccess();
  TestConversionToBool();
  TestComparison();
  TestSorting();
  TestReferenceCounting();
  TestStream();
  TestConst();
  TestSTL();
  TestCast();
  TestAutomaticCast();

  return 0;
}