catch2/internal/catch_runner_impl.hpp

261 lines
7.7 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
#include "catch_interfaces_reporter.h"
2011-01-01 01:29:58 +01:00
#include "catch_config.hpp"
2010-11-10 00:24:00 +01:00
#include "catch_registry.hpp"
#include "catch_capture.hpp"
namespace Catch
{
class TestSpec
{
public:
TestSpec( const std::string& rawSpec )
: m_rawSpec( rawSpec ),
m_isWildcarded( false )
{
if( m_rawSpec[m_rawSpec.size()-1] == '*' )
{
m_rawSpec = m_rawSpec.substr( 0, m_rawSpec.size()-1 );
m_isWildcarded = true;
}
}
bool matches( const std::string& testName ) const
{
if( !m_isWildcarded )
return m_rawSpec == testName;
else
return testName.size() >= m_rawSpec.size() && testName.substr( 0, m_rawSpec.size() ) == m_rawSpec;
}
private:
std::string m_rawSpec;
bool m_isWildcarded;
};
2010-11-30 07:48:21 +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
class Runner : public IResultListener
{
2010-12-30 00:18:16 +01:00
Runner( const Runner& );
void operator =( const Runner& );
2010-11-10 00:24:00 +01:00
public:
explicit Runner( const Config& config )
: m_config( config ),
m_successes( 0 ),
2010-11-10 00:24:00 +01:00
m_failures( 0 ),
m_reporter( m_config.getReporter() )
2010-11-10 00:24:00 +01:00
{
m_reporter->StartTesting();
2010-11-10 00:24:00 +01:00
}
~Runner()
2010-11-10 00:24:00 +01:00
{
m_reporter->EndTesting( m_successes, m_failures );
2010-11-10 00:24:00 +01:00
}
void runAll()
{
std::vector<TestCaseInfo> allTests = TestRegistry::instance().getAllTests();
for( std::size_t i=0; i < allTests.size(); ++i )
2010-11-10 00:24:00 +01:00
{
runTest( allTests[i] );
}
}
std::size_t runMatching( const std::string& rawTestSpec )
2010-11-10 00:24:00 +01:00
{
TestSpec testSpec( rawTestSpec );
std::vector<TestCaseInfo> allTests = TestRegistry::instance().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;
}
void runTest( const TestCaseInfo& testInfo )
{
IResultListener* prevListener = ResultsCapture::setListener( this );
m_reporter->StartTestCase( testInfo );
2010-11-30 07:48:21 +01:00
std::string redirectedCout;
std::string redirectedCerr;
2010-11-10 00:24:00 +01:00
try
{
2010-11-30 07:48:21 +01:00
StreamRedirect coutRedir( std::cout, redirectedCout );
StreamRedirect cerrRedir( std::cerr, redirectedCerr );
testInfo.invoke();
2010-11-10 00:24:00 +01:00
}
catch( TestFailureException& )
2010-11-10 00:24:00 +01:00
{
// This just means the test was aborted due to failure
}
catch( std::exception& ex )
{
acceptMessage( ex.what() );
acceptResult( ResultWas::ThrewException );
2010-11-10 00:24:00 +01:00
}
catch(...)
{
acceptMessage( "unknown exception" );
acceptResult( ResultWas::ThrewException );
2010-11-10 00:24:00 +01:00
}
m_info.clear();
2010-11-30 07:48:21 +01:00
m_reporter->EndTestCase( testInfo, redirectedCout, redirectedCerr );
2010-11-10 00:24:00 +01:00
ResultsCapture::setListener( prevListener );
}
std::size_t getSuccessCount() const
2010-11-10 00:24:00 +01:00
{
return m_successes;
}
std:: size_t getFailureCount() const
2010-11-10 00:24:00 +01:00
{
return m_failures;
}
private: // IResultListener
virtual ResultAction::Value acceptResult( bool result )
{
return acceptResult( result ? ResultWas::Ok : ResultWas::ExpressionFailed );
}
virtual ResultAction::Value acceptResult( ResultWas::OfType result )
{
m_currentResult.setResultType( result );
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;
}
virtual void acceptExpression( const MutableResultInfo& resultInfo )
{
m_currentResult = resultInfo;
}
virtual void acceptMessage( const std::string& msg )
{
m_currentResult.setMessage( msg );
}
///
2010-11-10 00:24:00 +01:00
virtual void testEnded( const ResultInfo& result )
{
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
}
virtual bool sectionStarted( const std::string& name, const std::string& description, std::size_t& successes, std::size_t& failures )
{
m_reporter->StartSection( name, description );
successes = m_successes;
failures = m_failures;
2010-11-29 23:52:27 +01:00
// !TBD look up whether we should execute this section or not
return true;
}
virtual void sectionEnded( const std::string& name, std::size_t prevSuccesses, std::size_t prevFailures )
{
m_reporter->EndSection( name, m_successes - prevSuccesses, m_failures - prevFailures );
}
virtual void pushScopedInfo( ScopedInfo* scopedInfo )
{
m_scopedInfos.push_back( scopedInfo );
}
virtual void popScopedInfo( ScopedInfo* scopedInfo )
{
if( m_scopedInfos.back() == scopedInfo )
m_scopedInfos.pop_back();
}
virtual bool shouldDebugBreak() const
{
return m_config.shouldDebugBreak();
}
2010-11-10 00:24:00 +01:00
private:
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;
2010-11-10 00:24:00 +01:00
};
}
#endif // TWOBLUECUBES_INTERNAL_CATCH_RUNNER_HPP_INCLUDED