diff --git a/single_include/catch.hpp b/single_include/catch.hpp index 32309c2f..96e87228 100644 --- a/single_include/catch.hpp +++ b/single_include/catch.hpp @@ -1,5 +1,5 @@ /* - * Generated: 2012-10-12 18:39:11.086583 + * Generated: 2012-10-28 12:06:53.944416 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. @@ -139,6 +139,9 @@ namespace Catch { file.swap( other.file ); std::swap( line, other.line ); } + bool empty() const { + return file.empty(); + } std::string function; std::string file; @@ -445,14 +448,14 @@ private: // #included from: internal/catch_capture.hpp #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED -// #included from: catch_expression_builder.hpp -#define TWOBLUECUBES_CATCH_EXPRESSION_BUILDER_HPP_INCLUDED +// #included from: catch_expression_decomposer.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_DECOMPOSER_HPP_INCLUDED -// #included from: catch_expression.hpp -#define TWOBLUECUBES_CATCH_EXPRESSION_HPP_INCLUDED +// #included from: catch_expression_lhs.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED -// #included from: catch_resultinfo_builder.h -#define TWOBLUECUBES_CATCH_RESULTINFO_BUILDER_H_INCLUDED +// #included from: catch_expressionresult_builder.h +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_BUILDER_H_INCLUDED // #included from: catch_tostring.hpp #define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED @@ -639,8 +642,8 @@ inline std::string toString( std::nullptr_t ) { } // end namespace Catch -// #included from: catch_resultinfo.h -#define TWOBLUECUBES_CATCH_RESULTINFO_H_INCLUDED +// #included from: catch_assertionresult.h +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED #include // #included from: catch_result_type.h @@ -682,23 +685,37 @@ struct ResultAction { enum Value { namespace Catch { - struct ResultData + struct AssertionInfo { - ResultData() : resultType( ResultWas::Unknown ) {} + AssertionInfo() {} + AssertionInfo( const std::string& _macroName, const SourceLineInfo& _lineInfo, const std::string& _capturedExpression, bool _shouldNegate ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + capturedExpression( _capturedExpression ) + { + if( _shouldNegate ) + capturedExpression = "!" + _capturedExpression; + } std::string macroName; SourceLineInfo lineInfo; std::string capturedExpression; + }; + + struct AssertionResultData + { + AssertionResultData() : resultType( ResultWas::Unknown ) {} + std::string reconstructedExpression; std::string message; ResultWas::OfType resultType; }; - class ResultInfo { + class AssertionResult { public: - ResultInfo(); - ResultInfo( const ResultData& data ); - ~ResultInfo(); + AssertionResult(); + AssertionResult( const AssertionInfo& info, const AssertionResultData& data ); + ~AssertionResult(); bool ok() const; ResultWas::OfType getResultType() const; @@ -708,12 +725,12 @@ namespace Catch { bool hasExpandedExpression() const; std::string getExpandedExpression() const; std::string getMessage() const; - std::string getFilename() const; - std::size_t getLine() const; + SourceLineInfo getSourceInfo() const; std::string getTestMacroName() const; protected: - ResultData m_data; + AssertionInfo m_info; + AssertionResultData m_resultData; }; } // end namespace Catch @@ -885,201 +902,145 @@ namespace Internal { namespace Catch { -struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; - -class ResultInfoBuilder { +// Wraps the (stringised versions of) the lhs, operator and rhs of an expression - as well as +// the result of evaluating it. This is used to build an AssertionResult object +class ExpressionResultBuilder { public: - ResultInfoBuilder(); + ExpressionResultBuilder( ResultWas::OfType resultType = ResultWas::Unknown ); + ExpressionResultBuilder( const ExpressionResultBuilder& other ); + ExpressionResultBuilder& operator=(const ExpressionResultBuilder& other ); - ResultInfoBuilder& setResultType( ResultWas::OfType result ); - ResultInfoBuilder& setCapturedExpression( const std::string& capturedExpression ); - ResultInfoBuilder& setIsFalse( bool isFalse ); - ResultInfoBuilder& setMessage( const std::string& message ); - ResultInfoBuilder& setLineInfo( const SourceLineInfo& lineInfo ); - ResultInfoBuilder& setLhs( const std::string& lhs ); - ResultInfoBuilder& setRhs( const std::string& rhs ); - ResultInfoBuilder& setOp( const std::string& op ); - ResultInfoBuilder& setMacroName( const std::string& macroName ); + ExpressionResultBuilder& setResultType( ResultWas::OfType result ); + ExpressionResultBuilder& setResultType( bool result ); + ExpressionResultBuilder& setLhs( const std::string& lhs ); + ExpressionResultBuilder& setRhs( const std::string& rhs ); + ExpressionResultBuilder& setOp( const std::string& op ); - std::string reconstructExpression() const; + ExpressionResultBuilder& negate( bool shouldNegate ); - ResultInfo build() const; - - // Disable attempts to use || and && in expressions (without parantheses) - template - STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( const RhsT& ); - template - STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( const RhsT& ); - - bool getIsFalse() const { - return m_isFalse; + template + ExpressionResultBuilder& operator << ( const T& value ) { + m_stream << value; + return *this; } + std::string reconstructExpression( const AssertionInfo& info ) const; + + AssertionResult buildResult( const AssertionInfo& info ) const; + private: - ResultData m_data; - std::string m_lhs, m_rhs, m_op; - bool m_isFalse; + AssertionResultData m_data; + struct ExprComponents { + ExprComponents() : shouldNegate( false ) {} + bool shouldNegate; + std::string lhs, rhs, op; + } m_exprComponents; + std::ostringstream m_stream; }; } // end namespace Catch namespace Catch { + struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; + + template + inline void setResultIfBoolean( ExpressionResultBuilder&, const T& ) {} + inline void setResultIfBoolean( ExpressionResultBuilder& result, bool value ) { + result.setResultType( value ); + } + +// Wraps the LHS of an expression and captures the operator and RHS (if any) - wrapping them all +// in an ExpressionResultBuilder object template -class Expression { - void operator = ( const Expression& ); +class ExpressionLhs { + void operator = ( const ExpressionLhs& ); public: - Expression( ResultInfoBuilder& result, T lhs ) - : m_result( result.setLhs( Catch::toString( lhs ) ) ), - m_lhs( lhs ) - {} + ExpressionLhs( T lhs ) : m_lhs( lhs ) { + setResultIfBoolean( m_result.setLhs( Catch::toString( lhs ) ), lhs ); + } template - ResultInfoBuilder& operator == ( const RhsT& rhs ) { + ExpressionResultBuilder& operator == ( const RhsT& rhs ) { return captureExpression( rhs ); } template - ResultInfoBuilder& operator != ( const RhsT& rhs ) { + ExpressionResultBuilder& operator != ( const RhsT& rhs ) { return captureExpression( rhs ); } template - ResultInfoBuilder& operator < ( const RhsT& rhs ) { + ExpressionResultBuilder& operator < ( const RhsT& rhs ) { return captureExpression( rhs ); } template - ResultInfoBuilder& operator > ( const RhsT& rhs ) { + ExpressionResultBuilder& operator > ( const RhsT& rhs ) { return captureExpression( rhs ); } template - ResultInfoBuilder& operator <= ( const RhsT& rhs ) { + ExpressionResultBuilder& operator <= ( const RhsT& rhs ) { return captureExpression( rhs ); } template - ResultInfoBuilder& operator >= ( const RhsT& rhs ) { + ExpressionResultBuilder& operator >= ( const RhsT& rhs ) { return captureExpression( rhs ); } - ResultInfoBuilder& operator == ( bool rhs ) { + ExpressionResultBuilder& operator == ( bool rhs ) { return captureExpression( rhs ); } - ResultInfoBuilder& operator != ( bool rhs ) { + ExpressionResultBuilder& operator != ( bool rhs ) { return captureExpression( rhs ); } - operator ResultInfoBuilder& () { - return m_result.setResultType( m_lhs ? ResultWas::Ok : ResultWas::ExpressionFailed ); + ExpressionResultBuilder& negate( bool shouldNegate ) { + return m_result.negate( shouldNegate ); } - template - STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( const RhsT& ); - - template - STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( const RhsT& ); + // Only simple binary expressions are allowed on the LHS. + // If more complex compositions are required then place the sub expression in parentheses + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( const RhsT& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( const RhsT& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( const RhsT& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( const RhsT& ); private: template - ResultInfoBuilder& captureExpression( const RhsT& rhs ) { + ExpressionResultBuilder& captureExpression( const RhsT& rhs ) { return m_result - .setResultType( Internal::compare( m_lhs, rhs ) ? ResultWas::Ok : ResultWas::ExpressionFailed ) + .setResultType( Internal::compare( m_lhs, rhs ) ) .setRhs( Catch::toString( rhs ) ) .setOp( Internal::OperatorTraits::getName() ); } private: - ResultInfoBuilder& m_result; + ExpressionResultBuilder m_result; T m_lhs; }; } // end namespace Catch -#include - namespace Catch { -class ExpressionBuilder { +// Captures the LHS of the expression and wraps it in an Expression Lhs object +class ExpressionDecomposer { public: - ExpressionBuilder( const SourceLineInfo& lineInfo, - const char* macroName, - const char* expr = "", - bool isFalse = false ) - : m_messageStream() - { - m_result - .setCapturedExpression( expr ) - .setIsFalse( isFalse ) - .setLineInfo( lineInfo ) - .setMacroName( macroName ); - } - template - Expression operator->* ( const T & operand ) { - Expression expr( m_result, operand ); - return expr; + ExpressionLhs operator->* ( const T & operand ) { + return ExpressionLhs( operand ); } - Expression operator->* ( bool value ) { - Expression expr( m_result, value ); - return expr; + ExpressionLhs operator->* ( bool value ) { + return ExpressionLhs( value ); } - - template - ExpressionBuilder& operator << ( const T & value ) { - m_messageStream << Catch::toString( value ); - return *this; - } - - template - ExpressionBuilder& acceptMatcher( const MatcherT& matcher, - const ArgT& arg, - const std::string& matcherCallAsString ) { - std::string matcherAsString = matcher.toString(); - if( matcherAsString == "{?}" ) - matcherAsString = matcherCallAsString; - m_result - .setLhs( Catch::toString( arg ) ) - .setRhs( matcherAsString ) - .setOp( "matches" ) - .setResultType( matcher.match( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed ); - return *this; - } - - template - ExpressionBuilder& acceptMatcher( const MatcherT& matcher, - ArgT* arg, - const std::string& matcherCallAsString ) { - std::string matcherAsString = matcher.toString(); - if( matcherAsString == "{?}" ) - matcherAsString = matcherCallAsString; - m_result - .setLhs( Catch::toString( arg ) ) - .setRhs( matcherAsString ) - .setOp( "matches" ) - .setResultType( matcher.match( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed ); - return *this; - } - - ExpressionBuilder& setResultType( ResultWas::OfType resultType ) { - m_result.setResultType( resultType ); - return *this; - } - - operator ResultInfoBuilder&() { - m_result.setMessage( m_messageStream.str() ); - return m_result; - } - -private: - ResultInfoBuilder m_result; - std::ostringstream m_messageStream; }; } // end namespace Catch @@ -1152,14 +1113,15 @@ namespace Catch { class TestCaseInfo; class ScopedInfo; - class ResultInfoBuilder; - class ResultInfo; + class ExpressionResultBuilder; + class AssertionResult; + struct AssertionInfo; struct IResultCapture { virtual ~IResultCapture(); - virtual void testEnded( const ResultInfo& result ) = 0; + virtual void testEnded( const AssertionResult& result ) = 0; virtual bool sectionStarted( const std::string& name, const std::string& description, const SourceLineInfo& lineInfo, @@ -1169,13 +1131,11 @@ namespace Catch { virtual void popScopedInfo( ScopedInfo* scopedInfo ) = 0; virtual bool shouldDebugBreak() const = 0; - virtual ResultAction::Value acceptResult( bool result ) = 0; - virtual ResultAction::Value acceptResult( ResultWas::OfType result ) = 0; - virtual ResultAction::Value acceptExpression( const ResultInfoBuilder& resultInfo ) = 0; - virtual void acceptMessage( const std::string& msg ) = 0; + virtual void acceptAssertionInfo( const AssertionInfo& assertionInfo ) = 0; + virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult ) = 0; virtual std::string getCurrentTestName() const = 0; - virtual const ResultInfo* getLastResult() const = 0; + virtual const AssertionResult* getLastResult() const = 0; }; } @@ -1285,349 +1245,6 @@ inline void writeToDebugConsole( const std::string& text ) { } #endif // CATCH_PLATFORM_WINDOWS -#include - -namespace Catch { - -struct TestFailureException{}; - -class ScopedInfo { -public: - ScopedInfo() : m_oss() { - getCurrentContext().getResultCapture().pushScopedInfo( this ); - } - - ~ScopedInfo() { - getCurrentContext().getResultCapture().popScopedInfo( this ); - } - - template - ScopedInfo& operator << ( const T& value ) { - m_oss << value; - return *this; - } - - ResultInfo getInfo () const { - return ResultInfoBuilder() - .setResultType( ResultWas::Info ) - .setMessage( m_oss.str() ) - .setMacroName( "SCOPED_INFO" ) - .build(); - } - -private: - std::ostringstream m_oss; -}; - -// This is just here to avoid compiler warnings with macro constants -inline bool isTrue( bool value ){ return value; } - -} // end namespace Catch - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_ACCEPT_EXPR( expr, stopOnFailure, originalExpr ) \ - if( Catch::ResultAction::Value internal_catch_action = Catch::getCurrentContext().getResultCapture().acceptExpression( expr ) ) { \ - if( internal_catch_action & Catch::ResultAction::Debug ) BreakIntoDebugger(); \ - if( internal_catch_action & Catch::ResultAction::Abort ) throw Catch::TestFailureException(); \ - if( Catch::isTrue( stopOnFailure ) ) throw Catch::TestFailureException(); \ - if( Catch::isTrue( false ) ){ bool this_is_here_to_invoke_warnings = ( originalExpr ); Catch::isTrue( this_is_here_to_invoke_warnings ); } \ - } - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_TEST( expr, isFalse, stopOnFailure, macroName ) \ - do { try { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr, isFalse )->*expr ), stopOnFailure, expr ); \ - } catch( Catch::TestFailureException& ) { \ - throw; \ - } catch( ... ) { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ) << Catch::getRegistryHub().getExceptionTranslatorRegistry().translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), false, expr ); \ - throw; \ - } } while( Catch::isTrue( false ) ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_IF( expr, isFalse, stopOnFailure, macroName ) \ - INTERNAL_CATCH_TEST( expr, isFalse, stopOnFailure, macroName ); \ - if( Catch::getCurrentContext().getResultCapture().getLastResult()->ok() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_ELSE( expr, isFalse, stopOnFailure, macroName ) \ - INTERNAL_CATCH_TEST( expr, isFalse, stopOnFailure, macroName ); \ - if( !Catch::getCurrentContext().getResultCapture().getLastResult()->ok() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_NO_THROW( expr, stopOnFailure, macroName ) \ - try { \ - expr; \ - INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ).setResultType( Catch::ResultWas::Ok ), stopOnFailure, false ); \ - } \ - catch( ... ) { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ) << Catch::getRegistryHub().getExceptionTranslatorRegistry().translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), stopOnFailure, false ); \ - } - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_THROWS( expr, exceptionType, stopOnFailure, macroName ) \ - try { \ - if( Catch::getCurrentContext().getConfig()->allowThrows() ) { \ - expr; \ - INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ).setResultType( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \ - } \ - } \ - catch( Catch::TestFailureException& ) { \ - throw; \ - } \ - catch( exceptionType ) { \ - INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ).setResultType( Catch::ResultWas::Ok ), stopOnFailure, false ); \ - } - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, stopOnFailure, macroName ) \ - INTERNAL_CATCH_THROWS( expr, exceptionType, stopOnFailure, macroName ) \ - catch( ... ) { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #expr ) << Catch::getRegistryHub().getExceptionTranslatorRegistry() ).setResultType( Catch::ResultWas::ThrewException ), stopOnFailure, false ); \ - } - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_MSG( reason, resultType, stopOnFailure, macroName ) \ - Catch::getCurrentContext().getResultCapture().acceptExpression( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName ) << reason ).setResultType( resultType ) ); - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_SCOPED_INFO( log ) \ - Catch::ScopedInfo INTERNAL_CATCH_UNIQUE_NAME( info ); \ - INTERNAL_CATCH_UNIQUE_NAME( info ) << log - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CHECK_THAT( arg, matcher, stopOnFailure, macroName ) \ - do { try { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #arg " " #matcher, false ).acceptMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \ - } catch( Catch::TestFailureException& ) { \ - throw; \ - } catch( ... ) { \ - INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder( CATCH_INTERNAL_LINEINFO, macroName, #arg " " #matcher ) << Catch::getRegistryHub().getExceptionTranslatorRegistry().translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), false, false ); \ - throw; \ - }}while( Catch::isTrue( false ) ) - -// #included from: internal/catch_section.hpp -#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED - -#include - -namespace Catch { - - class Section { - public: - Section( const std::string& name, - const std::string& description, - const SourceLineInfo& lineInfo ) - : m_name( name ), - m_sectionIncluded( getCurrentContext().getResultCapture().sectionStarted( name, description, lineInfo, m_assertions ) ) - {} - - ~Section() { - if( m_sectionIncluded ) - getCurrentContext().getResultCapture().sectionEnded( m_name, m_assertions ); - } - - // This indicates whether the section should be executed or not - operator bool() { - return m_sectionIncluded; - } - - private: - - std::string m_name; - Counts m_assertions; - bool m_sectionIncluded; - }; - -} // end namespace Catch - -#define INTERNAL_CATCH_SECTION( name, desc ) \ - if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( name, desc, CATCH_INTERNAL_LINEINFO ) ) - -// #included from: internal/catch_generators.hpp -#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED - -#include -#include -#include -#include - -namespace Catch { - -template -struct IGenerator { - virtual ~IGenerator() {} - virtual T getValue( std::size_t index ) const = 0; - virtual std::size_t size () const = 0; -}; - -template -class BetweenGenerator : public IGenerator { -public: - BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} - - virtual T getValue( std::size_t index ) const { - return m_from+static_cast( index ); - } - - virtual std::size_t size() const { - return static_cast( 1+m_to-m_from ); - } - -private: - - T m_from; - T m_to; -}; - -template -class ValuesGenerator : public IGenerator { -public: - ValuesGenerator(){} - - void add( T value ) { - m_values.push_back( value ); - } - - virtual T getValue( std::size_t index ) const { - return m_values[index]; - } - - virtual std::size_t size() const { - return m_values.size(); - } - -private: - std::vector m_values; -}; - -template -class CompositeGenerator { -public: - CompositeGenerator() : m_totalSize( 0 ) {} - - // *** Move semantics, similar to auto_ptr *** - CompositeGenerator( CompositeGenerator& other ) - : m_fileInfo( other.m_fileInfo ), - m_totalSize( 0 ) - { - move( other ); - } - - CompositeGenerator& setFileInfo( const char* fileInfo ) { - m_fileInfo = fileInfo; - return *this; - } - - ~CompositeGenerator() { - deleteAll( m_composed ); - } - - operator T () const { - size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); - - typename std::vector*>::const_iterator it = m_composed.begin(); - typename std::vector*>::const_iterator itEnd = m_composed.end(); - for( size_t index = 0; it != itEnd; ++it ) - { - const IGenerator* generator = *it; - if( overallIndex >= index && overallIndex < index + generator->size() ) - { - return generator->getValue( overallIndex-index ); - } - index += generator->size(); - } - CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); - return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so - } - - void add( const IGenerator* generator ) { - m_totalSize += generator->size(); - m_composed.push_back( generator ); - } - - CompositeGenerator& then( CompositeGenerator& other ) { - move( other ); - return *this; - } - - CompositeGenerator& then( T value ) { - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( value ); - add( valuesGen ); - return *this; - } - -private: - - void move( CompositeGenerator& other ) { - std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); - m_totalSize += other.m_totalSize; - other.m_composed.clear(); - } - - std::vector*> m_composed; - std::string m_fileInfo; - size_t m_totalSize; -}; - -namespace Generators -{ - template - CompositeGenerator between( T from, T to ) { - CompositeGenerator generators; - generators.add( new BetweenGenerator( from, to ) ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2 ) { - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - generators.add( valuesGen ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2, T val3 ){ - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - valuesGen->add( val3 ); - generators.add( valuesGen ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2, T val3, T val4 ) { - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - valuesGen->add( val3 ); - valuesGen->add( val4 ); - generators.add( valuesGen ); - return generators; - } - -} // end namespace Generators - -using namespace Generators; - -} // end namespace Catch - -#define INTERNAL_CATCH_LINESTR2( line ) #line -#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) - -#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) - -// #included from: internal/catch_interfaces_exception.h -#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED - -#include // #included from: catch_interfaces_registry_hub.h #define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED @@ -2311,23 +1928,37 @@ namespace Catch }; class TestCaseInfo; - class ResultInfo; + class AssertionResult; struct IReporter : IShared { virtual ~IReporter(); + virtual bool shouldRedirectStdout() const = 0; + virtual void StartTesting() = 0; virtual void EndTesting( const Totals& totals ) = 0; + virtual void StartGroup( const std::string& groupName ) = 0; virtual void EndGroup( const std::string& groupName, const Totals& totals ) = 0; + + virtual void StartTestCase( const TestCaseInfo& testInfo ) = 0; + // TestCaseResult + virtual void EndTestCase( const TestCaseInfo& testInfo, const Totals& totals, const std::string& stdOut, const std::string& stdErr ) = 0; + + // SectionInfo virtual void StartSection( const std::string& sectionName, const std::string& description ) = 0; + // Section Result + virtual void EndSection( const std::string& sectionName, const Counts& assertions ) = 0; + + // - merge into SectionResult ? virtual void NoAssertionsInSection( const std::string& sectionName ) = 0; virtual void NoAssertionsInTestCase( const std::string& testName ) = 0; - virtual void EndSection( const std::string& sectionName, const Counts& assertions ) = 0; - virtual void StartTestCase( const TestCaseInfo& testInfo ) = 0; + + // - merge into SectionResult, TestCaseResult, GroupResult & TestRunResult virtual void Aborted() = 0; - virtual void EndTestCase( const TestCaseInfo& testInfo, const Totals& totals, const std::string& stdOut, const std::string& stdErr ) = 0; - virtual void Result( const ResultInfo& result ) = 0; + + // AssertionReslt + virtual void Result( const AssertionResult& result ) = 0; }; struct IReporterFactory { @@ -2379,8 +2010,388 @@ namespace Catch { IRegistryHub& getRegistryHub(); IMutableRegistryHub& getMutableRegistryHub(); void cleanUp(); + std::string translateActiveException(); + } +#include + +namespace Catch { + + inline IResultCapture& getResultCapture() { + return getCurrentContext().getResultCapture(); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher, + const std::string& matcherCallAsString ) { + std::string matcherAsString = matcher.toString(); + if( matcherAsString == "{?}" ) + matcherAsString = matcherCallAsString; + return ExpressionResultBuilder() + .setRhs( matcherAsString ) + .setOp( "matches" ); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher, + const ArgT& arg, + const std::string& matcherCallAsString ) { + return expressionResultBuilderFromMatcher( matcher, matcherCallAsString ) + .setLhs( Catch::toString( arg ) ) + .setResultType( matcher.match( arg ) ); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher, + ArgT* arg, + const std::string& matcherCallAsString ) { + return expressionResultBuilderFromMatcher( matcher, matcherCallAsString ) + .setLhs( Catch::toString( arg ) ) + .setResultType( matcher.match( arg ) ); + } + +struct TestFailureException{}; + +class ScopedInfo { +public: + ScopedInfo() : m_resultBuilder( ResultWas::Info ) { + getResultCapture().pushScopedInfo( this ); + } + ~ScopedInfo() { + getResultCapture().popScopedInfo( this ); + } + template + ScopedInfo& operator << ( const T& value ) { + m_resultBuilder << value; + return *this; + } + AssertionResult buildResult( const AssertionInfo& assertionInfo ) const { + return m_resultBuilder.buildResult( assertionInfo ); + } + +private: + ExpressionResultBuilder m_resultBuilder; +}; + +// This is just here to avoid compiler warnings with macro constants and boolean literals +inline bool isTrue( bool value ){ return value; } + +} // end namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ACCEPT_EXPR( evaluatedExpr, stopOnFailure, originalExpr ) \ + if( Catch::ResultAction::Value internal_catch_action = Catch::getResultCapture().acceptExpression( evaluatedExpr ) ) { \ + if( internal_catch_action & Catch::ResultAction::Debug ) BreakIntoDebugger(); \ + if( internal_catch_action & Catch::ResultAction::Abort ) throw Catch::TestFailureException(); \ + if( Catch::isTrue( stopOnFailure ) ) throw Catch::TestFailureException(); \ + if( Catch::isTrue( false ) ){ bool this_is_here_to_invoke_warnings = ( originalExpr ); Catch::isTrue( this_is_here_to_invoke_warnings ); } \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ACCEPT_INFO( expr, macroName, shouldNegate ) \ + Catch::getResultCapture().acceptAssertionInfo( Catch::AssertionInfo( macroName, CATCH_INTERNAL_LINEINFO, expr, shouldNegate ) ); + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TEST( expr, shouldNegate, stopOnFailure, macroName ) \ + do { try { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, shouldNegate ); \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionDecomposer()->*expr ).negate( shouldNegate ), stopOnFailure, expr ); \ + } catch( Catch::TestFailureException& ) { \ + throw; \ + } catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), false, expr ); \ + throw; \ + } } while( Catch::isTrue( false ) ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_IF( expr, shouldNegate, stopOnFailure, macroName ) \ + INTERNAL_CATCH_TEST( expr, shouldNegate, stopOnFailure, macroName ); \ + if( Catch::getResultCapture().getLastResult()->ok() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ELSE( expr, shouldNegate, stopOnFailure, macroName ) \ + INTERNAL_CATCH_TEST( expr, shouldNegate, stopOnFailure, macroName ); \ + if( !Catch::getResultCapture().getLastResult()->ok() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_NO_THROW( expr, stopOnFailure, macroName ) \ + try { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, false ); \ + expr; \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \ + } \ + catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), stopOnFailure, false ); \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS( expr, exceptionType, stopOnFailure, macroName ) \ + try { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, false ); \ + if( Catch::getCurrentContext().getConfig()->allowThrows() ) { \ + expr; \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \ + } \ + } \ + catch( Catch::TestFailureException& ) { \ + throw; \ + } \ + catch( exceptionType ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, stopOnFailure, macroName ) \ + INTERNAL_CATCH_THROWS( expr, exceptionType, stopOnFailure, macroName ) \ + catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), stopOnFailure, false ); \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_MSG( reason, resultType, stopOnFailure, macroName ) \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( resultType ) << reason, stopOnFailure, true ); + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_SCOPED_INFO( log, macroName ) \ + INTERNAL_CATCH_ACCEPT_INFO( "", macroName, false ); \ + Catch::ScopedInfo INTERNAL_CATCH_UNIQUE_NAME( info ); \ + INTERNAL_CATCH_UNIQUE_NAME( info ) << log + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CHECK_THAT( arg, matcher, stopOnFailure, macroName ) \ + do { try { \ + INTERNAL_CATCH_ACCEPT_INFO( #arg " " #matcher, macroName, false ) \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::expressionResultBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \ + } catch( Catch::TestFailureException& ) { \ + throw; \ + } catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), false, false ); \ + throw; \ + }}while( Catch::isTrue( false ) ) + +// #included from: internal/catch_section.hpp +#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED + +#include + +namespace Catch { + + class Section { + public: + Section( const std::string& name, + const std::string& description, + const SourceLineInfo& lineInfo ) + : m_name( name ), + m_sectionIncluded( getCurrentContext().getResultCapture().sectionStarted( name, description, lineInfo, m_assertions ) ) + {} + + ~Section() { + if( m_sectionIncluded ) + getCurrentContext().getResultCapture().sectionEnded( m_name, m_assertions ); + } + + // This indicates whether the section should be executed or not + operator bool() { + return m_sectionIncluded; + } + + private: + + std::string m_name; + Counts m_assertions; + bool m_sectionIncluded; + }; + +} // end namespace Catch + +#define INTERNAL_CATCH_SECTION( name, desc ) \ + if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( name, desc, CATCH_INTERNAL_LINEINFO ) ) + +// #included from: internal/catch_generators.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + +template +struct IGenerator { + virtual ~IGenerator() {} + virtual T getValue( std::size_t index ) const = 0; + virtual std::size_t size () const = 0; +}; + +template +class BetweenGenerator : public IGenerator { +public: + BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} + + virtual T getValue( std::size_t index ) const { + return m_from+static_cast( index ); + } + + virtual std::size_t size() const { + return static_cast( 1+m_to-m_from ); + } + +private: + + T m_from; + T m_to; +}; + +template +class ValuesGenerator : public IGenerator { +public: + ValuesGenerator(){} + + void add( T value ) { + m_values.push_back( value ); + } + + virtual T getValue( std::size_t index ) const { + return m_values[index]; + } + + virtual std::size_t size() const { + return m_values.size(); + } + +private: + std::vector m_values; +}; + +template +class CompositeGenerator { +public: + CompositeGenerator() : m_totalSize( 0 ) {} + + // *** Move semantics, similar to auto_ptr *** + CompositeGenerator( CompositeGenerator& other ) + : m_fileInfo( other.m_fileInfo ), + m_totalSize( 0 ) + { + move( other ); + } + + CompositeGenerator& setFileInfo( const char* fileInfo ) { + m_fileInfo = fileInfo; + return *this; + } + + ~CompositeGenerator() { + deleteAll( m_composed ); + } + + operator T () const { + size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); + + typename std::vector*>::const_iterator it = m_composed.begin(); + typename std::vector*>::const_iterator itEnd = m_composed.end(); + for( size_t index = 0; it != itEnd; ++it ) + { + const IGenerator* generator = *it; + if( overallIndex >= index && overallIndex < index + generator->size() ) + { + return generator->getValue( overallIndex-index ); + } + index += generator->size(); + } + CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); + return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so + } + + void add( const IGenerator* generator ) { + m_totalSize += generator->size(); + m_composed.push_back( generator ); + } + + CompositeGenerator& then( CompositeGenerator& other ) { + move( other ); + return *this; + } + + CompositeGenerator& then( T value ) { + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( value ); + add( valuesGen ); + return *this; + } + +private: + + void move( CompositeGenerator& other ) { + std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); + m_totalSize += other.m_totalSize; + other.m_composed.clear(); + } + + std::vector*> m_composed; + std::string m_fileInfo; + size_t m_totalSize; +}; + +namespace Generators +{ + template + CompositeGenerator between( T from, T to ) { + CompositeGenerator generators; + generators.add( new BetweenGenerator( from, to ) ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3 ){ + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3, T val4 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + valuesGen->add( val4 ); + generators.add( valuesGen ); + return generators; + } + +} // end namespace Generators + +using namespace Generators; + +} // end namespace Catch + +#define INTERNAL_CATCH_LINESTR2( line ) #line +#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) + +#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) + +// #included from: internal/catch_interfaces_exception.h +#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED + +#include namespace Catch { @@ -3942,7 +3953,7 @@ namespace Catch { do { do { - m_currentResult.setLineInfo( m_runningTest->getTestCaseInfo().getLineInfo() ); + m_assertionInfo.lineInfo = m_runningTest->getTestCaseInfo().getLineInfo(); runCurrentTest( redirectedCout, redirectedCerr ); } while( m_runningTest->hasUntestedSections() && !aborting() ); @@ -3964,25 +3975,16 @@ namespace Catch { private: // IResultCapture - virtual ResultAction::Value acceptResult( bool result ) { - return acceptResult( result ? ResultWas::Ok : ResultWas::ExpressionFailed ); + virtual void acceptAssertionInfo( const AssertionInfo& assertionInfo ) { + m_assertionInfo = assertionInfo; } - virtual ResultAction::Value acceptResult( ResultWas::OfType result ) { - m_currentResult.setResultType( result ); + virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult ) { + m_currentResult = assertionResult; return actOnCurrentResult(); } - virtual ResultAction::Value acceptExpression( const ResultInfoBuilder& resultInfo ) { - m_currentResult = resultInfo; - return actOnCurrentResult(); - } - - virtual void acceptMessage( const std::string& msg ) { - m_currentResult.setMessage( msg ); - } - - virtual void testEnded( const ResultInfo& result ) { + virtual void testEnded( const AssertionResult& result ) { if( result.getResultType() == ResultWas::Ok ) { m_totals.assertions.passed++; } @@ -3993,19 +3995,19 @@ namespace Catch { std::vector::const_iterator it = m_scopedInfos.begin(); std::vector::const_iterator itEnd = m_scopedInfos.end(); for(; it != itEnd; ++it ) - m_reporter->Result( (*it)->getInfo() ); + m_reporter->Result( (*it)->buildResult( m_assertionInfo ) ); } { - std::vector::const_iterator it = m_info.begin(); - std::vector::const_iterator itEnd = m_info.end(); + std::vector::const_iterator it = m_assertionResults.begin(); + std::vector::const_iterator itEnd = m_assertionResults.end(); for(; it != itEnd; ++it ) m_reporter->Result( *it ); } - m_info.clear(); + m_assertionResults.clear(); } if( result.getResultType() == ResultWas::Info ) - m_info.push_back( result ); + m_assertionResults.push_back( result ); else m_reporter->Result( result ); } @@ -4023,7 +4025,7 @@ namespace Catch { if( !m_runningTest->addSection( oss.str() ) ) return false; - m_currentResult.setLineInfo( lineInfo ); + m_assertionInfo.lineInfo = lineInfo; m_reporter->StartSection( name, description ); assertions = m_totals.assertions; @@ -4062,7 +4064,7 @@ namespace Catch { : ""; } - virtual const ResultInfo* getLastResult() const { + virtual const AssertionResult* getLastResult() const { return &m_lastResult; } @@ -4075,10 +4077,11 @@ namespace Catch { private: ResultAction::Value actOnCurrentResult() { - m_lastResult = m_currentResult.build(); + m_lastResult = m_currentResult.buildResult( m_assertionInfo ); testEnded( m_lastResult ); - m_currentResult = ResultInfoBuilder(); + m_currentResult = ExpressionResultBuilder(); + m_assertionInfo = AssertionInfo(); ResultAction::Value action = ResultAction::None; @@ -4117,26 +4120,29 @@ namespace Catch { // This just means the test was aborted due to failure } catch(...) { - acceptMessage( getRegistryHub().getExceptionTranslatorRegistry().translateActiveException() ); - acceptResult( ResultWas::ThrewException ); + m_currentResult + .setResultType( ResultWas::ThrewException ) + << translateActiveException(); + actOnCurrentResult(); } - m_info.clear(); + m_assertionResults.clear(); } private: IMutableContext& m_context; RunningTest* m_runningTest; - ResultInfoBuilder m_currentResult; - ResultInfo m_lastResult; + ExpressionResultBuilder m_currentResult; + AssertionResult m_lastResult; const Config& m_config; Totals m_totals; Ptr m_reporter; std::vector m_scopedInfos; - std::vector m_info; + std::vector m_assertionResults; IRunner* m_prevRunner; IResultCapture* m_prevResultCapture; const IConfig* m_prevConfig; + AssertionInfo m_assertionInfo; }; } // end namespace Catch @@ -4669,6 +4675,9 @@ namespace Catch { getTheRegistryHub() = NULL; cleanUpContext(); } + std::string translateActiveException() { + return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); + } } // end namespace Catch @@ -4987,151 +4996,145 @@ namespace Catch { } // end namespace Catch -// #included from: catch_resultinfo.hpp -#define TWOBLUECUBES_CATCH_RESULTINFO_HPP_INCLUDED +// #included from: catch_assertionresult.hpp +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED namespace Catch { - ResultInfo::ResultInfo() {} + AssertionResult::AssertionResult() {} - ResultInfo::ResultInfo( const ResultData& data ) : m_data( data ) {} + AssertionResult::AssertionResult( const AssertionInfo& info, const AssertionResultData& data ) + : m_info( info ), + m_resultData( data ) + {} - ResultInfo::~ResultInfo() {} + AssertionResult::~AssertionResult() {} - bool ResultInfo::ok() const { - return isOk( m_data.resultType ); + bool AssertionResult::ok() const { + return isOk( m_resultData.resultType ); } - ResultWas::OfType ResultInfo::getResultType() const { - return m_data.resultType; + ResultWas::OfType AssertionResult::getResultType() const { + return m_resultData.resultType; } - bool ResultInfo::hasExpression() const { - return !m_data.capturedExpression.empty(); + bool AssertionResult::hasExpression() const { + return !m_info.capturedExpression.empty(); } - bool ResultInfo::hasMessage() const { - return !m_data.message.empty(); + bool AssertionResult::hasMessage() const { + return !m_resultData.message.empty(); } - std::string ResultInfo::getExpression() const { - return m_data.capturedExpression; + std::string AssertionResult::getExpression() const { + return m_info.capturedExpression; } - bool ResultInfo::hasExpandedExpression() const { + bool AssertionResult::hasExpandedExpression() const { return hasExpression() && getExpandedExpression() != getExpression(); } - std::string ResultInfo::getExpandedExpression() const { - return m_data.reconstructedExpression; + std::string AssertionResult::getExpandedExpression() const { + return m_resultData.reconstructedExpression; } - std::string ResultInfo::getMessage() const { - return m_data.message; + std::string AssertionResult::getMessage() const { + return m_resultData.message; + } + SourceLineInfo AssertionResult::getSourceInfo() const { + return m_info.lineInfo; } - std::string ResultInfo::getFilename() const { - return m_data.lineInfo.file; - } - - std::size_t ResultInfo::getLine() const { - return m_data.lineInfo.line; - } - - std::string ResultInfo::getTestMacroName() const { - return m_data.macroName; + std::string AssertionResult::getTestMacroName() const { + return m_info.macroName; } } // end namespace Catch -// #included from: catch_resultinfo_builder.hpp -#define TWOBLUECUBES_CATCH_RESULTINFO_BUILDER_HPP_INCLUDED +// #included from: catch_expressionresult_builder.hpp +#define TWOBLUECUBES_CATCH_EXPRESSIONRESULT_BUILDER_HPP_INCLUDED + +#include namespace Catch { - ResultInfoBuilder::ResultInfoBuilder() {} - - ResultInfoBuilder& ResultInfoBuilder::setResultType( ResultWas::OfType result ) { - // Flip bool results if isFalse is set - if( m_isFalse && result == ResultWas::Ok ) - m_data.resultType = ResultWas::ExpressionFailed; - else if( m_isFalse && result == ResultWas::ExpressionFailed ) - m_data.resultType = ResultWas::Ok; - else - m_data.resultType = result; - return *this; + ExpressionResultBuilder::ExpressionResultBuilder( ResultWas::OfType resultType ) { + m_data.resultType = resultType; } - ResultInfoBuilder& ResultInfoBuilder::setCapturedExpression( const std::string& capturedExpression ) { - m_data.capturedExpression = capturedExpression; - return *this; - } - ResultInfoBuilder& ResultInfoBuilder::setIsFalse( bool isFalse ) { - m_isFalse = isFalse; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setMessage( const std::string& message ) { - m_data.message = message; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setLineInfo( const SourceLineInfo& lineInfo ) { - m_data.lineInfo = lineInfo; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setMacroName( const std::string& macroName ) { - m_data.macroName = macroName; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setLhs( const std::string& lhs ) { - m_lhs = lhs; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setRhs( const std::string& rhs ) { - m_rhs = rhs; - return *this; - } - - ResultInfoBuilder& ResultInfoBuilder::setOp( const std::string& op ) { - m_op = op; - return *this; - } - - ResultInfo ResultInfoBuilder::build() const + ExpressionResultBuilder::ExpressionResultBuilder( const ExpressionResultBuilder& other ) + : m_data( other.m_data ), + m_exprComponents( other.m_exprComponents ) { - ResultData data = m_data; - data.reconstructedExpression = reconstructExpression(); - if( m_isFalse ) { - if( m_op == "" ) { - data.capturedExpression = "!" + data.capturedExpression; - data.reconstructedExpression = "!" + data.reconstructedExpression; - } - else { - data.capturedExpression = "!(" + data.capturedExpression + ")"; - data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; - } - } - return ResultInfo( data ); + m_stream << other.m_stream.str(); } + ExpressionResultBuilder& ExpressionResultBuilder::operator=(const ExpressionResultBuilder& other ) { + m_data = other.m_data; + m_exprComponents = other.m_exprComponents; + m_stream.str(""); + m_stream << other.m_stream.str(); + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setResultType( ResultWas::OfType result ) { + m_data.resultType = result; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setResultType( bool result ) { + m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::negate( bool shouldNegate ) { + m_exprComponents.shouldNegate = shouldNegate; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setLhs( const std::string& lhs ) { + m_exprComponents.lhs = lhs; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setRhs( const std::string& rhs ) { + m_exprComponents.rhs = rhs; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setOp( const std::string& op ) { + m_exprComponents.op = op; + return *this; + } + AssertionResult ExpressionResultBuilder::buildResult( const AssertionInfo& info ) const + { + assert( m_data.resultType != ResultWas::Unknown ); - std::string ResultInfoBuilder::reconstructExpression() const { - if( m_op == "" ) - return m_lhs.empty() ? m_data.capturedExpression : m_op + m_lhs; - else if( m_op == "matches" ) - return m_lhs + " " + m_rhs; - else if( m_op != "!" ) { - if( m_lhs.size() + m_rhs.size() < 30 ) - return m_lhs + " " + m_op + " " + m_rhs; - else if( m_lhs.size() < 70 && m_rhs.size() < 70 ) - return "\n\t" + m_lhs + "\n\t" + m_op + "\n\t" + m_rhs; + AssertionResultData data = m_data; + + // Flip bool results if shouldNegate is set + if( m_exprComponents.shouldNegate && data.resultType == ResultWas::Ok ) + data.resultType = ResultWas::ExpressionFailed; + else if( m_exprComponents.shouldNegate && data.resultType == ResultWas::ExpressionFailed ) + data.resultType = ResultWas::Ok; + + data.message = m_stream.str(); + data.reconstructedExpression = reconstructExpression( info ); + if( m_exprComponents.shouldNegate ) { + if( m_exprComponents.op == "" ) + data.reconstructedExpression = "!" + data.reconstructedExpression; else - return "\n" + m_lhs + "\n" + m_op + "\n" + m_rhs + "\n\n"; + data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; + } + return AssertionResult( info, data ); + } + std::string ExpressionResultBuilder::reconstructExpression( const AssertionInfo& info ) const { + if( m_exprComponents.op == "" ) + return m_exprComponents.lhs.empty() ? info.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; + else if( m_exprComponents.op == "matches" ) + return m_exprComponents.lhs + " " + m_exprComponents.rhs; + else if( m_exprComponents.op != "!" ) { + if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 30 ) + return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; + else if( m_exprComponents.lhs.size() < 70 && m_exprComponents.rhs.size() < 70 ) + return "\n\t" + m_exprComponents.lhs + "\n\t" + m_exprComponents.op + "\n\t" + m_exprComponents.rhs; + else + return "\n" + m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs + "\n\n"; } else - return "{can't expand - use " + m_data.macroName + "_FALSE( " + m_data.capturedExpression.substr(1) + " ) instead of " + m_data.macroName + "( " + m_data.capturedExpression + " ) for better diagnostics}"; + return "{can't expand - use " + info.macroName + "_FALSE( " + info.capturedExpression.substr(1) + " ) instead of " + info.macroName + "( " + info.capturedExpression + " ) for better diagnostics}"; } } // end namespace Catch @@ -5414,21 +5417,21 @@ namespace Catch { m_sectionSpans.pop_back(); } - virtual void Result( const ResultInfo& resultInfo ) { - if( !m_config.includeSuccessfulResults && resultInfo.getResultType() == ResultWas::Ok ) + virtual void Result( const AssertionResult& assertionResult ) { + if( !m_config.includeSuccessfulResults && assertionResult.getResultType() == ResultWas::Ok ) return; startSpansLazily(); - if( !resultInfo.getFilename().empty() ) { + if( !assertionResult.getSourceInfo().empty() ) { TextColour colour( TextColour::FileName ); - m_config.stream << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() ); + m_config.stream << assertionResult.getSourceInfo(); } - if( resultInfo.hasExpression() ) { + if( assertionResult.hasExpression() ) { TextColour colour( TextColour::OriginalExpression ); - m_config.stream << resultInfo.getExpression(); - if( resultInfo.ok() ) { + m_config.stream << assertionResult.getExpression(); + if( assertionResult.ok() ) { TextColour successColour( TextColour::Success ); m_config.stream << " succeeded"; } @@ -5437,36 +5440,36 @@ namespace Catch { m_config.stream << " failed"; } } - switch( resultInfo.getResultType() ) { + switch( assertionResult.getResultType() ) { case ResultWas::ThrewException: { TextColour colour( TextColour::Error ); - if( resultInfo.hasExpression() ) + if( assertionResult.hasExpression() ) m_config.stream << " with unexpected"; else m_config.stream << "Unexpected"; - m_config.stream << " exception with message: '" << resultInfo.getMessage() << "'"; + m_config.stream << " exception with message: '" << assertionResult.getMessage() << "'"; } break; case ResultWas::DidntThrowException: { TextColour colour( TextColour::Error ); - if( resultInfo.hasExpression() ) + if( assertionResult.hasExpression() ) m_config.stream << " because no exception was thrown where one was expected"; else m_config.stream << "No exception thrown where one was expected"; } break; case ResultWas::Info: - streamVariableLengthText( "info", resultInfo.getMessage() ); + streamVariableLengthText( "info", assertionResult.getMessage() ); break; case ResultWas::Warning: - m_config.stream << "warning:\n'" << resultInfo.getMessage() << "'"; + streamVariableLengthText( "warning", assertionResult.getMessage() ); break; case ResultWas::ExplicitFailure: { TextColour colour( TextColour::Error ); - m_config.stream << "failed with message: '" << resultInfo.getMessage() << "'"; + m_config.stream << "failed with message: '" << assertionResult.getMessage() << "'"; } break; case ResultWas::Unknown: // These cases are here to prevent compiler warnings @@ -5474,8 +5477,8 @@ namespace Catch { case ResultWas::FailureBit: case ResultWas::ExpressionFailed: case ResultWas::Exception: - if( !resultInfo.hasExpression() ) { - if( resultInfo.ok() ) { + if( !assertionResult.hasExpression() ) { + if( assertionResult.ok() ) { TextColour colour( TextColour::Success ); m_config.stream << " succeeded"; } @@ -5487,14 +5490,14 @@ namespace Catch { break; } - if( resultInfo.hasExpandedExpression() ) { + if( assertionResult.hasExpandedExpression() ) { m_config.stream << " for: "; - if( resultInfo.getExpandedExpression().size() > 40 ) + if( assertionResult.getExpandedExpression().size() > 40 ) m_config.stream << "\n"; - if( resultInfo.getExpandedExpression().size() < 70 ) + if( assertionResult.getExpandedExpression().size() < 70 ) m_config.stream << "\t"; TextColour colour( TextColour::ReconstructedExpression ); - m_config.stream << resultInfo.getExpandedExpression(); + m_config.stream << assertionResult.getExpandedExpression(); } m_config.stream << std::endl; } @@ -5564,7 +5567,7 @@ namespace Catch { void streamVariableLengthText( const std::string& prefix, const std::string& text ) { std::string trimmed = trim( text ); if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) { - m_config.stream << "[" << prefix << ": " << trimmed << "]\n"; + m_config.stream << "[" << prefix << ": " << trimmed << "]"; } else { m_config.stream << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed @@ -5853,42 +5856,42 @@ namespace Catch { m_currentTestSuccess = true; } - virtual void Result( const Catch::ResultInfo& resultInfo ) { - if( !m_config.includeSuccessfulResults && resultInfo.getResultType() == ResultWas::Ok ) + virtual void Result( const Catch::AssertionResult& assertionResult ) { + if( !m_config.includeSuccessfulResults && assertionResult.getResultType() == ResultWas::Ok ) return; - if( resultInfo.hasExpression() ) { + if( assertionResult.hasExpression() ) { m_xml.startElement( "Expression" ) - .writeAttribute( "success", resultInfo.ok() ) - .writeAttribute( "filename", resultInfo.getFilename() ) - .writeAttribute( "line", resultInfo.getLine() ); + .writeAttribute( "success", assertionResult.ok() ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ); m_xml.scopedElement( "Original" ) - .writeText( resultInfo.getExpression() ); + .writeText( assertionResult.getExpression() ); m_xml.scopedElement( "Expanded" ) - .writeText( resultInfo.getExpandedExpression() ); - m_currentTestSuccess &= resultInfo.ok(); + .writeText( assertionResult.getExpandedExpression() ); + m_currentTestSuccess &= assertionResult.ok(); } - switch( resultInfo.getResultType() ) { + switch( assertionResult.getResultType() ) { case ResultWas::ThrewException: m_xml.scopedElement( "Exception" ) - .writeAttribute( "filename", resultInfo.getFilename() ) - .writeAttribute( "line", resultInfo.getLine() ) - .writeText( resultInfo.getMessage() ); + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ) + .writeText( assertionResult.getMessage() ); m_currentTestSuccess = false; break; case ResultWas::Info: m_xml.scopedElement( "Info" ) - .writeText( resultInfo.getMessage() ); + .writeText( assertionResult.getMessage() ); break; case ResultWas::Warning: m_xml.scopedElement( "Warning" ) - .writeText( resultInfo.getMessage() ); + .writeText( assertionResult.getMessage() ); break; case ResultWas::ExplicitFailure: m_xml.scopedElement( "Failure" ) - .writeText( resultInfo.getMessage() ); + .writeText( assertionResult.getMessage() ); m_currentTestSuccess = false; break; case ResultWas::Unknown: @@ -5899,7 +5902,7 @@ namespace Catch { case ResultWas::DidntThrowException: break; } - if( resultInfo.hasExpression() ) + if( assertionResult.hasExpression() ) m_xml.endElement(); } @@ -6007,19 +6010,19 @@ namespace Catch { m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getName() ) ); } - virtual void Result( const Catch::ResultInfo& resultInfo ) { - if( resultInfo.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults ) { + virtual void Result( const Catch::AssertionResult& assertionResult ) { + if( assertionResult.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults ) { TestCaseStats& testCaseStats = m_currentStats->m_testCaseStats.back(); TestStats stats; std::ostringstream oss; - if( !resultInfo.getMessage().empty() ) - oss << resultInfo.getMessage() << " at "; - oss << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() ); + if( !assertionResult.getMessage().empty() ) + oss << assertionResult.getMessage() << " at "; + oss << assertionResult.getSourceInfo(); stats.m_content = oss.str(); - stats.m_message = resultInfo.getExpandedExpression(); - stats.m_resultType = resultInfo.getTestMacroName(); + stats.m_message = assertionResult.getExpandedExpression(); + stats.m_resultType = assertionResult.getTestMacroName(); - switch( resultInfo.getResultType() ) { + switch( assertionResult.getResultType() ) { case ResultWas::ThrewException: stats.m_element = "error"; m_currentStats->m_errorsCount++; @@ -6244,9 +6247,9 @@ int main (int argc, char * const argv[]) { #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Warning, false, "CATCH_WARN" ) #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::ExplicitFailure, true, "CATCH_FAIL" ) #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Ok, false, "CATCH_SUCCEED" ) -#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg ) +#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg, "CATCH_SCOPED_INFO" ) #define CATCH_CAPTURE( msg ) INTERNAL_CATCH_MSG( #msg " := " << msg, Catch::ResultWas::Info, false, "CATCH_CAPTURE" ) -#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg ) +#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg, "CATCH_SCOPED_CAPTURE" ) #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) @@ -6289,9 +6292,9 @@ int main (int argc, char * const argv[]) { #define WARN( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Warning, false, "WARN" ) #define FAIL( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::ExplicitFailure, true, "FAIL" ) #define SUCCEED( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Ok, false, "SUCCEED" ) -#define SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg ) +#define SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg, "SCOPED_INFO" ) #define CAPTURE( msg ) INTERNAL_CATCH_MSG( #msg " := " << msg, Catch::ResultWas::Info, false, "CAPTURE" ) -#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg ) +#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg, "SCOPED_CAPTURE" ) #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )