catch2/include/internal/catch_runner_impl.hpp

307 lines
11 KiB
C++
Raw Normal View History

/*
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)
*/
#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"
#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"
#include "catch_totals.hpp"
#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() {
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 )
: m_context( getCurrentMutableContext() ),
m_runningTest( NULL ),
2011-02-21 09:50:05 +01:00
m_config( config ),
m_reporter( reporter ),
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
{
m_context.setRunner( this );
m_context.setConfig( &m_config );
m_context.setResultCapture( this );
m_reporter->StartTesting();
2010-11-10 00:24:00 +01:00
}
virtual ~Runner() {
m_reporter->EndTesting( m_totals );
m_context.setRunner( m_prevRunner );
m_context.setConfig( NULL );
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-08-23 21:08:50 +02:00
Totals runMatching( const std::string& testSpec ) {
2012-08-23 21:08:50 +02:00
std::vector<TestCaseInfo> matchingTests = getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec );
2012-08-23 21:08:50 +02:00
Totals totals;
2012-08-23 21:08:50 +02:00
m_reporter->StartGroup( testSpec );
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-23 21:08:50 +02:00
m_reporter->EndGroup( testSpec, totals );
return totals;
2010-11-10 00:24:00 +01:00
}
Totals runTest( const TestCaseInfo& testInfo ) {
Totals prevTotals = m_totals;
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 {
2011-01-27 00:23:33 +01:00
runCurrentTest( redirectedCout, redirectedCerr );
}
while( m_runningTest->hasUntestedSections() && !aborting() );
2010-11-10 00:24:00 +01:00
}
while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
Totals deltaTotals = m_totals.delta( prevTotals );
if( deltaTotals.assertions.total() == 0 &&
( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) ) {
m_totals.assertions.failed++;
deltaTotals = m_totals.delta( prevTotals );
m_reporter->NoAssertionsInTestCase( m_runningTest->getTestCaseInfo().getName() );
}
m_totals.testCases += deltaTotals.testCases;
m_reporter->EndTestCase( testInfo, deltaTotals, redirectedCout, redirectedCerr );
2011-02-21 09:50:05 +01:00
delete m_runningTest;
m_runningTest = NULL;
return deltaTotals;
2010-11-10 00:24:00 +01:00
}
const Config& config() const {
return m_config;
}
2011-01-11 10:13:31 +01:00
private: // IResultCapture
2012-10-29 20:55:13 +01:00
virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult, const AssertionInfo& assertionInfo ) {
m_lastAssertionInfo = assertionInfo;
return actOnCurrentResult( assertionResult.buildResult( assertionInfo ) );
}
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 ) {
m_totals.assertions.passed++;
}
2012-11-13 10:44:52 +01:00
else if( !result.isOk() ) {
m_totals.assertions.failed++;
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)->buildResult( m_lastAssertionInfo ) );
2012-09-24 09:28:23 +02:00
}
{
2012-10-26 10:05:36 +02:00
std::vector<AssertionResult>::const_iterator it = m_assertionResults.begin();
std::vector<AssertionResult>::const_iterator itEnd = m_assertionResults.end();
2012-09-24 09:28:23 +02:00
for(; it != itEnd; ++it )
m_reporter->Result( *it );
}
2012-10-26 10:05:36 +02:00
m_assertionResults.clear();
2010-12-27 23:05:13 +01:00
}
2010-12-27 23:05:13 +01:00
if( result.getResultType() == ResultWas::Info )
{
2012-10-26 10:05:36 +02:00
m_assertionResults.push_back( result );
m_totals.assertions.info++;
}
2010-12-27 23:05:13 +01:00
else
m_reporter->Result( result );
// Reset AssertionInfo
m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after this line}" , m_lastAssertionInfo.resultDisposition );
2010-11-10 00:24:00 +01:00
}
2012-05-16 09:02:20 +02:00
virtual bool sectionStarted (
2011-01-11 20:48:48 +01:00
const std::string& name,
const std::string& description,
const SourceLineInfo& lineInfo,
Counts& assertions
2011-01-11 20:48:48 +01:00
)
{
std::ostringstream oss;
oss << name << "@" << lineInfo;
if( !m_runningTest->addSection( oss.str() ) )
return false;
m_lastAssertionInfo.lineInfo = lineInfo;
m_reporter->StartSection( name, description );
assertions = m_totals.assertions;
2010-11-29 23:52:27 +01:00
return true;
}
2012-05-16 09:02:20 +02:00
virtual void sectionEnded( const std::string& name, const Counts& prevAssertions ) {
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 );
m_reporter->EndSection( name, assertions );
}
2012-05-16 09:02:20 +02:00
virtual void pushScopedInfo( ScopedInfo* scopedInfo ) {
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 ) {
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 {
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-08-23 21:08:50 +02:00
public:
// !TBD We need to do this another way!
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-08-23 21:08:50 +02:00
private:
ResultAction::Value actOnCurrentResult( const AssertionResult& result ) {
m_lastResult = result;
testEnded( m_lastResult );
ResultAction::Value action = ResultAction::None;
2012-11-13 10:44:52 +01:00
if( !m_lastResult.isOk() ) {
action = ResultAction::Failed;
if( shouldDebugBreak() )
action = (ResultAction::Value)( action | ResultAction::Debug );
if( aborting() )
action = (ResultAction::Value)( action | ResultAction::Abort );
}
return action;
}
2012-05-16 09:02:20 +02:00
void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
try {
2012-11-13 10:44:52 +01:00
m_lastAssertionInfo = AssertionInfo( "TEST_CASE", m_runningTest->getTestCaseInfo().getLineInfo(), "", ResultDisposition::Normal );
2011-02-21 09:50:05 +01:00
m_runningTest->reset();
2012-05-16 09:02:20 +02:00
if( m_reporter->shouldRedirectStdout() ) {
StreamRedirect coutRedir( std::cout, redirectedCout );
StreamRedirect cerrRedir( std::cerr, redirectedCerr );
m_runningTest->getTestCaseInfo().invoke();
}
2012-05-16 09:02:20 +02:00
else {
m_runningTest->getTestCaseInfo().invoke();
}
2011-02-21 09:50:05 +01:00
m_runningTest->ranToCompletion();
}
2012-05-16 09:02:20 +02:00
catch( TestFailureException& ) {
// This just means the test was aborted due to failure
}
2012-05-16 09:02:20 +02:00
catch(...) {
ExpressionResultBuilder exResult( ResultWas::ThrewException );
exResult << translateActiveException();
actOnCurrentResult( exResult.buildResult( m_lastAssertionInfo ) );
}
2012-10-26 10:05:36 +02:00
m_assertionResults.clear();
}
2012-05-10 22:46:46 +02:00
2010-11-10 00:24:00 +01:00
private:
IMutableContext& m_context;
2011-02-21 09:50:05 +01:00
RunningTest* m_runningTest;
2012-10-16 09:27:21 +02:00
AssertionResult m_lastResult;
const Config& m_config;
Totals m_totals;
Ptr<IReporter> m_reporter;
std::vector<ScopedInfo*> m_scopedInfos;
2012-10-26 10:05:36 +02:00
std::vector<AssertionResult> m_assertionResults;
IRunner* m_prevRunner;
IResultCapture* m_prevResultCapture;
2012-06-08 09:22:56 +02:00
const IConfig* m_prevConfig;
AssertionInfo m_lastAssertionInfo;
2010-11-10 00:24:00 +01:00
};
} // end namespace Catch
2010-11-10 00:24:00 +01:00
#endif // TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED