catch2/include/internal/catch_run_context.hpp

379 lines
14 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_test_spec.hpp"
#include "catch_test_case_tracker.hpp"
#include "catch_timer.h"
#include "catch_result_builder.h"
#include "catch_fatal_condition.hpp"
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() ),
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 );
}
2011-02-21 09:50:05 +01:00
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 RunContext : public IResultCapture, public IRunner {
RunContext( RunContext const& );
void operator =( RunContext const& );
2010-11-10 00:24:00 +01:00
public:
2011-01-11 20:48:48 +01:00
explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
: m_runInfo( _config->name() ),
2012-12-02 00:54:17 +01:00
m_context( getCurrentMutableContext() ),
m_activeTestCase( nullptr ),
m_config( _config ),
m_reporter( reporter ),
m_shouldReportUnexpected ( true )
2010-11-10 00:24:00 +01:00
{
m_context.setRunner( this );
m_context.setConfig( m_config );
m_context.setResultCapture( this );
2012-12-02 00:54:17 +01:00
m_reporter->testRunStarting( m_runInfo );
2010-11-10 00:24:00 +01:00
}
virtual ~RunContext() {
m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
2010-11-10 00:24:00 +01:00
}
void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
}
void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
}
Totals runTest( TestCase const& testCase ) {
Totals prevTotals = m_totals;
std::string redirectedCout;
std::string redirectedCerr;
TestCaseInfo testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting( testInfo );
2013-07-25 08:49:00 +02:00
m_activeTestCase = &testCase;
2010-11-30 07:48:21 +01:00
2012-05-16 09:02:20 +02:00
do {
ITracker& rootTracker = m_trackerContext.startRun();
assert( rootTracker.isSectionTracker() );
static_cast<SectionTracker&>( rootTracker ).addInitialFilters( m_config->getSectionsToRun() );
2012-05-16 09:02:20 +02:00
do {
2015-11-02 20:21:46 +01:00
m_trackerContext.startCycle();
m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( testInfo.name, testInfo.lineInfo ) );
2011-01-27 00:23:33 +01:00
runCurrentTest( redirectedCout, redirectedCerr );
}
2015-11-02 20:21:46 +01:00
while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() );
2010-11-10 00:24:00 +01:00
}
// !TBD: deprecated - this will be replaced by indexed trackers
while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
Totals deltaTotals = m_totals.delta( prevTotals );
2016-03-14 20:13:34 +01:00
if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) {
deltaTotals.assertions.failed++;
deltaTotals.testCases.passed--;
deltaTotals.testCases.failed++;
}
m_totals.testCases += deltaTotals.testCases;
m_reporter->testCaseEnded( TestCaseStats( testInfo,
deltaTotals,
redirectedCout,
redirectedCerr,
aborting() ) );
m_activeTestCase = nullptr;
m_testCaseTracker = nullptr;
return deltaTotals;
2010-11-10 00:24:00 +01:00
}
Ptr<IConfig const> config() const {
return m_config;
}
2011-01-11 10:13:31 +01:00
private: // IResultCapture
virtual void assertionEnded( AssertionResult const& 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++;
2010-12-27 23:05:13 +01:00
}
if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
m_messages.clear();
2013-02-02 21:36:36 +01:00
// Reset working state
m_lastAssertionInfo = AssertionInfo( std::string(), m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
m_lastResult = result;
2010-11-10 00:24:00 +01:00
}
2012-05-16 09:02:20 +02:00
virtual bool sectionStarted (
SectionInfo const& sectionInfo,
Counts& assertions
2011-01-11 20:48:48 +01:00
)
{
ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( sectionInfo.name, sectionInfo.lineInfo ) );
2015-11-02 20:21:46 +01:00
if( !sectionTracker.isOpen() )
return false;
2015-11-02 20:21:46 +01:00
m_activeSections.push_back( &sectionTracker );
m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting( sectionInfo );
assertions = m_totals.assertions;
return true;
}
2013-07-26 20:26:08 +02:00
bool testForMissingAssertions( Counts& assertions ) {
2015-11-02 20:21:46 +01:00
if( assertions.total() != 0 )
return false;
if( !m_config->warnAboutMissingAssertions() )
2015-11-02 20:21:46 +01:00
return false;
if( m_trackerContext.currentTracker().hasChildren() )
2013-07-26 20:26:08 +02:00
return false;
m_totals.assertions.failed++;
assertions.failed++;
return true;
}
virtual void sectionEnded( SectionEndInfo const& endInfo ) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
2013-07-26 20:26:08 +02:00
bool missingAssertions = testForMissingAssertions( assertions );
2015-11-02 20:21:46 +01:00
if( !m_activeSections.empty() ) {
m_activeSections.back()->close();
m_activeSections.pop_back();
}
m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
m_messages.clear();
}
virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
2015-11-02 20:21:46 +01:00
if( m_unfinishedSections.empty() )
m_activeSections.back()->fail();
else
m_activeSections.back()->close();
m_activeSections.pop_back();
m_unfinishedSections.push_back( endInfo );
}
virtual void pushScopedMessage( MessageInfo const& message ) {
m_messages.push_back( message );
}
virtual void popScopedMessage( MessageInfo const& message ) {
m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
}
2011-01-11 20:48:48 +01:00
2012-05-16 09:02:20 +02:00
virtual std::string getCurrentTestName() const {
2013-07-25 08:49:00 +02:00
return m_activeTestCase
? m_activeTestCase->getTestCaseInfo().name
: std::string();
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 {
return &m_lastResult;
2012-02-10 09:30:13 +01:00
}
virtual void exceptionEarlyReported() {
m_shouldReportUnexpected = false;
}
virtual void handleFatalErrorCondition( std::string const& message ) {
// Don't rebuild the result -- the stringification itself can cause more fatal errors
// Instead, fake a result data.
AssertionResultData tempResult;
tempResult.resultType = ResultWas::FatalErrorCondition;
tempResult.message = message;
AssertionResult result(m_lastAssertionInfo, tempResult);
getResultCapture().assertionEnded(result);
handleUnfinishedSections();
// Recreate section for test case (as we will lose the one that was in scope)
TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
Counts assertions;
assertions.failed = 1;
SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
m_reporter->sectionEnded( testCaseSectionStats );
TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
Totals deltaTotals;
deltaTotals.testCases.failed = 1;
m_reporter->testCaseEnded( TestCaseStats( testInfo,
deltaTotals,
std::string(),
std::string(),
false ) );
m_totals.testCases.failed++;
testGroupEnded( std::string(), m_totals, 1, 1 );
m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
}
2012-08-23 21:08:50 +02:00
public:
// !TBD We need to do this another way!
bool aborting() const {
return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
}
2012-08-23 21:08:50 +02:00
private:
2012-05-16 09:02:20 +02:00
void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
2013-07-25 08:49:00 +02:00
TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
m_reporter->sectionStarting( testCaseSection );
Counts prevAssertions = m_totals.assertions;
double duration = 0;
m_shouldReportUnexpected = true;
2012-05-16 09:02:20 +02:00
try {
m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, std::string(), ResultDisposition::Normal );
seedRng( *m_config );
Timer timer;
timer.start();
if( m_reporter->getPreferences().shouldRedirectStdOut ) {
StreamRedirect coutRedir( Catch::cout(), redirectedCout );
StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
invokeActiveTestCase();
}
2012-05-16 09:02:20 +02:00
else {
invokeActiveTestCase();
}
duration = timer.getElapsedSeconds();
}
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(...) {
// Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
// are reported without translation at the point of origin.
if (m_shouldReportUnexpected) {
makeUnexpectedResultBuilder().useActiveException();
}
}
2015-11-02 20:21:46 +01:00
m_testCaseTracker->close();
handleUnfinishedSections();
m_messages.clear();
Counts assertions = m_totals.assertions - prevAssertions;
2013-07-26 20:26:08 +02:00
bool missingAssertions = testForMissingAssertions( assertions );
if( testCaseInfo.okToFail() ) {
std::swap( assertions.failedButOk, assertions.failed );
m_totals.assertions.failed -= assertions.failedButOk;
m_totals.assertions.failedButOk += assertions.failedButOk;
}
SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
m_reporter->sectionEnded( testCaseSectionStats );
}
2012-05-10 22:46:46 +02:00
void invokeActiveTestCase() {
FatalConditionHandler fatalConditionHandler; // Handle signals
m_activeTestCase->invoke();
fatalConditionHandler.reset();
}
2010-11-10 00:24:00 +01:00
private:
ResultBuilder makeUnexpectedResultBuilder() const {
return ResultBuilder( m_lastAssertionInfo.macroName.c_str(),
m_lastAssertionInfo.lineInfo,
m_lastAssertionInfo.capturedExpression.c_str(),
m_lastAssertionInfo.resultDisposition );
}
void handleUnfinishedSections() {
// If sections ended prematurely due to an exception we stored their
// infos here so we can tear them down outside the unwind process.
for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
itEnd = m_unfinishedSections.rend();
it != itEnd;
++it )
sectionEnded( *it );
m_unfinishedSections.clear();
}
2012-12-02 00:54:17 +01:00
TestRunInfo m_runInfo;
IMutableContext& m_context;
2013-07-25 08:49:00 +02:00
TestCase const* m_activeTestCase;
2015-11-02 20:21:46 +01:00
ITracker* m_testCaseTracker;
ITracker* m_currentSectionTracker;
2012-10-16 09:27:21 +02:00
AssertionResult m_lastResult;
Ptr<IConfig const> m_config;
Totals m_totals;
Ptr<IStreamingReporter> m_reporter;
std::vector<MessageInfo> m_messages;
AssertionInfo m_lastAssertionInfo;
std::vector<SectionEndInfo> m_unfinishedSections;
2015-11-02 20:21:46 +01:00
std::vector<ITracker*> m_activeSections;
TrackerContext m_trackerContext;
bool m_shouldReportUnexpected;
2010-11-10 00:24:00 +01:00
};
IResultCapture& getResultCapture() {
if( IResultCapture* capture = getCurrentContext().getResultCapture() )
return *capture;
else
throw std::logic_error( "No result capture instance" );
}
} // end namespace Catch
2010-11-10 00:24:00 +01:00
#endif // TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED