CppUnit project page FAQ CppUnit home page

TestCaller< Fixture > Class Template Reference
[Writing test fixture]

Generate a test case from a fixture method.

A test caller provides access to a test case method on a test fixture class. Test callers are useful when you want to run an individual test or add it to a suite. Test Callers invoke only one Test (i.e. test method) on one Fixture of a TestFixture. More...

#include <TestCaller.h>

Inheritance diagram for TestCaller< Fixture >:

Inheritance graph
[legend]
Collaboration diagram for TestCaller< Fixture >:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 TestCaller (std::string name, TestMethod test)
 TestCaller (std::string name, TestMethod test, Fixture &fixture)
 TestCaller (std::string name, TestMethod test, Fixture *fixture)
 ~TestCaller ()
void runTest ()
 FIXME: this should probably be pure virtual.
void setUp ()
 Set up context before running a test.
void tearDown ()
 Clean up after the test run.
std::string toString () const

Private Types

typedef void(Fixture::* TestMethod )()

Private Member Functions

 TestCaller (const TestCaller &other)
TestCalleroperator= (const TestCaller &other)

Private Attributes

bool m_ownFixture
Fixture * m_fixture
TestMethod m_test


Detailed Description

template<class Fixture>
class TestCaller< Fixture >

Generate a test case from a fixture method.

A test caller provides access to a test case method on a test fixture class. Test callers are useful when you want to run an individual test or add it to a suite. Test Callers invoke only one Test (i.e. test method) on one Fixture of a TestFixture.

Here is an example:

 class MathTest : public CppUnit::TestFixture {
         ...
     public:
         void         setUp();
         void         tearDown();

         void         testAdd();
         void         testSubtract();
 };

 CppUnit::Test *MathTest::suite() {
     CppUnit::TestSuite *suite = new CppUnit::TestSuite;

     suite->addTest( new CppUnit::TestCaller<MathTest>( "testAdd", testAdd ) );
     return suite;
 }

You can use a TestCaller to bind any test method on a TestFixture class, as long as it accepts void and returns void.

See also:
TestCase

Member Typedef Documentation

template<class Fixture >
typedef void(Fixture::* TestCaller< Fixture >::TestMethod)() [private]


Constructor & Destructor Documentation

template<class Fixture >
TestCaller< Fixture >::TestCaller ( std::string  name,
TestMethod  test 
) [inline]

Constructor for TestCaller. This constructor builds a new Fixture instance owned by the TestCaller.

Parameters:
name name of this TestCaller
test the method this TestCaller calls in runTest()

template<class Fixture >
TestCaller< Fixture >::TestCaller ( std::string  name,
TestMethod  test,
Fixture &  fixture 
) [inline]

Constructor for TestCaller. This constructor does not create a new Fixture instance but accepts an existing one as parameter. The TestCaller will not own the Fixture object.

Parameters:
name name of this TestCaller
test the method this TestCaller calls in runTest()
fixture the Fixture to invoke the test method on.

template<class Fixture >
TestCaller< Fixture >::TestCaller ( std::string  name,
TestMethod  test,
Fixture *  fixture 
) [inline]

Constructor for TestCaller. This constructor does not create a new Fixture instance but accepts an existing one as parameter. The TestCaller will own the Fixture object and delete it in its destructor.

Parameters:
name name of this TestCaller
test the method this TestCaller calls in runTest()
fixture the Fixture to invoke the test method on.

template<class Fixture >
TestCaller< Fixture >::~TestCaller (  )  [inline]

template<class Fixture >
TestCaller< Fixture >::TestCaller ( const TestCaller< Fixture > &  other  )  [private]


Member Function Documentation

template<class Fixture >
TestCaller& TestCaller< Fixture >::operator= ( const TestCaller< Fixture > &  other  )  [private]

template<class Fixture >
void TestCaller< Fixture >::runTest (  )  [inline, virtual]

FIXME: this should probably be pure virtual.

All the work for runTest is deferred to subclasses.

Reimplemented from TestCase.

template<class Fixture >
void TestCaller< Fixture >::setUp (  )  [inline, virtual]

Set up context before running a test.

Reimplemented from TestFixture.

template<class Fixture >
void TestCaller< Fixture >::tearDown (  )  [inline, virtual]

Clean up after the test run.

Reimplemented from TestFixture.

template<class Fixture >
std::string TestCaller< Fixture >::toString (  )  const [inline]


Member Data Documentation

template<class Fixture >
Fixture* TestCaller< Fixture >::m_fixture [private]

template<class Fixture >
bool TestCaller< Fixture >::m_ownFixture [private]

template<class Fixture >
TestMethod TestCaller< Fixture >::m_test [private]


The documentation for this class was generated from the following file:

SourceForge Logo hosts this site. Send comments to:
CppUnit Developers