#include "FailureException.h"
#include "MockTestCase.h"
#include <cppunit/TestPath.h>


MockTestCase::MockTestCase( std::string name )
    : CPPUNIT_NS::TestCase( name )
    , m_hasSetUpExpectation( false )
    , m_expectedSetUpCall( 0 )
    , m_actualSetUpCall( 0 )
    , m_hasTearDownExpectation( false )
    , m_expectedTearDownCall( 0 )
    , m_actualTearDownCall( 0 )
    , m_expectRunTestCall( false )
    , m_expectedRunTestCallCount( 0 )
    , m_actualRunTestCallCount( 0 )
    , m_expectCountTestCasesCall( false )
    , m_expectedCountTestCasesCallCount( 0 )
    , m_actualCountTestCasesCallCount( 0 )
    , m_setUpThrow( false )
    , m_tearDownThrow( false )
    , m_runTestThrow( false )
    , m_passingTest( NULL )
{
}


MockTestCase::~MockTestCase()
{
}


int 
MockTestCase::countTestCases() const
{
  MockTestCase *mutableThis = CPPUNIT_CONST_CAST(MockTestCase *, this );
  ++mutableThis->m_actualCountTestCasesCallCount;
  if ( m_expectCountTestCasesCall )
  {
    CPPUNIT_ASSERT_MESSAGE( getName() + ": unexpected MockTestCase::countTestCases() call",
                            m_actualCountTestCasesCallCount <= m_expectedCountTestCasesCallCount );
  }

  return SuperClass::countTestCases();
}


void 
MockTestCase::setUp()
{
  if ( m_hasSetUpExpectation )
  {
    ++m_actualSetUpCall;
    CPPUNIT_ASSERT_MESSAGE( getName() + ": unexpected MockTestCase::setUp() call",
                            m_actualSetUpCall <= m_expectedSetUpCall );
  }

  if ( m_setUpThrow )
    throw FailureException();
}

void 
MockTestCase::tearDown()
{
  if ( m_hasTearDownExpectation )
  {
    ++m_actualTearDownCall;
    CPPUNIT_ASSERT_MESSAGE( getName() + ": unexpected MockTestCase::tearDown() call",
                            m_actualTearDownCall <= m_expectedTearDownCall );
  }

  if ( m_tearDownThrow )
    throw FailureException();
}


void 
MockTestCase::runTest()
{
  ++m_actualRunTestCallCount;
  if ( m_expectRunTestCall )
  {
    CPPUNIT_ASSERT_MESSAGE( getName() + ": unexpected MockTestCase::runTest() call",
                            m_actualRunTestCallCount <= m_expectedRunTestCallCount );
  }

  if ( m_runTestThrow )
    throw FailureException();
}

/*
bool 
MockTestCase::findTestPath( const CPPUNIT_NS::Test *test,
                            CPPUNIT_NS::TestPath &testPath )
{
  if ( m_passingTest == test )
  {
    testPath.add( this );
    return true;
  }

  return false;
}
*/

void 
MockTestCase::setExpectedSetUpCall( int callCount )
{
  m_hasSetUpExpectation = true;
  m_expectedSetUpCall = callCount;
}


void 
MockTestCase::setExpectedTearDownCall( int )
{
}


void 
MockTestCase::setExpectedRunTestCall( int callCount )
{
  m_expectRunTestCall = true;
  m_expectedRunTestCallCount = callCount ;
}


void 
MockTestCase::setExpectedCountTestCasesCall( int callCount )
{
  m_expectCountTestCasesCall = true;
  m_expectedCountTestCasesCallCount = callCount;
}


void 
MockTestCase::makeSetUpThrow()
{
  m_setUpThrow = true;
}


void 
MockTestCase::makeTearDownThrow()
{
  m_tearDownThrow = true;
}


void 
MockTestCase::makeRunTestThrow()
{
  m_runTestThrow = true;
}


void 
MockTestCase::verify()
{
  if ( m_hasSetUpExpectation )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( getName() + ": bad MockTestCase::setUp() "
                                  "call count",
                                  m_expectedSetUpCall,
                                  m_actualSetUpCall );
  }

  if ( m_hasTearDownExpectation )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( getName() + ": bad MockTestCase::tearDown() "
                                  "call count",
                                  m_expectedTearDownCall,
                                  m_actualTearDownCall );
  }

  if ( m_expectCountTestCasesCall )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( getName() + ": bad MockTestCase::countTestCases() "
                                  "call count",
                                  m_expectedCountTestCasesCallCount,
                                  m_actualCountTestCasesCallCount );
  }
  if ( m_expectRunTestCall )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( getName() + ": bad MockTestCase::runTest() "
                                  "call count",
                                  m_expectedRunTestCallCount,
                                  m_actualRunTestCallCount );
  }
}