mirror of
https://github.com/catchorg/Catch2.git
synced 2024-11-04 05:09:53 +01:00
Refactored assertion builder stuff out of expression builder
This commit is contained in:
parent
c96f9330a0
commit
3ad13256e1
@ -22,17 +22,24 @@ class AssertionResultBuilder {
|
||||
public:
|
||||
|
||||
AssertionResultBuilder();
|
||||
AssertionResultBuilder( const AssertionResultBuilder& other );
|
||||
AssertionResultBuilder& operator=(const AssertionResultBuilder& other );
|
||||
|
||||
AssertionResultBuilder& setResultType( ResultWas::OfType result );
|
||||
AssertionResultBuilder& setCapturedExpression( const std::string& capturedExpression );
|
||||
AssertionResultBuilder& setIsFalse( bool isFalse );
|
||||
AssertionResultBuilder& setMessage( const std::string& message );
|
||||
AssertionResultBuilder& setLineInfo( const SourceLineInfo& lineInfo );
|
||||
AssertionResultBuilder& setLhs( const std::string& lhs );
|
||||
AssertionResultBuilder& setRhs( const std::string& rhs );
|
||||
AssertionResultBuilder& setOp( const std::string& op );
|
||||
AssertionResultBuilder& setMacroName( const std::string& macroName );
|
||||
|
||||
template<typename T>
|
||||
AssertionResultBuilder& operator << ( const T& value ) {
|
||||
m_stream << value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::string reconstructExpression() const;
|
||||
|
||||
AssertionResult build() const;
|
||||
@ -43,14 +50,14 @@ public:
|
||||
template<typename RhsT>
|
||||
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( const RhsT& );
|
||||
|
||||
bool getIsFalse() const {
|
||||
return m_isFalse;
|
||||
}
|
||||
|
||||
private:
|
||||
AssertionResultData m_data;
|
||||
std::string m_lhs, m_rhs, m_op;
|
||||
bool m_isFalse;
|
||||
struct ExprComponents {
|
||||
ExprComponents() : isFalse( false ) {}
|
||||
bool isFalse;
|
||||
std::string lhs, rhs, op;
|
||||
} m_exprComponents;
|
||||
std::ostringstream m_stream;
|
||||
};
|
||||
|
||||
} // end namespace Catch
|
||||
|
@ -13,12 +13,26 @@
|
||||
namespace Catch {
|
||||
|
||||
AssertionResultBuilder::AssertionResultBuilder() {}
|
||||
AssertionResultBuilder::AssertionResultBuilder( const AssertionResultBuilder& other )
|
||||
: m_data( other.m_data ),
|
||||
m_exprComponents( other.m_exprComponents )
|
||||
{
|
||||
m_stream << other.m_stream.str();
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::operator=(const AssertionResultBuilder& other ) {
|
||||
m_data = other.m_data;
|
||||
m_exprComponents = other.m_exprComponents;
|
||||
m_stream.clear();
|
||||
m_stream << other.m_stream.str();
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::setResultType( ResultWas::OfType result ) {
|
||||
// Flip bool results if isFalse is set
|
||||
if( m_isFalse && result == ResultWas::Ok )
|
||||
if( m_exprComponents.isFalse && result == ResultWas::Ok )
|
||||
m_data.resultType = ResultWas::ExpressionFailed;
|
||||
else if( m_isFalse && result == ResultWas::ExpressionFailed )
|
||||
else if( m_exprComponents.isFalse && result == ResultWas::ExpressionFailed )
|
||||
m_data.resultType = ResultWas::Ok;
|
||||
else
|
||||
m_data.resultType = result;
|
||||
@ -29,12 +43,7 @@ namespace Catch {
|
||||
return *this;
|
||||
}
|
||||
AssertionResultBuilder& AssertionResultBuilder::setIsFalse( bool isFalse ) {
|
||||
m_isFalse = isFalse;
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::setMessage( const std::string& message ) {
|
||||
m_data.message = message;
|
||||
m_exprComponents.isFalse = isFalse;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -49,26 +58,27 @@ namespace Catch {
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::setLhs( const std::string& lhs ) {
|
||||
m_lhs = lhs;
|
||||
m_exprComponents.lhs = lhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::setRhs( const std::string& rhs ) {
|
||||
m_rhs = rhs;
|
||||
m_exprComponents.rhs = rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResultBuilder& AssertionResultBuilder::setOp( const std::string& op ) {
|
||||
m_op = op;
|
||||
m_exprComponents.op = op;
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResult AssertionResultBuilder::build() const
|
||||
{
|
||||
AssertionResultData data = m_data;
|
||||
data.message = m_stream.str();
|
||||
data.reconstructedExpression = reconstructExpression();
|
||||
if( m_isFalse ) {
|
||||
if( m_op == "" ) {
|
||||
if( m_exprComponents.isFalse ) {
|
||||
if( m_exprComponents.op == "" ) {
|
||||
data.capturedExpression = "!" + data.capturedExpression;
|
||||
data.reconstructedExpression = "!" + data.reconstructedExpression;
|
||||
}
|
||||
@ -81,17 +91,17 @@ namespace Catch {
|
||||
}
|
||||
|
||||
std::string AssertionResultBuilder::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;
|
||||
if( m_exprComponents.op == "" )
|
||||
return m_exprComponents.lhs.empty() ? m_data.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_lhs + "\n" + m_op + "\n" + m_rhs + "\n\n";
|
||||
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}";
|
||||
|
@ -9,6 +9,7 @@
|
||||
#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
|
||||
|
||||
#include "catch_expression_builder.hpp"
|
||||
#include "catch_assertionresult_builder.h"
|
||||
#include "catch_interfaces_capture.h"
|
||||
#include "catch_debugger.hpp"
|
||||
#include "catch_context.h"
|
||||
@ -22,11 +23,44 @@ namespace Catch {
|
||||
return getCurrentContext().getResultCapture();
|
||||
}
|
||||
|
||||
template<typename MatcherT>
|
||||
AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
|
||||
const std::string& matcherCallAsString ) {
|
||||
std::string matcherAsString = matcher.toString();
|
||||
if( matcherAsString == "{?}" )
|
||||
matcherAsString = matcherCallAsString;
|
||||
return AssertionResultBuilder()
|
||||
.setRhs( matcherAsString )
|
||||
.setOp( "matches" );
|
||||
}
|
||||
|
||||
template<typename MatcherT, typename ArgT>
|
||||
AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
|
||||
const ArgT& arg,
|
||||
const std::string& matcherCallAsString ) {
|
||||
return assertionBuilderFromMatcher( matcher, matcherCallAsString )
|
||||
.setLhs( Catch::toString( arg ) )
|
||||
.setResultType( matcher.match( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
|
||||
}
|
||||
|
||||
template<typename MatcherT, typename ArgT>
|
||||
AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
|
||||
ArgT* arg,
|
||||
const std::string& matcherCallAsString ) {
|
||||
return assertionBuilderFromMatcher( matcher, matcherCallAsString )
|
||||
.setLhs( Catch::toString( arg ) )
|
||||
.setResultType( matcher.match( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
|
||||
}
|
||||
|
||||
struct TestFailureException{};
|
||||
|
||||
class ScopedInfo {
|
||||
public:
|
||||
ScopedInfo() : m_oss() {
|
||||
ScopedInfo() {
|
||||
m_resultBuilder
|
||||
.setResultType( ResultWas::Info )
|
||||
.setMacroName( "SCOPED_INFO" );
|
||||
|
||||
getResultCapture().pushScopedInfo( this );
|
||||
}
|
||||
|
||||
@ -36,30 +70,27 @@ public:
|
||||
|
||||
template<typename T>
|
||||
ScopedInfo& operator << ( const T& value ) {
|
||||
m_oss << value;
|
||||
m_resultBuilder << value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
AssertionResult getInfo () const {
|
||||
return AssertionResultBuilder()
|
||||
.setResultType( ResultWas::Info )
|
||||
.setMessage( m_oss.str() )
|
||||
.setMacroName( "SCOPED_INFO" )
|
||||
.build();
|
||||
return m_resultBuilder.build();
|
||||
}
|
||||
|
||||
private:
|
||||
AssertionResultBuilder m_resultBuilder;
|
||||
std::ostringstream m_oss;
|
||||
};
|
||||
|
||||
// This is just here to avoid compiler warnings with macro constants
|
||||
// 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( expr, stopOnFailure, originalExpr ) \
|
||||
if( Catch::ResultAction::Value internal_catch_action = Catch::getResultCapture().acceptExpression( expr ) ) { \
|
||||
#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(); \
|
||||
@ -74,7 +105,7 @@ inline bool isTrue( bool value ){ return value; }
|
||||
} catch( Catch::TestFailureException& ) { \
|
||||
throw; \
|
||||
} catch( ... ) { \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder() << Catch::translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), false, expr ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), false, expr ); \
|
||||
throw; \
|
||||
} } while( Catch::isTrue( false ) )
|
||||
|
||||
@ -93,10 +124,10 @@ inline bool isTrue( bool value ){ return value; }
|
||||
try { \
|
||||
Catch::getResultCapture().acceptAssertionInfo( Catch::AssertionInfo( macroName, CATCH_INTERNAL_LINEINFO, #expr ) ); \
|
||||
expr; \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder().setResultType( Catch::ResultWas::Ok ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::Ok ), stopOnFailure, false ); \
|
||||
} \
|
||||
catch( ... ) { \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder() << Catch::translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), stopOnFailure, false ); \
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@ -105,26 +136,26 @@ inline bool isTrue( bool value ){ return value; }
|
||||
Catch::getResultCapture().acceptAssertionInfo( Catch::AssertionInfo( macroName, CATCH_INTERNAL_LINEINFO, #expr ) ); \
|
||||
if( Catch::getCurrentContext().getConfig()->allowThrows() ) { \
|
||||
expr; \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder().setResultType( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \
|
||||
} \
|
||||
} \
|
||||
catch( Catch::TestFailureException& ) { \
|
||||
throw; \
|
||||
} \
|
||||
catch( exceptionType ) { \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionBuilder().setResultType( Catch::ResultWas::Ok ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder().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::getRegistryHub().getExceptionTranslatorRegistry() ).setResultType( Catch::ResultWas::ThrewException ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), stopOnFailure, false ); \
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#define INTERNAL_CATCH_MSG( reason, resultType, stopOnFailure, macroName ) \
|
||||
Catch::getResultCapture().acceptExpression( ( Catch::ExpressionBuilder() << reason ).setResultType( resultType ) );
|
||||
Catch::getResultCapture().acceptExpression( Catch::AssertionResultBuilder().setResultType( resultType ) << reason );
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#define INTERNAL_CATCH_SCOPED_INFO( log ) \
|
||||
@ -135,11 +166,11 @@ inline bool isTrue( bool value ){ return value; }
|
||||
#define INTERNAL_CHECK_THAT( arg, matcher, stopOnFailure, macroName ) \
|
||||
do { try { \
|
||||
Catch::getResultCapture().acceptAssertionInfo( Catch::AssertionInfo( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher ) ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder().acceptMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::assertionBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \
|
||||
} catch( Catch::TestFailureException& ) { \
|
||||
throw; \
|
||||
} catch( ... ) { \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionBuilder() << Catch::translateActiveException() ).setResultType( Catch::ResultWas::ThrewException ), false, false ); \
|
||||
INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::AssertionResultBuilder().setResultType( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), false, false ); \
|
||||
throw; \
|
||||
}}while( Catch::isTrue( false ) )
|
||||
|
||||
|
@ -10,12 +10,6 @@
|
||||
|
||||
#include "catch_expression.hpp"
|
||||
#include "catch_assertionresult_builder.h"
|
||||
#include "catch_tostring.hpp"
|
||||
#include "catch_assertionresult.h"
|
||||
#include "catch_result_type.h"
|
||||
#include "catch_context.h"
|
||||
#include "catch_common.h"
|
||||
#include <sstream>
|
||||
|
||||
namespace Catch {
|
||||
|
||||
@ -23,7 +17,6 @@ class ExpressionBuilder {
|
||||
public:
|
||||
|
||||
ExpressionBuilder( bool isFalse = false )
|
||||
: m_messageStream()
|
||||
{
|
||||
m_result.setIsFalse( isFalse );
|
||||
}
|
||||
@ -38,56 +31,9 @@ public:
|
||||
Expression<bool> expr( m_result, value );
|
||||
return expr;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ExpressionBuilder& operator << ( const T & value ) {
|
||||
m_messageStream << Catch::toString( value );
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename MatcherT, typename ArgT>
|
||||
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<typename MatcherT, typename ArgT>
|
||||
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 AssertionResultBuilder&() {
|
||||
m_result.setMessage( m_messageStream.str() );
|
||||
return m_result;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
AssertionResultBuilder m_result;
|
||||
std::ostringstream m_messageStream;
|
||||
};
|
||||
|
||||
} // end namespace Catch
|
||||
|
@ -39,7 +39,6 @@ namespace Catch {
|
||||
virtual ResultAction::Value acceptResult( bool result ) = 0;
|
||||
virtual ResultAction::Value acceptResult( ResultWas::OfType result ) = 0;
|
||||
virtual ResultAction::Value acceptExpression( const AssertionResultBuilder& assertionResult ) = 0;
|
||||
virtual void acceptMessage( const std::string& msg ) = 0;
|
||||
|
||||
virtual std::string getCurrentTestName() const = 0;
|
||||
virtual const AssertionResult* getLastResult() const = 0;
|
||||
|
@ -148,10 +148,6 @@ namespace Catch {
|
||||
return actOnCurrentResult();
|
||||
}
|
||||
|
||||
virtual void acceptMessage( const std::string& msg ) {
|
||||
m_currentResult.setMessage( msg );
|
||||
}
|
||||
|
||||
virtual void testEnded( const AssertionResult& result ) {
|
||||
if( result.getResultType() == ResultWas::Ok ) {
|
||||
m_totals.assertions.passed++;
|
||||
@ -293,8 +289,10 @@ 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();
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user