MockTest.h

//
// This is a test of CxxTest's Mock framework (not a mock test).
//
#include <cxxtest/TestSuite.h>

//
// Here are the "real" functions
//
static int one( void ) { return 1; }
static void two( int *p ) { *p = 2; }

namespace NameSpace 
{
    static int identity( int i ) { return i; }
    static double identity( double d ) { return d; }
}

class Opaque
{
public:
    explicit Opaque( int i ) : value( i ) {}
    int value;
};

static Opaque getOpaque( int i ) 
{
    return Opaque( i );
}

#define CXXTEST_MOCK_TEST_SOURCE_FILE
#include <cxxtest/Mock.h>

CXXTEST_MOCK_GLOBAL( int, one, ( void ), () );
CXXTEST_MOCK_VOID_GLOBAL( two, ( int *p ), ( p ) );

CXXTEST_MOCK( intIdentity, int, identity, ( int i ), NameSpace::identity, ( i ) );
CXXTEST_MOCK( doubleIdentity, double, identity, ( double i ), NameSpace::identity, ( i ) );

CXXTEST_MOCK_DEFAULT_VALUE( Opaque, Opaque( 42 ) );
CXXTEST_MOCK_GLOBAL( Opaque, getOpaque, ( int i ), ( i ) );

CXXTEST_SUPPLY_GLOBAL( int, supplyOne, ( void ), () );
CXXTEST_SUPPLY_VOID_GLOBAL( supplyTwo, ( int *p ), ( p ) );

CXXTEST_SUPPLY( SupplyThree, int, doSupplyThree, ( void ), supplyThree, () );
CXXTEST_SUPPLY_VOID( SupplyFour, doSupplyFour, ( int *p ), supplyFour, ( p ) );

class MockOne : public T::Base_one
{
public:
    MockOne( int i ) : result( i ) {}
    int result;
    int one() { return result; }
};

class MockIntIdentity : public T::Base_intIdentity
{
public:
    MockIntIdentity( int i ) : result( i ) {}
    int result;
    int identity( int ) { return result; }
};

class MockDoubleIdentity : public T::Base_doubleIdentity
{
public:
    MockDoubleIdentity( double d ) : result( d ) {}
    double result;
    double identity( double ) { return result; }
};

class MockGetOpaque : public T::Base_getOpaque
{
public:
    MockGetOpaque( int i ) : result( i ) {}
    Opaque result;
    Opaque getOpaque( int ) { return result; }
};

class SupplyOne : public T::Base_supplyOne
{
public:
    SupplyOne( int i ) : result( i ) {}
    int result;
    int supplyOne() { return result; }
};

class SupplyTwo : public T::Base_supplyTwo
{
public:
    SupplyTwo( int i ) : result( i ) {}
    int result;
    void supplyTwo( int *p ) { *p = result; }
};

class SupplyThree : public T::Base_SupplyThree
{
public:
    SupplyThree( int i ) : result( i ) {}
    int result;
    int doSupplyThree() { return result; }
};

class SupplyFour : public T::Base_SupplyFour
{
public:
    SupplyFour( int i ) : result( i ) {}
    int result;
    void doSupplyFour( int *p ) { *p = result; }
};

class MockTest : public CxxTest::TestSuite
{
public:
    void test_Mock()
    {
        MockOne mockOne( 2 );
        TS_ASSERT_EQUALS( T::one(), 2 );
    }

    void test_Real()
    {
        T::Real_one realOne;
        TS_ASSERT_EQUALS( T::one(), 1 );
    }

    void test_Unimplemented()
    {
        TS_ASSERT_EQUALS( T::one(), 1 );
    }

    void test_More_complex_mock()
    {
        MockIntIdentity mii( 53 );
        MockDoubleIdentity mdi ( 71 );

        TS_ASSERT_EQUALS( T::identity( (int)5 ), 53 );
        TS_ASSERT_EQUALS( T::identity( (double)5.0 ), 71 );
    }

    void test_Mock_traits()
    {
        TS_ASSERT_EQUALS( T::getOpaque( 3 ).value, 72 );
    }

    void test_Override()
    {
        MockOne *two = new MockOne( 2 );
        MockOne *three = new MockOne( 3 );
        MockOne *four = new MockOne( 4 );
        TS_ASSERT_EQUALS( T::one(), 4 );
        delete three;
        TS_ASSERT_EQUALS( T::one(), 4 );
        delete four;
        TS_ASSERT_EQUALS( T::one(), 2 );
        delete two;
        TS_ASSERT_EQUALS( T::one(), 1 );
    }

    void test_Supply()
    {
        SupplyOne s( 2 );
        TS_ASSERT_EQUALS( supplyOne(), 2 );
    }

    void test_Unimplemented_supply()
    {
        TS_ASSERT_EQUALS( supplyOne(), 1 );
    }

    void test_More_complex_supply()
    {
        SupplyThree st( 28 );
        SupplyFour sf( 53 );

        TS_ASSERT_EQUALS( supplyThree(), 28 );
        
        int i;
        supplyFour( &i );
        TS_ASSERT_EQUALS( i, 53 );
    }
};