mocktestlistener.cpp

这是国外的resip协议栈

#include <cppunit/TestAssert.h>
#include <cppunit/TestFailure.h>
#include "MockTestListener.h"


MockTestListener::MockTestListener( std::string name )
    : m_name( name )
    , m_hasExpectationForStartTest( false )
    , m_hasParametersExpectationForStartTest( false )
    , m_expectedStartTestCallCount( 0 )
    , m_startTestCall( 0 )
    , m_hasExpectationForEndTest( false )
    , m_hasParametersExpectationForEndTest( false )
    , m_expectedEndTestCallCount( 0 )
    , m_endTestCall( 0 )
    , m_hasExpectationForStartSuite( false )
    , m_hasParametersExpectationForStartSuite( false )
    , m_expectedStartSuiteCallCount( 0 )
    , m_startSuiteCall( 0 )
    , m_hasExpectationForEndSuite( false )
    , m_hasParametersExpectationForEndSuite( false )
    , m_expectedEndSuiteCallCount( 0 )
    , m_endSuiteCall( 0 )
    , m_hasExpectationForStartTestRun( false )
    , m_hasParametersExpectationForStartTestRun( false )
    , m_expectedStartTestRunCallCount( 0 )
    , m_startTestRunCall( 0 )
    , m_hasExpectationForEndTestRun( false )
    , m_hasParametersExpectationForEndTestRun( false )
    , m_expectedEndTestRunCallCount( 0 )
    , m_endTestRunCall( 0 )
    , m_hasExpectationForAddFailure( false )
    , m_hasExpectationForSomeFailure( false )
    , m_hasParametersExpectationForAddFailure( false )
    , m_expectedAddFailureCallCount( 0 )
    , m_addFailureCall( 0 )
    , m_expectedFailedTest( NULL )
    , m_expectedException( NULL )
    , m_expectedIsError( false )
{
}


void 
MockTestListener::setExpectFailure( CPPUNIT_NS::Test *failedTest,
                                    CPPUNIT_NS::Exception *thrownException,
                                    bool isError )
{
  m_hasExpectationForAddFailure = true;
  m_hasParametersExpectationForAddFailure = true;
  m_expectedAddFailureCallCount = 1;
  m_expectedFailedTest = failedTest;
  m_expectedException = thrownException;
  m_expectedIsError = isError;
}


void 
MockTestListener::setExpectNoFailure()
{
  m_hasExpectationForAddFailure = true;
  m_expectedAddFailureCallCount = 0;
}


void 
MockTestListener::setExpectFailure()
{
  m_hasExpectationForSomeFailure = true;
}


void 
MockTestListener::setExpectedAddFailureCall( int callCount )
{
  m_hasExpectationForAddFailure = true;
  m_expectedAddFailureCallCount = callCount;
}


void 
MockTestListener::setExpectStartTest( CPPUNIT_NS::Test *test )
{
  m_hasExpectationForStartTest = true;
  m_hasParametersExpectationForStartTest = true;
  m_expectedStartTestCallCount = 1;
  m_expectedStartTest = test;
}


void 
MockTestListener::setExpectedStartTestCall( int callCount )
{
  m_hasExpectationForStartTest = true;
  m_expectedStartTestCallCount = callCount;
}


void 
MockTestListener::setExpectEndTest( CPPUNIT_NS::Test *test )
{
  m_hasExpectationForEndTest = true;
  m_hasParametersExpectationForEndTest = true;
  m_expectedEndTestCallCount = 1;
  m_expectedEndTest = test;
}


void 
MockTestListener::setExpectedEndTestCall( int callCount )
{
  m_hasExpectationForEndTest = true;
  m_expectedEndTestCallCount = callCount;
}


void 
MockTestListener::setExpectStartSuite( CPPUNIT_NS::Test *test )
{
  m_hasExpectationForStartSuite = true;
  m_hasParametersExpectationForStartSuite = true;
  m_expectedStartSuiteCallCount = 1;
  m_expectedStartSuite = test;
}


void 
MockTestListener::setExpectedStartSuiteCall( int callCount )
{
  m_hasExpectationForStartSuite = true;
  m_expectedStartSuiteCallCount = callCount;
}


void 
MockTestListener::setExpectEndSuite( CPPUNIT_NS::Test *test )
{
  m_hasExpectationForEndSuite = true;
  m_hasParametersExpectationForEndSuite = true;
  m_expectedEndSuiteCallCount = 1;
  m_expectedEndSuite = test;
}


void 
MockTestListener::setExpectedEndSuiteCall( int callCount )
{
  m_hasExpectationForEndSuite = true;
  m_expectedEndSuiteCallCount = callCount;
}


void 
MockTestListener::setExpectStartTestRun( CPPUNIT_NS::Test *test,
                                         CPPUNIT_NS::TestResult *eventManager )
{
  m_hasExpectationForStartTestRun = true;
  m_hasParametersExpectationForStartTestRun = true;
  m_expectedStartTestRunCallCount = 1;
  m_expectedStartTestRun = test;
  m_expectedStartTestRun2 = eventManager;
}


void 
MockTestListener::setExpectedStartTestRunCall( int callCount )
{
  m_hasExpectationForStartTestRun = true;
  m_expectedStartTestRunCallCount = callCount;
}


void 
MockTestListener::setExpectEndTestRun( CPPUNIT_NS::Test *test,
                                       CPPUNIT_NS::TestResult *eventManager )
{
  m_hasExpectationForEndTestRun = true;
  m_hasParametersExpectationForEndTestRun = true;
  m_expectedEndTestRunCallCount = 1;
  m_expectedEndTestRun = test;
  m_expectedEndTestRun2 = eventManager;
}


void 
MockTestListener::setExpectedEndTestRunCall( int callCount )
{
  m_hasExpectationForEndTestRun = true;
  m_expectedEndTestRunCallCount = callCount;
}


void 
MockTestListener::addFailure( const CPPUNIT_NS::TestFailure &failure )
{
  if ( m_hasExpectationForAddFailure  ||  m_hasExpectationForSomeFailure )
    ++m_addFailureCall;

  if ( m_hasExpectationForAddFailure )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_addFailureCall <= m_expectedAddFailureCallCount );
  }

  if ( m_hasParametersExpectationForAddFailure )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedFailedTest == failure.failedTest() );
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad thrownException",
                            m_expectedException == failure.thrownException() );
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad isError",
                            m_expectedIsError == failure.isError() );
  }
}


void 
MockTestListener::startTest( CPPUNIT_NS::Test *test )
{
  if ( m_hasExpectationForStartTest )
  {
    ++m_startTestCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_startTestCall <= m_expectedStartTestCallCount );
  
  }

  if ( m_hasParametersExpectationForStartTest )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedStartTest == test );
  }
}


void 
MockTestListener::endTest( CPPUNIT_NS::Test *test )
{
  if ( m_hasExpectationForEndTest )
  {
    ++m_endTestCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_endTestCall <= m_expectedEndTestCallCount );
  }

  if ( m_hasParametersExpectationForEndTest )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedEndTest == test );
  }
}


void 
MockTestListener::startSuite( CPPUNIT_NS::Test *test )
{
  if ( m_hasExpectationForStartSuite )
  {
    ++m_startSuiteCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_startSuiteCall <= m_expectedStartSuiteCallCount );
  }

  if ( m_hasParametersExpectationForStartSuite )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedStartSuite == test );
  }
}


void 
MockTestListener::endSuite( CPPUNIT_NS::Test *test )
{
  if ( m_hasExpectationForEndSuite )
  {
    ++m_endSuiteCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_endSuiteCall <= m_expectedEndSuiteCallCount );
  }

  if ( m_hasParametersExpectationForEndSuite )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedEndSuite == test );
  }
}


void 
MockTestListener::startTestRun( CPPUNIT_NS::Test *test, 
                                CPPUNIT_NS::TestResult *eventManager )
{
  if ( m_hasExpectationForStartTestRun )
  {
    ++m_startTestRunCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_startTestRunCall <= m_expectedStartTestRunCallCount );
  }

  if ( m_hasParametersExpectationForStartTestRun )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedStartTestRun == test );
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad eventManager",
                            m_expectedStartTestRun2 == eventManager );
  }
}


void 
MockTestListener::endTestRun( CPPUNIT_NS::Test *test, 
                              CPPUNIT_NS::TestResult *eventManager )
{
  if ( m_hasExpectationForEndTestRun )
  {
    ++m_endTestRunCall;
    CPPUNIT_ASSERT_MESSAGE( m_name + ": unexpected call",
                            m_endTestRunCall <= m_expectedEndTestRunCallCount );
  }

  if ( m_hasParametersExpectationForEndTestRun )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad test",
                            m_expectedEndTestRun == test );
    CPPUNIT_ASSERT_MESSAGE( m_name + ": bad eventManager",
                            m_expectedEndTestRun2 == eventManager );
  }
}


void 
MockTestListener::verify()
{
  if ( m_hasExpectationForStartTest )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startTest calls",
                                  m_expectedStartTestCallCount, 
                                  m_startTestCall );
  }

  if ( m_hasExpectationForEndTest )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endTest calls",
                                  m_expectedEndTestCallCount, 
                                  m_endTestCall );
  }

  if ( m_hasExpectationForStartSuite )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startSuite calls",
                                  m_expectedStartSuiteCallCount, 
                                  m_startSuiteCall );
  }

  if ( m_hasExpectationForEndSuite )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endSuite calls",
                                  m_expectedEndSuiteCallCount, 
                                  m_endSuiteCall );
  }

  if ( m_hasExpectationForStartTestRun )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing startTestRun calls",
                                  m_expectedStartTestRunCallCount, 
                                  m_startTestRunCall );
  }

  if ( m_hasExpectationForEndTestRun )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing endTestRun calls",
                                  m_expectedEndTestRunCallCount, 
                                  m_endTestRunCall );
  }

  if ( m_hasExpectationForAddFailure )
  {
    CPPUNIT_ASSERT_EQUAL_MESSAGE( m_name + ": missing addFailure calls",
                                  m_expectedAddFailureCallCount, 
                                  m_addFailureCall );
  }

  if ( m_hasExpectationForSomeFailure )
  {
    CPPUNIT_ASSERT_MESSAGE( m_name + ": there was no call to "
                                "MockTestListener::addFailure()",
                            m_addFailureCall > 0 );
  }
}