2011-12-28 11:23:32 +01:00
|
|
|
/*
|
2010-11-10 00:24:00 +01:00
|
|
|
* Created by Phil on 22/10/2010.
|
|
|
|
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
|
|
|
|
*
|
|
|
|
* Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
|
|
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
*/
|
2012-09-17 07:42:29 +02:00
|
|
|
#ifndef TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
|
|
|
|
#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2011-01-11 10:13:31 +01:00
|
|
|
#include "catch_interfaces_runner.h"
|
2010-12-31 23:46:51 +01:00
|
|
|
#include "catch_interfaces_reporter.h"
|
2012-05-11 09:16:39 +02:00
|
|
|
#include "catch_interfaces_exception.h"
|
2011-01-01 01:29:58 +01:00
|
|
|
#include "catch_config.hpp"
|
2011-01-05 22:16:54 +01:00
|
|
|
#include "catch_test_registry.hpp"
|
2012-08-14 20:30:30 +02:00
|
|
|
#include "catch_test_case_info.h"
|
2010-11-10 00:24:00 +01:00
|
|
|
#include "catch_capture.hpp"
|
2012-02-23 09:49:52 +01:00
|
|
|
#include "catch_totals.hpp"
|
2012-05-05 20:32:52 +02:00
|
|
|
#include "catch_running_test.hpp"
|
2012-08-14 20:35:30 +02:00
|
|
|
#include "catch_test_spec.h"
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2011-02-08 09:42:05 +01:00
|
|
|
#include <set>
|
|
|
|
#include <string>
|
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
namespace Catch {
|
|
|
|
|
|
|
|
class StreamRedirect {
|
|
|
|
|
2011-02-21 09:50:05 +01:00
|
|
|
public:
|
2012-05-16 09:02:20 +02:00
|
|
|
StreamRedirect( std::ostream& stream, std::string& targetString )
|
2011-02-21 09:50:05 +01:00
|
|
|
: m_stream( stream ),
|
|
|
|
m_prevBuf( stream.rdbuf() ),
|
2012-05-16 09:02:20 +02:00
|
|
|
m_targetString( targetString )
|
2011-02-21 09:50:05 +01:00
|
|
|
{
|
|
|
|
stream.rdbuf( m_oss.rdbuf() );
|
|
|
|
}
|
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
~StreamRedirect() {
|
2011-12-28 11:23:32 +01:00
|
|
|
m_targetString += m_oss.str();
|
2011-02-21 09:50:05 +01:00
|
|
|
m_stream.rdbuf( m_prevBuf );
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::ostream& m_stream;
|
|
|
|
std::streambuf* m_prevBuf;
|
|
|
|
std::ostringstream m_oss;
|
|
|
|
std::string& m_targetString;
|
|
|
|
};
|
|
|
|
|
2011-01-28 19:56:26 +01:00
|
|
|
///////////////////////////////////////////////////////////////////////////
|
2012-05-16 09:02:20 +02:00
|
|
|
|
|
|
|
class Runner : public IResultCapture, public IRunner {
|
|
|
|
|
2010-12-30 00:18:16 +01:00
|
|
|
Runner( const Runner& );
|
|
|
|
void operator =( const Runner& );
|
|
|
|
|
2010-11-10 00:24:00 +01:00
|
|
|
public:
|
2011-01-11 20:48:48 +01:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
explicit Runner( const Config& config, const Ptr<IReporter>& reporter )
|
2012-05-21 19:52:09 +02:00
|
|
|
: m_context( getCurrentMutableContext() ),
|
|
|
|
m_runningTest( NULL ),
|
2011-02-21 09:50:05 +01:00
|
|
|
m_config( config ),
|
2012-07-16 09:58:28 +02:00
|
|
|
m_reporter( reporter ),
|
2012-05-21 19:52:09 +02:00
|
|
|
m_prevRunner( &m_context.getRunner() ),
|
2012-06-08 09:22:56 +02:00
|
|
|
m_prevResultCapture( &m_context.getResultCapture() ),
|
|
|
|
m_prevConfig( m_context.getConfig() )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
2012-05-21 19:52:09 +02:00
|
|
|
m_context.setRunner( this );
|
2012-06-05 21:50:47 +02:00
|
|
|
m_context.setConfig( &m_config );
|
2012-05-21 19:52:09 +02:00
|
|
|
m_context.setResultCapture( this );
|
2010-11-29 20:40:44 +01:00
|
|
|
m_reporter->StartTesting();
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|
2012-08-13 08:46:10 +02:00
|
|
|
virtual ~Runner() {
|
2012-02-24 09:59:35 +01:00
|
|
|
m_reporter->EndTesting( m_totals );
|
2012-05-21 19:52:09 +02:00
|
|
|
m_context.setRunner( m_prevRunner );
|
2012-06-05 21:50:47 +02:00
|
|
|
m_context.setConfig( NULL );
|
2012-05-21 19:52:09 +02:00
|
|
|
m_context.setResultCapture( m_prevResultCapture );
|
2012-06-08 09:22:56 +02:00
|
|
|
m_context.setConfig( m_prevConfig );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
2012-07-16 09:58:28 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
Totals runMatching( const std::string& testSpec ) {
|
2012-07-16 09:58:28 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
std::vector<TestCaseInfo> matchingTests = getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec );
|
2012-08-15 20:12:51 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
Totals totals;
|
2012-08-15 20:12:51 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
m_reporter->StartGroup( testSpec );
|
2012-08-15 20:12:51 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
std::vector<TestCaseInfo>::const_iterator it = matchingTests.begin();
|
|
|
|
std::vector<TestCaseInfo>::const_iterator itEnd = matchingTests.end();
|
|
|
|
for(; it != itEnd; ++it )
|
|
|
|
totals += runTest( *it );
|
|
|
|
// !TBD use std::accumulate?
|
2012-08-15 20:12:51 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
m_reporter->EndGroup( testSpec, totals );
|
2012-08-15 20:12:51 +02:00
|
|
|
return totals;
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
2012-08-15 20:12:51 +02:00
|
|
|
|
|
|
|
Totals runTest( const TestCaseInfo& testInfo ) {
|
2012-02-23 09:49:52 +01:00
|
|
|
Totals prevTotals = m_totals;
|
2011-01-19 20:30:01 +01:00
|
|
|
|
|
|
|
std::string redirectedCout;
|
|
|
|
std::string redirectedCerr;
|
|
|
|
|
|
|
|
m_reporter->StartTestCase( testInfo );
|
|
|
|
|
2011-02-21 09:50:05 +01:00
|
|
|
m_runningTest = new RunningTest( &testInfo );
|
2010-11-30 07:48:21 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
do {
|
|
|
|
do {
|
2012-05-08 20:16:18 +02:00
|
|
|
m_currentResult.setLineInfo( m_runningTest->getTestCaseInfo().getLineInfo() );
|
2011-01-27 00:23:33 +01:00
|
|
|
runCurrentTest( redirectedCout, redirectedCerr );
|
|
|
|
}
|
2012-06-01 20:40:27 +02:00
|
|
|
while( m_runningTest->hasUntestedSections() && !aborting() );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
2012-06-01 20:40:27 +02:00
|
|
|
while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
|
2011-01-19 09:52:25 +01:00
|
|
|
|
2011-02-21 09:50:05 +01:00
|
|
|
delete m_runningTest;
|
|
|
|
m_runningTest = NULL;
|
2011-01-19 20:30:01 +01:00
|
|
|
|
2012-05-22 09:56:11 +02:00
|
|
|
Totals deltaTotals = m_totals.delta( prevTotals );
|
|
|
|
m_totals.testCases += deltaTotals.testCases;
|
|
|
|
m_reporter->EndTestCase( testInfo, deltaTotals, redirectedCout, redirectedCerr );
|
2012-08-15 20:12:51 +02:00
|
|
|
return deltaTotals;
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
2012-02-17 20:50:59 +01:00
|
|
|
|
2012-06-05 21:50:47 +02:00
|
|
|
const Config& config() const {
|
|
|
|
return m_config;
|
|
|
|
}
|
|
|
|
|
2011-01-11 10:13:31 +01:00
|
|
|
private: // IResultCapture
|
2010-12-31 21:49:58 +01:00
|
|
|
|
2012-10-17 09:14:22 +02:00
|
|
|
virtual void acceptAssertionInfo( const AssertionInfo& assertionInfo ) {
|
|
|
|
m_assertionInfo = assertionInfo;
|
|
|
|
}
|
2012-10-18 23:59:16 +02:00
|
|
|
|
2012-10-16 09:31:05 +02:00
|
|
|
virtual ResultAction::Value acceptExpression( const AssertionResultBuilder& assertionResult ) {
|
|
|
|
m_currentResult = assertionResult;
|
2011-03-15 19:01:44 +01:00
|
|
|
return actOnCurrentResult();
|
2010-12-31 21:49:58 +01:00
|
|
|
}
|
|
|
|
|
2012-10-16 09:27:21 +02:00
|
|
|
virtual void testEnded( const AssertionResult& result ) {
|
2012-05-16 09:02:20 +02:00
|
|
|
if( result.getResultType() == ResultWas::Ok ) {
|
2012-02-23 09:49:52 +01:00
|
|
|
m_totals.assertions.passed++;
|
2010-12-27 23:18:33 +01:00
|
|
|
}
|
2012-05-16 09:02:20 +02:00
|
|
|
else if( !result.ok() ) {
|
2012-02-23 09:49:52 +01:00
|
|
|
m_totals.assertions.failed++;
|
2010-12-27 23:18:33 +01:00
|
|
|
|
2012-09-24 09:28:23 +02:00
|
|
|
{
|
|
|
|
std::vector<ScopedInfo*>::const_iterator it = m_scopedInfos.begin();
|
|
|
|
std::vector<ScopedInfo*>::const_iterator itEnd = m_scopedInfos.end();
|
|
|
|
for(; it != itEnd; ++it )
|
|
|
|
m_reporter->Result( (*it)->getInfo() );
|
|
|
|
}
|
|
|
|
{
|
2012-10-16 09:27:21 +02:00
|
|
|
std::vector<AssertionResult>::const_iterator it = m_info.begin();
|
|
|
|
std::vector<AssertionResult>::const_iterator itEnd = m_info.end();
|
2012-09-24 09:28:23 +02:00
|
|
|
for(; it != itEnd; ++it )
|
|
|
|
m_reporter->Result( *it );
|
|
|
|
}
|
2010-12-27 23:18:33 +01:00
|
|
|
m_info.clear();
|
2010-12-27 23:05:13 +01:00
|
|
|
}
|
2010-12-27 23:18:33 +01:00
|
|
|
|
2010-12-27 23:05:13 +01:00
|
|
|
if( result.getResultType() == ResultWas::Info )
|
|
|
|
m_info.push_back( result );
|
|
|
|
else
|
|
|
|
m_reporter->Result( result );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
2012-06-01 20:40:27 +02:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual bool sectionStarted (
|
2011-01-11 20:48:48 +01:00
|
|
|
const std::string& name,
|
2011-04-21 20:43:55 +02:00
|
|
|
const std::string& description,
|
2012-05-08 20:16:18 +02:00
|
|
|
const SourceLineInfo& lineInfo,
|
2012-02-23 09:57:51 +01:00
|
|
|
Counts& assertions
|
2011-01-11 20:48:48 +01:00
|
|
|
)
|
2010-11-29 20:40:44 +01:00
|
|
|
{
|
2011-04-21 20:43:55 +02:00
|
|
|
std::ostringstream oss;
|
2012-05-08 20:16:18 +02:00
|
|
|
oss << name << "@" << lineInfo;
|
2011-04-21 20:43:55 +02:00
|
|
|
|
|
|
|
if( !m_runningTest->addSection( oss.str() ) )
|
2011-01-19 09:52:25 +01:00
|
|
|
return false;
|
|
|
|
|
2012-05-08 20:16:18 +02:00
|
|
|
m_currentResult.setLineInfo( lineInfo );
|
2010-11-29 20:40:44 +01:00
|
|
|
m_reporter->StartSection( name, description );
|
2012-02-23 09:57:51 +01:00
|
|
|
assertions = m_totals.assertions;
|
2010-11-29 23:52:27 +01:00
|
|
|
|
2010-11-29 20:40:44 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual void sectionEnded( const std::string& name, const Counts& prevAssertions ) {
|
2012-08-31 09:10:36 +02:00
|
|
|
Counts assertions = m_totals.assertions - prevAssertions;
|
|
|
|
if( assertions.total() == 0 &&
|
|
|
|
( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
|
|
|
|
!m_runningTest->isBranchSection() ) {
|
|
|
|
m_reporter->NoAssertionsInSection( name );
|
|
|
|
m_totals.assertions.failed++;
|
|
|
|
assertions.failed++;
|
|
|
|
}
|
2011-02-21 09:50:05 +01:00
|
|
|
m_runningTest->endSection( name );
|
2012-08-31 09:10:36 +02:00
|
|
|
m_reporter->EndSection( name, assertions );
|
2010-11-29 20:40:44 +01:00
|
|
|
}
|
2010-12-27 12:09:34 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual void pushScopedInfo( ScopedInfo* scopedInfo ) {
|
2010-12-27 12:09:34 +01:00
|
|
|
m_scopedInfos.push_back( scopedInfo );
|
|
|
|
}
|
2011-01-11 20:48:48 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual void popScopedInfo( ScopedInfo* scopedInfo ) {
|
2010-12-27 12:09:34 +01:00
|
|
|
if( m_scopedInfos.back() == scopedInfo )
|
|
|
|
m_scopedInfos.pop_back();
|
|
|
|
}
|
2011-01-11 20:48:48 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual bool shouldDebugBreak() const {
|
2010-12-27 21:49:19 +01:00
|
|
|
return m_config.shouldDebugBreak();
|
|
|
|
}
|
2011-01-27 00:23:33 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
virtual std::string getCurrentTestName() const {
|
2011-02-21 09:50:05 +01:00
|
|
|
return m_runningTest
|
|
|
|
? m_runningTest->getTestCaseInfo().getName()
|
|
|
|
: "";
|
2011-01-27 00:23:33 +01:00
|
|
|
}
|
2012-02-10 09:30:13 +01:00
|
|
|
|
2012-10-16 09:27:21 +02:00
|
|
|
virtual const AssertionResult* getLastResult() const {
|
2012-02-10 09:30:13 +01:00
|
|
|
return &m_lastResult;
|
|
|
|
}
|
2012-06-01 20:40:27 +02:00
|
|
|
|
2012-08-23 21:08:50 +02:00
|
|
|
public:
|
|
|
|
// !TBD We need to do this another way!
|
2012-06-01 20:40:27 +02:00
|
|
|
bool aborting() const {
|
2012-06-03 00:08:07 +02:00
|
|
|
return m_totals.assertions.failed == static_cast<std::size_t>( m_config.getCutoff() );
|
2012-06-01 20:40:27 +02:00
|
|
|
}
|
2012-08-23 21:08:50 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
ResultAction::Value actOnCurrentResult() {
|
2012-10-17 09:14:22 +02:00
|
|
|
m_currentResult
|
|
|
|
.setMacroName( m_assertionInfo.macroName )
|
|
|
|
.setLineInfo( m_assertionInfo.lineInfo )
|
|
|
|
.setCapturedExpression( m_assertionInfo.capturedExpression );
|
|
|
|
|
2012-10-05 19:35:01 +02:00
|
|
|
m_lastResult = m_currentResult.build();
|
|
|
|
testEnded( m_lastResult );
|
|
|
|
|
2012-10-16 09:27:21 +02:00
|
|
|
m_currentResult = AssertionResultBuilder();
|
2012-10-17 09:14:22 +02:00
|
|
|
m_assertionInfo = AssertionInfo();
|
2012-06-01 20:40:27 +02:00
|
|
|
|
|
|
|
ResultAction::Value action = ResultAction::None;
|
|
|
|
|
|
|
|
if( !m_lastResult.ok() ) {
|
|
|
|
action = ResultAction::Failed;
|
|
|
|
if( shouldDebugBreak() )
|
|
|
|
action = (ResultAction::Value)( action | ResultAction::Debug );
|
|
|
|
if( aborting() )
|
|
|
|
action = (ResultAction::Value)( action | ResultAction::Abort );
|
|
|
|
}
|
|
|
|
return action;
|
2011-03-15 19:01:44 +01:00
|
|
|
}
|
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
|
|
|
|
try {
|
2011-02-21 09:50:05 +01:00
|
|
|
m_runningTest->reset();
|
2012-08-31 09:10:36 +02:00
|
|
|
Counts prevAssertions = m_totals.assertions;
|
2012-05-16 09:02:20 +02:00
|
|
|
if( m_reporter->shouldRedirectStdout() ) {
|
2012-02-17 10:28:21 +01:00
|
|
|
StreamRedirect coutRedir( std::cout, redirectedCout );
|
|
|
|
StreamRedirect cerrRedir( std::cerr, redirectedCerr );
|
|
|
|
m_runningTest->getTestCaseInfo().invoke();
|
|
|
|
}
|
2012-05-16 09:02:20 +02:00
|
|
|
else {
|
2012-02-17 10:28:21 +01:00
|
|
|
m_runningTest->getTestCaseInfo().invoke();
|
|
|
|
}
|
2012-08-31 09:10:36 +02:00
|
|
|
Counts assertions = m_totals.assertions - prevAssertions;
|
|
|
|
if( assertions.total() == 0 &&
|
|
|
|
( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
|
|
|
|
!m_runningTest->hasSections() ) {
|
|
|
|
m_totals.assertions.failed++;
|
|
|
|
m_reporter->NoAssertionsInTestCase( m_runningTest->getTestCaseInfo().getName() );
|
|
|
|
}
|
2011-02-21 09:50:05 +01:00
|
|
|
m_runningTest->ranToCompletion();
|
2011-01-19 09:52:25 +01:00
|
|
|
}
|
2012-05-16 09:02:20 +02:00
|
|
|
catch( TestFailureException& ) {
|
2011-01-19 09:52:25 +01:00
|
|
|
// This just means the test was aborted due to failure
|
|
|
|
}
|
2012-05-16 09:02:20 +02:00
|
|
|
catch(...) {
|
2012-10-18 09:39:44 +02:00
|
|
|
m_currentResult
|
|
|
|
.setResultType( ResultWas::ThrewException )
|
|
|
|
<< translateActiveException();
|
|
|
|
actOnCurrentResult();
|
2011-01-19 09:52:25 +01:00
|
|
|
}
|
|
|
|
m_info.clear();
|
|
|
|
}
|
2012-05-10 22:46:46 +02:00
|
|
|
|
2010-11-10 00:24:00 +01:00
|
|
|
private:
|
2012-05-21 19:52:09 +02:00
|
|
|
IMutableContext& m_context;
|
2011-02-21 09:50:05 +01:00
|
|
|
RunningTest* m_runningTest;
|
2012-10-16 09:27:21 +02:00
|
|
|
AssertionResultBuilder m_currentResult;
|
|
|
|
AssertionResult m_lastResult;
|
2010-12-31 21:49:58 +01:00
|
|
|
|
2011-01-01 01:20:14 +01:00
|
|
|
const Config& m_config;
|
2012-02-23 09:49:52 +01:00
|
|
|
Totals m_totals;
|
2012-05-04 08:55:11 +02:00
|
|
|
Ptr<IReporter> m_reporter;
|
2010-12-27 12:09:34 +01:00
|
|
|
std::vector<ScopedInfo*> m_scopedInfos;
|
2012-10-16 09:27:21 +02:00
|
|
|
std::vector<AssertionResult> m_info;
|
2011-01-14 09:26:58 +01:00
|
|
|
IRunner* m_prevRunner;
|
|
|
|
IResultCapture* m_prevResultCapture;
|
2012-06-08 09:22:56 +02:00
|
|
|
const IConfig* m_prevConfig;
|
2012-10-17 09:14:22 +02:00
|
|
|
AssertionInfo m_assertionInfo;
|
2010-11-10 00:24:00 +01:00
|
|
|
};
|
2012-05-21 19:52:09 +02:00
|
|
|
|
|
|
|
} // end namespace Catch
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2012-09-17 07:42:29 +02:00
|
|
|
#endif // TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
|