catch2/internal/catch_runner_impl.hpp

602 lines
18 KiB
C++
Raw Normal View History

2010-11-10 00:24:00 +01:00
/*
* catch_runner.hpp
* Catch
*
* 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_INTERNAL_CATCH_RUNNER_HPP_INCLUDED
#define TWOBLUECUBES_INTERNAL_CATCH_RUNNER_HPP_INCLUDED
2011-01-11 10:13:31 +01:00
#include "catch_interfaces_runner.h"
#include "catch_interfaces_reporter.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"
#include "catch_test_case_info.hpp"
2010-11-10 00:24:00 +01:00
#include "catch_capture.hpp"
2011-02-08 09:42:05 +01:00
#include <set>
#include <string>
2010-11-10 00:24:00 +01:00
namespace Catch
{
2011-02-21 09:50:05 +01:00
class StreamRedirect
{
public:
///////////////////////////////////////////////////////////////////////
StreamRedirect
(
std::ostream& stream,
std::string& targetString
)
: m_stream( stream ),
m_prevBuf( stream.rdbuf() ),
m_targetString( targetString )
{
stream.rdbuf( m_oss.rdbuf() );
}
///////////////////////////////////////////////////////////////////////
~StreamRedirect
()
{
m_targetString = m_oss.str();
m_stream.rdbuf( m_prevBuf );
}
private:
std::ostream& m_stream;
std::streambuf* m_prevBuf;
std::ostringstream m_oss;
std::string& m_targetString;
};
2010-11-10 00:24:00 +01:00
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
2011-02-21 09:50:05 +01:00
class SectionInfo
{
public:
enum Status
{
Root,
Unknown,
NonLeaf,
UntestedLeaf,
TestedLeaf
};
///////////////////////////////////////////////////////////////////////
SectionInfo
(
SectionInfo* parent
)
: m_status( Unknown ),
m_parent( parent )
{
}
///////////////////////////////////////////////////////////////////////
SectionInfo
()
: m_status( Root ),
m_parent( NULL )
{
}
///////////////////////////////////////////////////////////////////////
~SectionInfo
()
{
deleteAllValues( m_subSections );
}
///////////////////////////////////////////////////////////////////////
bool shouldRun
()
const
{
return m_status != TestedLeaf;
}
///////////////////////////////////////////////////////////////////////
bool ran
()
{
if( m_status != NonLeaf )
{
m_status = TestedLeaf;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* getSubSection
(
const std::string& name
)
{
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.find( name );
if( it != m_subSections.end() )
return it->second;
SectionInfo* subSection = new SectionInfo( this );
m_subSections.insert( std::make_pair( name, subSection ) );
m_status = NonLeaf;
return subSection;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* getParent
()
{
return m_parent;
}
///////////////////////////////////////////////////////////////////////
bool hasUntestedSections
()
const
{
if( m_status == Unknown || m_status == UntestedLeaf )
return true;
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.begin();
std::map<std::string, SectionInfo*>::const_iterator itEnd = m_subSections.end();
for(; it != itEnd; ++it )
{
if( it->second->hasUntestedSections() )
return true;
}
return false;
}
private:
Status m_status;
std::map<std::string, SectionInfo*> m_subSections;
SectionInfo* m_parent;
};
2011-01-28 19:56:26 +01:00
2011-02-21 09:50:05 +01:00
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class RunningTest
{
2011-02-21 09:50:05 +01:00
enum RunStatus
{
NothingRun,
EncounteredASection,
RanAtLeastOneSection,
RanToCompletionWithSections,
RanToCompletionWithNoSections
};
public:
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
explicit RunningTest
(
const TestCaseInfo* info = NULL
)
: m_info( info ),
2011-02-21 09:50:05 +01:00
m_runStatus( RanAtLeastOneSection ),
m_currentSection( &m_rootSection )
{
}
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
2011-02-21 09:50:05 +01:00
bool wasSectionSeen
2011-01-28 19:56:26 +01:00
()
const
{
2011-02-21 09:50:05 +01:00
return m_runStatus == RanAtLeastOneSection ||
m_runStatus == RanToCompletionWithSections;
}
2011-02-21 09:50:05 +01:00
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
2011-02-21 09:50:05 +01:00
void reset
2011-01-28 19:56:26 +01:00
()
{
2011-02-21 09:50:05 +01:00
m_runStatus = NothingRun;
}
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
2011-02-21 09:50:05 +01:00
void ranToCompletion
2011-01-28 19:56:26 +01:00
()
{
2011-02-21 09:50:05 +01:00
m_runStatus = m_runStatus == RanAtLeastOneSection ||
m_runStatus == EncounteredASection
? RanToCompletionWithSections
: RanToCompletionWithNoSections;
}
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
bool addSection
(
const std::string& name
)
{
2011-02-21 09:50:05 +01:00
if( m_runStatus == NothingRun )
m_runStatus = EncounteredASection;
SectionInfo* thisSection = m_currentSection->getSubSection( name );
if( !wasSectionSeen() && thisSection->shouldRun() )
{
m_currentSection = thisSection;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
void endSection
(
2011-02-21 09:50:05 +01:00
const std::string&
)
{
2011-02-21 09:50:05 +01:00
if( m_currentSection->ran() )
m_runStatus = RanAtLeastOneSection;
m_currentSection = m_currentSection->getParent();
}
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
const TestCaseInfo& getTestCaseInfo
()
const
{
return *m_info;
}
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////
2011-02-21 09:50:05 +01:00
bool hasUntestedSections
2011-01-28 19:56:26 +01:00
()
2011-02-21 09:50:05 +01:00
const
2010-11-30 07:48:21 +01:00
{
2011-02-21 09:50:05 +01:00
return m_rootSection.hasUntestedSections() ||
m_runStatus == RanAtLeastOneSection;
2010-11-30 07:48:21 +01:00
}
private:
2011-02-21 09:50:05 +01:00
const TestCaseInfo* m_info;
RunStatus m_runStatus;
SectionInfo m_rootSection;
SectionInfo* m_currentSection;
2010-11-30 07:48:21 +01:00
};
2011-01-28 19:56:26 +01:00
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
2011-01-11 10:13:31 +01:00
class Runner : public IResultCapture, public IRunner
2010-11-10 00:24:00 +01:00
{
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
///////////////////////////////////////////////////////////////////////////
explicit Runner
(
const Config& config
)
2011-02-21 09:50:05 +01:00
: m_runningTest( NULL ),
m_config( config ),
m_successes( 0 ),
2010-11-10 00:24:00 +01:00
m_failures( 0 ),
m_reporter( m_config.getReporter() ),
m_prevRunner( &Hub::getRunner() ),
m_prevResultCapture( &Hub::getResultCapture() )
2010-11-10 00:24:00 +01:00
{
2011-01-11 10:13:31 +01:00
Hub::setRunner( this );
Hub::setResultCapture( this );
m_reporter->StartTesting();
2010-11-10 00:24:00 +01:00
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
~Runner
()
2010-11-10 00:24:00 +01:00
{
m_reporter->EndTesting( m_successes, m_failures );
Hub::setRunner( m_prevRunner );
Hub::setResultCapture( m_prevResultCapture );
2010-11-10 00:24:00 +01:00
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void runAll
2011-02-08 09:42:05 +01:00
(
bool runHiddenTests = false
)
2010-11-10 00:24:00 +01:00
{
2011-01-07 11:01:40 +01:00
std::vector<TestCaseInfo> allTests = Hub::getTestCaseRegistry().getAllTests();
for( std::size_t i=0; i < allTests.size(); ++i )
2010-11-10 00:24:00 +01:00
{
2011-02-08 09:42:05 +01:00
if( runHiddenTests || !allTests[i].isHidden() )
runTest( allTests[i] );
2010-11-10 00:24:00 +01:00
}
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual std::size_t runMatching
(
const std::string& rawTestSpec
)
2010-11-10 00:24:00 +01:00
{
TestSpec testSpec( rawTestSpec );
2011-01-07 11:01:40 +01:00
std::vector<TestCaseInfo> allTests = Hub::getTestCaseRegistry().getAllTests();
std::size_t testsRun = 0;
for( std::size_t i=0; i < allTests.size(); ++i )
2010-11-10 00:24:00 +01:00
{
if( testSpec.matches( allTests[i].getName() ) )
{
runTest( allTests[i] );
testsRun++;
}
}
return testsRun;
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
void runTest
(
const TestCaseInfo& testInfo
)
2010-11-10 00:24:00 +01:00
{
std::size_t prevSuccessCount = m_successes;
std::size_t prevFailureCount = m_failures;
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
do
2010-11-10 00:24:00 +01:00
{
2011-01-27 00:23:33 +01:00
do
{
runCurrentTest( redirectedCout, redirectedCerr );
}
2011-02-21 09:50:05 +01:00
while( m_runningTest->hasUntestedSections() );
2010-11-10 00:24:00 +01:00
}
2011-01-27 00:23:33 +01:00
while( Hub::advanceGeneratorsForCurrentTest() );
2011-02-21 09:50:05 +01:00
delete m_runningTest;
m_runningTest = NULL;
m_reporter->EndTestCase( testInfo, m_successes - prevSuccessCount, m_failures - prevFailureCount, redirectedCout, redirectedCerr );
2010-11-10 00:24:00 +01:00
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual std::size_t getSuccessCount
()
const
2010-11-10 00:24:00 +01:00
{
return m_successes;
}
2011-01-11 10:13:31 +01:00
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual std:: size_t getFailureCount
()
const
2010-11-10 00:24:00 +01:00
{
return m_failures;
}
2011-01-11 10:13:31 +01:00
private: // IResultCapture
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual ResultAction::Value acceptResult
(
bool result
)
{
return acceptResult( result ? ResultWas::Ok : ResultWas::ExpressionFailed );
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual ResultAction::Value acceptResult
(
ResultWas::OfType result
)
{
m_currentResult.setResultType( result );
return actOnCurrentResult();
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
2011-03-10 15:09:32 +01:00
virtual ResultAction::Value acceptExpression
2011-01-11 20:48:48 +01:00
(
const MutableResultInfo& resultInfo
)
{
m_currentResult = resultInfo;
return actOnCurrentResult();
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void acceptMessage
(
const std::string& msg
)
{
m_currentResult.setMessage( msg );
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void testEnded
(
const ResultInfo& result
)
2010-11-10 00:24:00 +01:00
{
if( result.getResultType() == ResultWas::Ok )
{
2010-11-10 00:24:00 +01:00
m_successes++;
}
else if( !result.ok() )
2010-12-27 23:05:13 +01:00
{
m_failures++;
2010-12-27 23:05:13 +01:00
std::vector<ResultInfo>::const_iterator it = m_info.begin();
std::vector<ResultInfo>::const_iterator itEnd = m_info.end();
for(; it != itEnd; ++it )
m_reporter->Result( *it );
m_info.clear();
2010-12-27 23:05:13 +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
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual bool sectionStarted
(
const std::string& name,
const std::string& description,
2011-02-17 21:15:20 +01:00
std::size_t& successes,
2011-01-11 20:48:48 +01:00
std::size_t& failures
)
{
2011-02-21 09:50:05 +01:00
if( !m_runningTest->addSection( name ) )
return false;
m_reporter->StartSection( name, description );
successes = m_successes;
failures = m_failures;
2010-11-29 23:52:27 +01:00
return true;
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void sectionEnded
(
const std::string& name,
std::size_t prevSuccesses,
std::size_t prevFailures
)
{
2011-02-21 09:50:05 +01:00
m_runningTest->endSection( name );
m_reporter->EndSection( name, m_successes - prevSuccesses, m_failures - prevFailures );
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void pushScopedInfo
(
ScopedInfo* scopedInfo
)
{
m_scopedInfos.push_back( scopedInfo );
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual void popScopedInfo
(
ScopedInfo* scopedInfo
)
{
if( m_scopedInfos.back() == scopedInfo )
m_scopedInfos.pop_back();
}
2011-01-11 20:48:48 +01:00
///////////////////////////////////////////////////////////////////////////
virtual bool shouldDebugBreak
()
const
{
return m_config.shouldDebugBreak();
}
2011-01-27 00:23:33 +01: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
}
private:
///////////////////////////////////////////////////////////////////////////
ResultAction::Value actOnCurrentResult
()
{
testEnded( m_currentResult );
bool ok = m_currentResult.ok();
m_currentResult = MutableResultInfo();
if( ok )
return ResultAction::None;
else if( shouldDebugBreak() )
return ResultAction::DebugFailed;
else
return ResultAction::Failed;
}
///////////////////////////////////////////////////////////////////////////
void runCurrentTest
(
std::string& redirectedCout,
std::string& redirectedCerr
)
{
try
{
2011-02-21 09:50:05 +01:00
m_runningTest->reset();
StreamRedirect coutRedir( std::cout, redirectedCout );
StreamRedirect cerrRedir( std::cerr, redirectedCerr );
2011-02-21 09:50:05 +01:00
m_runningTest->getTestCaseInfo().invoke();
m_runningTest->ranToCompletion();
}
catch( TestFailureException& )
{
// This just means the test was aborted due to failure
}
catch( std::exception& ex )
{
acceptMessage( ex.what() );
acceptResult( ResultWas::ThrewException );
}
catch( std::string& msg )
{
acceptMessage( msg );
acceptResult( ResultWas::ThrewException );
}
catch( const char* msg )
{
acceptMessage( msg );
acceptResult( ResultWas::ThrewException );
}
catch(...)
{
2011-04-20 16:40:40 +02:00
acceptMessage( Catch::Hub::getExceptionTranslatorRegistry().translateActiveException() );
acceptResult( ResultWas::ThrewException );
}
m_info.clear();
}
2010-11-10 00:24:00 +01:00
private:
2011-02-21 09:50:05 +01:00
RunningTest* m_runningTest;
MutableResultInfo m_currentResult;
const Config& m_config;
std::size_t m_successes;
std::size_t m_failures;
IReporter* m_reporter;
std::vector<ScopedInfo*> m_scopedInfos;
2010-12-27 23:05:13 +01:00
std::vector<ResultInfo> m_info;
IRunner* m_prevRunner;
IResultCapture* m_prevResultCapture;
2010-11-10 00:24:00 +01:00
};
}
#endif // TWOBLUECUBES_INTERNAL_CATCH_RUNNER_HPP_INCLUDED