CppUnit project page | FAQ | CppUnit home page

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

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

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

`#include <TestCaller.h>`

Inheritance diagram for TestCaller< Fixture >:

[legend]
Collaboration diagram for TestCaller< Fixture >:

[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)
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< 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>

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]`

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]`

template<class Fixture>

TestCaller& TestCaller< Fixture >::operator= | ( | const TestCaller< Fixture > & | other | ) | `[private]`

## Member Data Documentation

template<class Fixture>

bool TestCaller< Fixture >::m_ownFixture`[private]`

template<class Fixture>

Fixture* TestCaller< Fixture >::m_fixture`[private]`

template<class Fixture>

TestMethod TestCaller< Fixture >::m_test`[private]`

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

- TestCaller.h

| hosts this site. |  | Send comments to: CppUnit Developers