// Ptr_t.cpp

// Test pointer class Ptr.

#include "ptr/Ptr.h"
#include "ptr/Ptr_t.h"
#include "ptr/TestPolicy.h"

#include <iostream>
#include <string>
#include <list>
#include <cassert>

#ifndef DEFECT_NO_NAMESPACES
using std::cout;
using std::cerr;
using std::endl;
using std::string;
#endif

int MyInt::_count = 0;

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

int main( ) {

  string component = "Ptr";
  string ok_prefix = component + " (I): ";
  string error_prefix = component + " test (E): ";

  cout << ok_prefix
       << "---------- Testing component " + component
          + ". ----------" << endl;

  // Make sure assert is enabled.
  bool assert_flag = false;
  assert ( ( assert_flag = true, assert_flag ) );
  if ( ! assert_flag ) {
    cerr << "Assert is disabled" << endl;
    return 1;
  }

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

  cout << ok_prefix << "Construct a pointer." << endl;
  MyInt* pbare1 = new MyInt(123);
  MyInt& i1 = *pbare1;
#ifndef DEFECT_NO_EXPLICIT
  //CHECK1 Ptr<MyInt,TestPolicy> pi0 = pbare1;  // should not compile
#endif
  Ptr<MyInt,TestPolicy> pi1(pbare1);
  assert( pi1 != 0 );

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

  cout << ok_prefix << "Test access methods." << endl;
  cout << i1.get_value() << " " << &i1 << endl;
  cout << pi1.pointer() << endl;
  assert( pi1.pointer() == &i1 );
  cout << (*pi1).get_value() << endl;
  assert( (*pi1).get_value() == 123 );
  cout << pi1->get_value() << endl;
  assert( pi1->get_value() == 123 );
  (*pi1).set_value(246);
  cout << pi1->get_value() << endl;
  assert( pi1->get_value() == 246 );
  pi1->set_value(369);
  cout << pi1->get_value() << endl;
  assert( pi1->get_value() == 369 );

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

  cout << ok_prefix << "Construct a const pointer." << endl;
  const MyInt* pbare2 = new MyInt(321);
  const MyInt& i2 = *pbare2;
  Ptr<const MyInt,TestPolicy> pi2(pbare2);
  cout << pi2.pointer() << endl;
  assert( pi2.pointer() == &i2 );
  cout << (*pi2).get_value() << endl;
  assert( (*pi2).get_value() == 321 );
  cout << pi2->get_value() << endl;
  assert( pi2->get_value() == 321 );
  //CHECK2 (*pi2).set_value(246);  // This should not compile
  //CHECK3 pi2->set_value(246);  // This should not compile

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

  cout << ok_prefix << "Test construction from Ptr." << endl;

  // mutable -> mutable
  cout << pi1->get_value() << endl;
  Ptr<MyInt,TestPolicy> pi3 = pi1;
  cout << pi3->get_value() << endl;
  assert( pi3->get_value() == pi1->get_value() );

  // const -> const
  Ptr<const MyInt,TestPolicy> pi4 = pi2;
  cout << pi4->get_value() << endl;
  assert( pi4->get_value() == pi2->get_value() );

  // const -> mutable  (should fail)
  //CHECK4 Ptr<MyInt,TestPolicy> pi5 = pi2;

  // mutable -> const (requires template member or TmpPtr workaround)
#ifndef DEFECT_NO_MEMBER_TEMPLATES_AT_ALL
  Ptr<const MyInt,TestPolicy> pi6 = pi1;
#else
  Ptr<const MyInt,TestPolicy> pi6 = TmpPtr(pi1);
#endif
  cout << pi6->get_value() << endl;
  assert( pi6->get_value() == pi1->get_value() );

  // Give management back to pi1 and pi2.
  pi1 = pi3;
  pi2 = pi4;

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

  cout << ok_prefix << "Test assignment from Ptr." << endl;

  // mutable -> mutable
  pi1->set_value(1234);
  pi3->set_value(0);
  cout << pi1->get_value() << endl;
  assert( pi1 != 0 );
  pi3 = pi1;
  assert( pi1 != 0 );
  cout << pi1->get_value() << endl;
  cout << pi3->get_value() << endl;
  assert( pi3->get_value() == pi1->get_value() );
  // Give management back to pi1.
  pi1 = pi3;

  // const -> const
  pi6 = pi2;
  cout << pi2->get_value() << endl;
  cout << pi6->get_value() << endl;
  assert( pi6->get_value() == pi2->get_value() );
  // Give management back to pi2.
  pi2 = pi6;

  // const -> mutable -- should not compile if member templates exist
#ifndef DEFECT_NO_MEMBER_TEMPLATES_AT_ALL
  //CHECK5 pi3 = pi2;
#endif

  // mutable -> const
  pi6 = pi3;
  cout << pi3->get_value() << endl;
  cout << pi6->get_value() << endl;
  assert( pi6->get_value() == pi3->get_value() );

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

  cout << ok_prefix << "Test assignment from bare pointers." << endl;

  // mutable -> mutable
  {
    MyInt* pbaretmp = new MyInt(369);
    MyInt& itmp = *pbaretmp;
    pi3 = pbaretmp;
    itmp.set_value(i1.get_value());
    cout << itmp.get_value() << endl;
    cout << pi3->get_value() << endl;
    assert( pi3->get_value() == itmp.get_value() );
  }

  // const -> const
  {
    const MyInt* pbaretmp = new MyInt(389);
    const MyInt& itmp = *pbaretmp;
    pi6 = pbaretmp;
    cout << itmp.get_value() << endl;
    cout << pi6->get_value() << endl;
    assert( pi6->get_value() == itmp.get_value() );
  }

  // const -> mutable -- should not compile
  {
    //const MyInt* pbaretmp = new MyInt(389);
    //const MyInt& i3 = *pbaretmp;
    //CHECK6 pi3 = pbaretmp;
  }

  // mutable -> const
  {
    MyInt* pbaretmp = new MyInt(369);
    MyInt& itmp = *pbaretmp;
    pi6 = pbaretmp;
    cout << itmp.get_value() << endl;
    cout << pi6->get_value() << endl;
    assert( pi6->get_value() == itmp.get_value() );
  }

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

  cout << ok_prefix << "Check equality." << endl;
  pi3 = pi1;
  pi4 = pi1;
  // ptr == ptr
  assert( pi3 == pi1 );
  assert( ! (pi3 != pi1) );
  assert( pi4 == pi1 );
  assert( pi2 != pi1 );
  // ptr = = bare
  assert( pi1 == pbare1 );
  assert( ! (pi1 != pbare1) );
  // bare == ptr
  assert( pbare2 == pi2 );
  assert( ! (pbare2 != pi2) );

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

  cout << ok_prefix << "Check ordering." << endl;
  if ( pbare1 < pbare2 ) {
    assert( pi1 < pi2 );
    assert( pi2 > pi1 );
    assert( pi1 < pbare2 );
    assert( pbare1 < pi2 );
  } else {
    assert( pi1 > pi2 );
    assert( pi2 < pi1 );
    assert( pi1 > pbare2 );
    assert( pbare1 > pi2 );
  }

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

  cout << ok_prefix << "Check validity." << endl;
  Ptr<MyInt,TestPolicy> pi9;
  assert( ! pi9 );
  assert( pi1 != 0 );
  assert( pi3 != 0 );
  try {
    pi9->get_value();
    assert(false);
  }
  catch(const PtrInvalidPointer&) { }
  try {
    *pi9;
    assert(false);
  }
  catch(const PtrInvalidPointer&) { }

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

  cout << ok_prefix << "Construct a list of pointers." << endl;
  {
    typedef std::list< Ptr<MyInt,TestPolicy> > List;
    List list1;
    list1.push_back( pi1 );
    //list1.push_back( new MyInt(987) );
  }

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

  cout << ok_prefix << "Assign mutable to const." << endl;
  {
    Ptr<MyInt,TestPolicy> pm(new MyInt(1));
    Ptr<const MyInt,TestPolicy> pc(new MyInt(2));
    assert( pm != pc );
    pc = pm;
    assert( pm == pc );
  }
    
  //********************************************************************

  cout << ok_prefix << "Assign const to mutable." << endl;
  {
    Ptr<MyInt,TestPolicy> pm(new MyInt(1));
    Ptr<const MyInt,TestPolicy> pc(new MyInt(2));
    assert( pm != pc );
    // pm = pc;   // This should not compile
    pm.assign_with_const_cast(pc);
    assert( pm == pc );
  }
    
  //********************************************************************

  cout << ok_prefix << "Assign derived to base." << endl;
  {
    Ptr<MyInt,TestPolicy> pb(new MyInt(1));
    Ptr<MySubInt,TestPolicy> pd(new MySubInt(2));
    assert( pb != pd );
    pb = pd;
    assert( pb == pd );
  }
    
  //********************************************************************

  cout << ok_prefix << "Assign base to derived." << endl;
  {
    Ptr<MyInt,TestPolicy> pb(new MySubInt(1));
    Ptr<MySubInt,TestPolicy> pd(new MySubInt(2));
    assert( pb != pd );
    //pd = pb;   // This should not compile.
    pd.assign_with_dynamic_cast(pb);
    assert( pb == pd );
  }

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

  cout << ok_prefix << "Set pointer to null." << endl;
  {
    Ptr<MyInt,TestPolicy> pb(new MyInt(1));
    assert( pb != 0 );
    pb = 0;
    assert( pb == 0 );
  }
    
  //********************************************************************

  cout << ok_prefix
       << "------------- All tests passed. -------------" << endl;
  return 0;

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

}