testObjectFactory.cc

Go to the documentation of this file.

// header for unit test testObjectFactory

#include <utl/ObjectFactory.h>
#include <string>

#include <tst/Verify.h>
#include <cppunit/extensions/HelperMacros.h>

using namespace utl;
using namespace tst;
using namespace std;




namespace {
  // Test factory polymorphic class with a default constructor
  class IdObjectBase {
  public:
    virtual ~IdObjectBase() { }
    virtual int GetId() = 0;
  };

  // Template to create concrete implementations of IdObjectBase
  template<int id>
  class IdObject : public IdObjectBase {
  public:
    int GetId() { return id; }
    static IdObjectBase* Create()
    { return new IdObject; }
  };

  // Convenience typedef for factory
  typedef ObjectFactory<IdObjectBase*, int> IdObjectFactory;


  // Test factory polymorphic class with a one-argument constructor
  class IdObjectCountBase {
  public:
    IdObjectCountBase() : fCount(0) { }
    IdObjectCountBase(int i) : fCount(i) { }
    virtual ~IdObjectCountBase() { }
    virtual int GetId() = 0;
    int GetCount() { return fCount; }
  private:
    int fCount;
  };

  template<int id>
  class IdObjectCount : public IdObjectCountBase {
  public:
    IdObjectCount(int i) : IdObjectCountBase(i) { }
    int GetId() { return id; }
    static IdObjectCountBase* Create(int i)
    { return new IdObjectCount(i); }
  };

  typedef ObjectFactory<IdObjectCountBase*, string, IdObjectCountBase* (*)(int)>
  IdObjectCountFactory;


  // Test factory polymorphic class with a two-argument constructor
  class IdObjectCount2Base {
  public:
    IdObjectCount2Base() : fCount1(0), fCount2(0) { }
    IdObjectCount2Base(int i, int j) : fCount1(i), fCount2(j) { }
    virtual ~IdObjectCount2Base() { }
    virtual int GetId() = 0;
    int GetCount1() { return fCount1; }
    int GetCount2() { return fCount2; }
  private:
    int fCount1;
    int fCount2;
  };

  template<int id>
  class IdObjectCount2 : public IdObjectCount2Base {
  public:
    IdObjectCount2(int i, int j) : IdObjectCount2Base(i, j) { }
    int GetId() { return id; }
    static IdObjectCount2Base* Create(int i, int j)
    { return new IdObjectCount2(i, j); }
  };

  typedef ObjectFactory<IdObjectCount2Base*, string, IdObjectCount2Base* (*)(int, int)>
  IdObjectCount2Factory;
}


class testObjectFactory
  : public CppUnit::TestFixture
{
  CPPUNIT_TEST_SUITE(testObjectFactory);
  CPPUNIT_TEST(testCreation);
  CPPUNIT_TEST(testCreationArg);
  CPPUNIT_TEST(testCreationArg2);
  //  CPPUNIT_TEST(testFN);
  //  CPPUNIT_TEST_EXCEPTION(testFN, anException);
  CPPUNIT_TEST_SUITE_END();
public:
  // shared data for tests

  void setUp()
  {
  }

  void tearDown()
  {
  }

  void testCreation()
  {
    IdObjectBase* const pNull = 0;

    CPPUNIT_ASSERT(IdObjectFactory::Register(1, IdObject<1>::Create));

    IdObjectBase* p1 = IdObjectFactory::Create(1);
    CPPUNIT_ASSERT(Verify<Not<Equal> >(p1, pNull));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetId(), 1));
    delete p1;

    IdObjectBase* p2 = IdObjectFactory::Create(2);
    CPPUNIT_ASSERT(Verify<Equal>(p2, pNull));

    CPPUNIT_ASSERT(IdObjectFactory::Register(2, IdObject<2>::Create));

    p2 = IdObjectFactory::Create(2);
    CPPUNIT_ASSERT(Verify<Not<Equal> >(p2, pNull));
    CPPUNIT_ASSERT(Verify<Equal>(p2->GetId(), 2));
    delete p2;

    IdObjectFactory::Iterator iter = IdObjectFactory::Begin();
    CPPUNIT_ASSERT(Verify<Equal>(iter->first, 1));
    ++iter;
    CPPUNIT_ASSERT(Verify<Equal>(iter->first, 2));
    ++iter;
    CPPUNIT_ASSERT(iter == IdObjectFactory::End());
  }


  void testCreationArg()
  {
    IdObjectCountBase* const pNull = 0;

    CPPUNIT_ASSERT(Verify<Equal>(IdObjectCountFactory::GetNumberOfCreators(), 
                               0u));

    CPPUNIT_ASSERT(IdObjectCountFactory::Register("1", 
                                                  IdObjectCount<1>::Create));
    CPPUNIT_ASSERT(Verify<Equal>(IdObjectCountFactory::GetNumberOfCreators(), 
                               1u));

    IdObjectCountBase* p1 = IdObjectCountFactory::Create("1", 5);
    CPPUNIT_ASSERT(Verify<Not<Equal> >(p1, pNull));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetId(), 1));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetCount(), 5));
    delete p1;

    IdObjectCountBase* p2 = IdObjectCountFactory::Create("2", 1);
    CPPUNIT_ASSERT(Verify<Equal>(p2, pNull));

    CPPUNIT_ASSERT(IdObjectCountFactory::Register("2",
                                                  IdObjectCount<2>::Create));
    CPPUNIT_ASSERT(Verify<Equal>(IdObjectCountFactory::GetNumberOfCreators(), 
                               2u));

    p2 = IdObjectCountFactory::Create("2", 3);
    CPPUNIT_ASSERT(Verify<Not<Equal> >(p2, pNull));
    CPPUNIT_ASSERT(Verify<Equal>(p2->GetId(), 2));
    CPPUNIT_ASSERT(Verify<Equal>(p2->GetCount(), 3));
    delete p2;
  }

  void testCreationArg2()
  {
    IdObjectCount2Base* const pNull = 0;

    CPPUNIT_ASSERT(Verify<Equal>(IdObjectCount2Factory::GetNumberOfCreators(), 
                               0u));

    CPPUNIT_ASSERT(IdObjectCount2Factory::Register("1", 
                                                  IdObjectCount2<1>::Create));
    CPPUNIT_ASSERT(Verify<Equal>(IdObjectCount2Factory::GetNumberOfCreators(), 
                               1u));

    IdObjectCount2Base* p1 = IdObjectCount2Factory::Create("1", 5, 6);
    CPPUNIT_ASSERT(Verify<Not<Equal> >(p1, pNull));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetId(), 1));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetCount1(), 5));
    CPPUNIT_ASSERT(Verify<Equal>(p1->GetCount2(), 6));
    delete p1;
  }

};

CPPUNIT_TEST_SUITE_REGISTRATION(testObjectFactory);


// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -C .. -k testSTL && ../testSTL"
// End: