testShadowPtr.cc

Go to the documentation of this file.

#include <iostream>
#include <vector>
#include <cppunit/extensions/HelperMacros.h>
#include <tst/Verify.h>
#include <utl/CountedObject.h>
#include <utl/CountedObjectRegistry.h>
#include <utl/ShadowPtr.h>

using namespace utl;
using namespace tst;

#define ASSERT_OBJECT_COUNTS(o, c, d, e) \
  CPPUNIT_ASSERT(utl::CountedObject<o>::GetObjectsCreated() == c); \
  CPPUNIT_ASSERT(utl::CountedObject<o>::GetObjectsDestroyed() == d); \
  CPPUNIT_ASSERT(utl::CountedObject<o>::GetObjectsExisting() == e)


namespace ns2 {
  class Bar;
}


namespace ns1 {

  // this class emulates offline framework object with private ctor/dtor
  // commented methods are implicit
  class Foo : public utl::CountedObject<Foo> {

  public:
    Foo(const Foo& foo) : utl::CountedObject<Foo>() { fData = foo.fData; }
    Foo& operator=(const Foo& foo) { fData = foo.fData; return *this; }
    int GetData() const { return fData; }
    void SetData(const int data) { fData = data; }
    bool operator==(const Foo& foo) const { return fData == foo.fData; }
    bool operator!=(const Foo& foo) const { return !operator==(foo); }

  private:
    Foo() : fData(0) { }
    ~Foo() { }

    int fData;

    friend class ns2::Bar;
    friend class utl::ShadowPtr<Foo>;
    friend class utl::InitializedShadowPtr<Foo>;

  };

}


namespace ns2 {

  class Bar {

  public:
    bool HasFoo1() const { return bool(fFoo1); }
    void MakeFoo1() { fFoo1 = new ns1::Foo; }
    ns1::Foo& GetFoo1() { return *fFoo1; }
    const ns1::Foo& GetFoo1() const { return *fFoo1; }

    bool HasFoo2() const { return bool(fFoo2); }
    ns1::Foo& GetFoo2() { return *fFoo2; }
    const ns1::Foo& GetFoo2() const { return *fFoo2; }

    bool operator==(const Bar& bar) const
    { return utl::DeepEqual(fFoo1, bar.fFoo1) && utl::DeepEqual(fFoo2, bar.fFoo2); }
    bool operator!=(const Bar& bar) const { return !operator==(bar); }

    Bar() {}

  private:
    utl::ShadowPtr<ns1::Foo> fFoo1;
    utl::InitializedShadowPtr<ns1::Foo> fFoo2;

  };

}


namespace ns3 {

  class VBase {

  public:
    typedef int IsClonableTag;

    virtual VBase* Clone() const = 0;
    virtual ~VBase() { }

  };

  class Child : public VBase {

  public:
    virtual ~Child() { }
    Child() : fCountClone(0) { }
    int GetCount() const { return fCountClone; }
    Child* Clone() const { ++fCountClone; return new Child(*this); }

  private:
    mutable int fCountClone;

  };

  class Mother {

  public:
    bool HasChild() const { return bool(fChild); }
    void MakeChild() { fChild = new Child; }
    Child& GetChild() { return *fChild; }
    const Child& GetChild() const { return *fChild; }

  private:
    utl::ShadowPtr<Child> fChild;

  };

}

/*namespace ns4 {

  class Prince {
  public:
    int i;
    Prince()
      : i(0)
    { }
    static int fgCloneCount;
  };

  int Prince::fgCloneCount = 0;

  class King {
  public:
    utl::ShadowPtr<Prince> fHeir;
    King()
      : fHeir(new Prince())
    { }
  };

  Prince* Clone(const Prince& src)
  {
    ++Prince::fgCloneCount;
    return new Prince(src);
  }

}*/


class OverCounted {
public:
  explicit OverCounted(const int data = 0)
  { ++fgConstructor; fData = data; }

  ~OverCounted()
  { ++fgDestructor; }

  OverCounted(const OverCounted& oc)
  { ++fgCopyConstructor; fData = oc.fData; }

  OverCounted& operator=(const OverCounted& oc)
  { ++fgAssign; fData = oc.fData; return *this; }

  static void Clear()
  { fgConstructor = fgDestructor = fgCopyConstructor = fgAssign = fgSwap = 0; }

  void Swap(OverCounted& oc)
  { ++fgSwap; std::swap(fData, oc.fData); }

  static
  void
  Print()
  {
    std::cout << '+' << fgConstructor << " ~" << fgDestructor
              << " :" << fgCopyConstructor << " =" << fgAssign
              << " s" << fgSwap << std::endl;
  }

private:
  int fData;
  static int fgConstructor;
  static int fgDestructor;
  static int fgCopyConstructor;
  static int fgAssign;
  static int fgSwap;
};

int OverCounted::fgConstructor = 0;
int OverCounted::fgDestructor = 0;
int OverCounted::fgCopyConstructor = 0;
int OverCounted::fgAssign = 0;
int OverCounted::fgSwap = 0;


//namespace std {

  void
  swap(OverCounted& oc1, OverCounted& oc2)
  {
    oc1.Swap(oc2);
  }

//}


class testShadowPtr : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testShadowPtr);
  CPPUNIT_TEST(testALot);
  CPPUNIT_TEST_EXCEPTION(testDereferenceZeroThrow, utl::NonExistentComponentException);
  CPPUNIT_TEST(testNoThrow);
  CPPUNIT_TEST(testCloning);
  //CPPUNIT_TEST(testKoenigCloning);
  CPPUNIT_TEST(testPrintStatistics);
  CPPUNIT_TEST(testContainerOps);
  CPPUNIT_TEST_SUITE_END();

public:
  void setUp() { }

  void tearDown() { }

  void
  testALot()
  {
    int created = 0;
    int destroyed = 0;
    int existing = 0;
    ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
    {
      ns2::Bar bar;
      ++created; ++existing;
      ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
    }
    ++destroyed; --existing;
    ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
    {
      ns2::Bar bar1;
      ++created; ++existing;
      ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
      CPPUNIT_ASSERT(bar1.HasFoo1() == false);
      CPPUNIT_ASSERT(bar1.HasFoo2() == true);
      bar1.MakeFoo1();
      ++created; ++existing;
      ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
      CPPUNIT_ASSERT(bar1.HasFoo1() == true);
      CPPUNIT_ASSERT(bar1.HasFoo2() == true);
      bar1.GetFoo1().SetData(13);
      bar1.GetFoo2().SetData(137);
      CPPUNIT_ASSERT(bar1.GetFoo1().GetData() == 13);
      CPPUNIT_ASSERT(bar1.GetFoo2().GetData() == 137);
      const ns2::Bar bar2(bar1);
      created += 2; existing += 2;
      ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
      CPPUNIT_ASSERT(bar2.GetFoo1().GetData() == 13);
      CPPUNIT_ASSERT(bar2.GetFoo2().GetData() == 137);
      CPPUNIT_ASSERT(&bar1.GetFoo1() != &bar2.GetFoo1());
      CPPUNIT_ASSERT(&bar1.GetFoo2() != &bar2.GetFoo2());
      const ns2::Bar bar3 = bar1;
      created += 2; existing += 2;
      ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
      CPPUNIT_ASSERT(bar3.GetFoo1().GetData() == 13);
      CPPUNIT_ASSERT(bar3.GetFoo2().GetData() == 137);
      CPPUNIT_ASSERT(&bar1.GetFoo1() != &bar3.GetFoo1());
      CPPUNIT_ASSERT(&bar1.GetFoo2() != &bar3.GetFoo2());
      CPPUNIT_ASSERT(bar3 == bar1);
      CPPUNIT_ASSERT(bar3.GetFoo1() == bar1.GetFoo1());
      CPPUNIT_ASSERT(bar3.GetFoo2() == bar1.GetFoo2());
      ns2::Bar bar4;
      ++created; ++existing;
      CPPUNIT_ASSERT(bar4 != bar1);
    }
    destroyed += 7; existing -= 7;
    ASSERT_OBJECT_COUNTS(ns1::Foo, created, destroyed, existing);
  }

  void
  testDereferenceZeroThrow()
  {
    const ns2::Bar bar;
    const ns1::Foo& foo = bar.GetFoo1();
    foo.GetData();
  }

  void
  testNoThrow()
  {
    const ns2::Bar bar;
    const ns1::Foo& foo = bar.GetFoo2();
    foo.GetData();
  }

  void
  testCloning()
  {
    ns3::Mother mom;
    CPPUNIT_ASSERT(mom.HasChild() == false);
    mom.MakeChild();
    CPPUNIT_ASSERT(mom.HasChild() == true);
    CPPUNIT_ASSERT(Verify<Equal>(mom.GetChild().GetCount(), 0));
    ns3::Mother stepMother(mom);
    CPPUNIT_ASSERT(stepMother.HasChild() == true);
    CPPUNIT_ASSERT(Verify<Equal>(mom.GetChild().GetCount(), 1));
    CPPUNIT_ASSERT(Verify<Equal>(stepMother.GetChild().GetCount(), 1));
    CPPUNIT_ASSERT(&mom.GetChild() != &stepMother.GetChild());
  }

  /*void
  testKoenigCloning()
  {
    ns4::King k;
    CPPUNIT_ASSERT(Verify<Equal>(ns4::Prince::fgCloneCount, 0));
    ns4::King k2(k);
    CPPUNIT_ASSERT(Verify<Equal>(ns4::Prince::fgCloneCount, 1));
  }*/

  void
  testPrintStatistics()
  {
    std::cerr << std::endl;
    utl::CountedObjectRegistry::PrintStatistics(std::cerr, "ns1::Foo");
    std::cerr << std::endl;
  }

  void
  testContainerOps()
  {
    OverCounted::Clear();
    std::cout << "\n0: "; OverCounted::Print();
    // ctor
    OverCounted obj;
    std::cout << "1: "; OverCounted::Print();
    // vec
    std::vector<utl::ShadowPtr<OverCounted> > vec;
    std::cout << "2: "; OverCounted::Print();
    // push_back version 1
    vec.push_back(utl::ShadowPtr<OverCounted>(new OverCounted(obj)));
    std::cout << "3: "; OverCounted::Print();
    // push_back version 2
    vec.push_back(utl::ShadowPtr<OverCounted>());
    std::cout << "4: "; OverCounted::Print();
    vec.back() = new OverCounted(obj);
    std::cout << "5: "; OverCounted::Print();

    //

    OverCounted::Clear();
    {
      typedef utl::ShadowPtr<OverCounted> OverCountedShPtr;
      std::vector<OverCountedShPtr> vec;
      for (int i = 0; i < 100; ++i)
        vec.push_back(OverCountedShPtr(new OverCounted(obj)));
      std::cout << "\n vec: "; OverCounted::Print();
    }
    std::cout << "~vec: "; OverCounted::Print();

    //

    std::vector<OverCounted> v2(1, obj);
    // trim to exactly 1 element size
    std::vector<OverCounted>(v2).swap(v2);
    OverCounted::Clear();
    std::cout << "\n0: "; OverCounted::Print();
    v2.push_back(obj);
    std::cout << "1: "; OverCounted::Print();
    v2.push_back(obj);
    std::cout << "2: "; OverCounted::Print();

    //

    std::vector<std::vector<OverCounted> > v3(1, v2);
    // trim to exactly 1 element size
    std::vector<std::vector<OverCounted> >(v3).swap(v3);
    OverCounted::Clear();
    std::cout << "\n0: "; OverCounted::Print();
    v3.push_back(v2);
    std::cout << "1: "; OverCounted::Print();
    v3.push_back(v2);
    std::cout << "2: "; OverCounted::Print();
  }

};

CPPUNIT_TEST_SUITE_REGISTRATION(testShadowPtr);


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: