CppUnit project page FAQ CppUnit home page

Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

TestCaller Class Template Reference
[Writing test fixture]

Generate a test case from a fixture method. More...

#include <TestCaller.h>

Inheritance diagram for TestCaller:

Inheritance graph
[legend]
Collaboration diagram for TestCaller:

Collaboration graph
[legend]
List of all members.

Public Methods

 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. More...

void setUp ()
 \brief Set up context before running a test. More...

void tearDown ()
 Clean up after the test run. More...

std::string toString () const

Private Types

typedef void(Fixture::* TestMethod )()

Private Methods

 TestCaller (const TestCaller &other)
TestCaller & operator= (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::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.

Reimplemented from TestCase.

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

\brief 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::m_fixture [private]
 

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

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


The documentation for this class was generated from the following file:
SourceForge Logo hosts this site. Send comments to:
CppUnit Developers