// export LD_LIBRARY_PATH=/usr/local/lib
// g++ -I/usr/local/include/cppunit -L/usr/local/lib -lcppunit -ldl *.cpp

//#include "ObjectPool.h"
#include "ObjectPool.cpp"
#include "Serial.h"
#include "ObjectPoolTest.h"
#include <cppunit/TestAssert.h>
#include <cppunit/TestCaller.h>
#include <cppunit/TestResult.h>
#include <cppunit/ui/text/TestRunner.h>
#include <iostream>
#include <set>

void ObjectPoolTest::setUp()
{
}

void ObjectPoolTest::tearDown()
{
}

void ObjectPoolTest::testCreation()
{
  ObjectPool<Serial> myPool;
}

void ObjectPoolTest::testInvalidChunkSize()
{
  bool caughtException = false;

  try {
    ObjectPool<Serial> myPool(0);
  } catch (const invalid_argument& ex) {
    // ok. we were expecting an exception
    caughtException = true;
  }

  CPPUNIT_ASSERT(caughtException);
}

void ObjectPoolTest::testAcquire()
{
  ObjectPool<Serial> myPool;

  Serial& serial = myPool.acquireObject();

  CPPUNIT_ASSERT(serial.getSerialNumber() >= 0);
}


void ObjectPoolTest::testExclusivity()
{
  const int poolSize = 5;
  ObjectPool<Serial> myPool(poolSize);
  set<int> seenSerials;

  for (int i = 0; i < poolSize; i++) {
    Serial& nextSerial = myPool.acquireObject();

    // assert that this number hasn't been seen before
    CPPUNIT_ASSERT(seenSerials.find(nextSerial.getSerialNumber()) == 
		   seenSerials.end());

    // add this number to the set
    seenSerials.insert(nextSerial.getSerialNumber());
  }
}

void ObjectPoolTest::testRelease()
{
  const int poolSize = 5;
  ObjectPool<Serial> myPool(poolSize);

  Serial& originalSerial = myPool.acquireObject();

  int originalSerialNumber = originalSerial.getSerialNumber();

  // return the original object to the pool
  myPool.releaseObject(originalSerial);

  // now make sure that the original object is recycled before
  // a new chunk is created
  bool wasRecycled = false;
  for (int i = 0; i < poolSize; i++) {
    Serial& nextSerial = myPool.acquireObject();
    if (nextSerial.getSerialNumber() == originalSerialNumber) {
      wasRecycled = true;
      break;
    }
  }

  CPPUNIT_ASSERT(wasRecycled);
}

void ObjectPoolTest::testSimple()
{
  CPPUNIT_ASSERT(1 != 0);
}

CppUnit::Test* ObjectPoolTest::suite()
{
  CppUnit::TestSuite *suiteOfTests = new CppUnit::TestSuite( "ObjectPoolTest" );
  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testSimple", 
								    &ObjectPoolTest::testSimple ) );

  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testCreation", 
								    &ObjectPoolTest::testCreation ) );

  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testInvalidChunkSize", 
								    &ObjectPoolTest::testInvalidChunkSize ) );

  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testAcquire", 
								    &ObjectPoolTest::testAcquire ) );

  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testExclusivity", 
								    &ObjectPoolTest::testExclusivity ) );

  suiteOfTests->addTest( new CppUnit::TestCaller<ObjectPoolTest>( 
								    "testRelease", 
								    &ObjectPoolTest::testRelease ) );
  return suiteOfTests;
}

int main()
{
  CppUnit::TextUi::TestRunner runner;
  runner.addTest( ObjectPoolTest::suite() );
  runner.run();
  return 0;
}