Loading...
Searching...
No Matches
robottestingframework::FixtureManager Class Reference

The FixtureManager can be used to to setup any fixture which is required for the tests before executing the tests by a TestSuite. More...

`#include <robottestingframework/FixtureManager.h>`

## Public Member Functions

| FixtureManager (std::string param="")
| FixtureManager constructor The parameter string is parsed into (argc/argv) format and will be passed to the fixture manager using setup(int argc, char** argv).
| FixtureManager (FixtureEvents *dispatcher, std::string param="")
| FixtureManager constructor The parameter string is parsed into (argc/argv) format and will be passed to the fixture manager using setup(int argc, char** argv).
virtual | ~FixtureManager ()
| FixtureManager destructor.
bool | setup ()
| setup is called by a test suite.
virtual bool | setup (int argc, char **argv)
| setup is called to start the fixture manager
virtual void | tearDown ()
| tearDown is called after to stop the fixture manager
virtual bool | check ()
| check if the fixture is okay.
void | setDispatcher (FixtureEvents *dispatcher)
| setDispatcher Sets the FixtureEvents dispatcher
FixtureEvents * | getDispatcher ()
| getResult returns an instance of FixtureEvents dispatcher
void | setParam (const std::string param)
| setParam Sets the optional parameters of the fixture manager.
std::string | getParam ()
| getParam gets the original parameter string which is set for the fixture manager

## Private Attributes

std::string | param
FixtureEvents * | dispatcher

## Detailed Description

The FixtureManager can be used to to setup any fixture which is required for the tests before executing the tests by a TestSuite.

The `fixtureCollapsed` method of the FixtureEvents class is used by a fixture manager to inform any class which inherited from FixtureEvents that the corresponding fixture has been collapsed.

Here's an example of using a FixtureManager:

/*
* Robot Testing Framework
*
* Copyright (C) 2015-2019 Istituto Italiano di Tecnologia (IIT)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <robottestingframework/ConsoleListener.h>
#include <robottestingframework/FixtureManager.h>
#include <robottestingframework/TestAssert.h>
#include <robottestingframework/TestCase.h>
#include <robottestingframework/TestResult.h>
#include <robottestingframework/TestResultCollector.h>
#include <robottestingframework/TestRunner.h>
#include <robottestingframework/TestSuite.h>
#include <cstdio>
using namespace robottestingframework;
class MyTest1 : public TestCase
{
public:
MyTest1() :
TestCase("MyTest1")
{
}
void run() override
{
ROBOTTESTINGFRAMEWORK_TEST_REPORT("testing smaller");
ROBOTTESTINGFRAMEWORK_TEST_FAIL_IF_FALSE(3 < 5, "is not smaller");
}
};
class MyTest2 : public TestCase
{
public:
MyTest2() :
TestCase("MyTest2")
{
}
void run() override
{
ROBOTTESTINGFRAMEWORK_TEST_REPORT("testing equality");
ROBOTTESTINGFRAMEWORK_TEST_FAIL_IF_FALSE(3 == 3, "are not equal");
}
};
class MyFixture : public FixtureManager
{
public:
MyFixture(FixtureEvents* dispatcher) :
FixtureManager(dispatcher)
{
}
bool setup(int argc, char** argv) override
{
// setup and initialize the fixture
// ...
printf("Myfixture setup!\n");
// return true if everything is fine.
return true;
}
bool check() override
{
printf("Myfixture checking ...\n");
return true;
}
void tearDown() override
{
// uninitialize the fixture
// ...
printf("Myfixture tear down!\n");
// for an example if there is any error during tear down,
// throw an exception.
throw FixtureException(TestMessage("MyFixture cannot tear down!"));
}
};
int main(int argc, char** argv)
{
// create a test listener to collect the result
ConsoleListener listener(false);
// create a collector to get computer readable
// test results
TestResultCollector collector;
// create a test result and add the listeners
TestResult result;
result.addListener(&listener);
result.addListener(&collector);
// create a test suite
TestSuite suite("MyTestSuite");
// create a fixture manager for the test suite
MyFixture fixture(&suite);
suite.addFixtureManager(&fixture);
// creates test cases and add them to the suite
MyTest1 test1;
MyTest2 test2;
suite.addTest(&test1);
suite.addTest(&test2);
// create a test runner and run the tests
TestRunner runner;
runner.addTest(&suite);
runner.run(result);
// return the number of failed tests
return collector.failedCount();
}
ConsoleListener.h
FixtureManager.h
TestAssert.h
ROBOTTESTINGFRAMEWORK_TEST_FAIL_IF_FALSE
#define ROBOTTESTINGFRAMEWORK_TEST_FAIL_IF_FALSE(condition, message)
Conditional failure report.
Definition TestAssert.h:149
ROBOTTESTINGFRAMEWORK_TEST_REPORT
#define ROBOTTESTINGFRAMEWORK_TEST_REPORT(message)
Reporting a message to the TestResult.
Definition TestAssert.h:131
TestCase.h
TestResultCollector.h
TestResult.h
TestRunner.h
TestSuite.h
robottestingframework::ConsoleListener
class ConsoleListener listens to any messages reported by the tests during the test run,...
Definition ConsoleListener.h:39
robottestingframework::FixtureManager
The FixtureManager can be used to to setup any fixture which is required for the tests before executi...
Definition FixtureManager.h:64
robottestingframework::TestCase
The base class to implememnt a test case.
Definition TestCase.h:42
robottestingframework::TestCase::run
virtual void run()=0
run is called by the TestCase class if setup is successfull;
robottestingframework::TestResultCollector
The TestResultCollector class can be used to store all the events issued by the test cases,...
Definition TestResultCollector.h:44
robottestingframework::TestResultCollector::failedCount
unsigned int failedCount()
failedCount gets the number of failed test cases.
robottestingframework::TestResult
The TestResult class is used to deliver the test results including any error and failures produced by...
Definition TestResult.h:44
robottestingframework::TestResult::addListener
void addListener(TestListener *listener)
Adding a new listener.
robottestingframework::TestRunner
The TestRunner class runs the tests added as TestCase or TestSuite.
Definition TestRunner.h:42
robottestingframework::TestRunner::run
void run(TestResult &result)
Run all the tests in the list.
robottestingframework::TestRunner::addTest
void addTest(Test *test)
Adding a new test.
robottestingframework::TestSuite
The TestSuite holds a group of tests.
Definition TestSuite.h:55
robottestingframework
Definition Arguments.h:25

Examples
  simple_fixture.cpp.

Definition at line 63 of file FixtureManager.h.

## Constructor & Destructor Documentation

## FixtureManager() [1/2]

robottestingframework::FixtureManager::FixtureManager | ( | std::string | param = "" | ) |

FixtureManager constructor The parameter string is parsed into (argc/argv) format and will be passed to the fixture manager using setup(int argc, char** argv).

Parameters

  param | fixture manager optional parameters

## FixtureManager() [2/2]

robottestingframework::FixtureManager::FixtureManager | ( | FixtureEvents * | dispatcher,
|  | std::string | param = "" )

FixtureManager constructor The parameter string is parsed into (argc/argv) format and will be passed to the fixture manager using setup(int argc, char** argv).

Parameters

  dispatcher | an instance of FixtureEvents
  param | fixture manager optional parameters

## ~FixtureManager()

virtual robottestingframework::FixtureManager::~FixtureManager | ( |  | ) |

virtual

FixtureManager destructor.

## Member Function Documentation

## check()

virtual bool robottestingframework::FixtureManager::check | ( |  | ) |

virtual

check if the fixture is okay.

This is called automatically from the corresponding test suite to ensure the correctness of the fixture before running each test case.

Returns
  true or false depending of correctness of the fixture

## getDispatcher()

FixtureEvents * robottestingframework::FixtureManager::getDispatcher | ( |  | ) |

getResult returns an instance of FixtureEvents dispatcher

Returns
  an instance of TestResult

## getParam()

std::string robottestingframework::FixtureManager::getParam | ( |  | ) |

getParam gets the original parameter string which is set for the fixture manager

Returns
  a string parameter

## setDispatcher()

void robottestingframework::FixtureManager::setDispatcher | ( | FixtureEvents * | dispatcher | ) |

setDispatcher Sets the FixtureEvents dispatcher

Parameters

  dispatcher | an instance of FixtureEvents dispatcher

## setParam()

void robottestingframework::FixtureManager::setParam | ( | const std::string | param | ) |

setParam Sets the optional parameters of the fixture manager.

The parameter string is parsed into (argc/argv) format and will be passed to the fixture manager using setup(int argc, char** argv).

Parameters

  param | the parameter string

## setup() [1/2]

bool robottestingframework::FixtureManager::setup | ( |  | ) |

setup is called by a test suite.

The setup() function parses the fixture paramteres and call the setup(int argc, char**argv) which can be ovveriden by the user customized fixture manager.

Returns
  true or false depending of the test initialization

## setup() [2/2]

virtual bool robottestingframework::FixtureManager::setup | ( | int | argc,
|  | char ** | argv )

virtual

setup is called to start the fixture manager

Parameters

  argc | The number of the pasred argument from string parameter
  argv | The arguments which is parsed using string parameter

Returns
  true or false depending of the fixture initialization

## tearDown()

virtual void robottestingframework::FixtureManager::tearDown | ( |  | ) |

virtual

tearDown is called after to stop the fixture manager

## Member Data Documentation

## dispatcher

FixtureEvents* robottestingframework::FixtureManager::dispatcher

private

Definition at line 148 of file FixtureManager.h.

## param

std::string robottestingframework::FixtureManager::param

private

Definition at line 147 of file FixtureManager.h.

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

- src/robottestingframework/include/robottestingframework/FixtureManager.h