3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-12-28 21:53:30 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactoring ResultData out of ResultInfo/ Builder pt1

Browse Source
This commit is contained in:
Phil Nash 2012-10-05 18:35:01 +01:00
parent 47f679ef21
commit 86e1915099
9 changed files with 131 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/internal/catch_capture.hpp
View File

@ -39,7 +39,8 @@ public:
return ResultInfoBuilder()
.setResultType( ResultWas::Info )
.setMessage( m_oss.str() )
.setMacroName( "SCOPED_INFO" );
.setMacroName( "SCOPED_INFO" )
.build();
}
private:

20
include/internal/catch_expression.hpp
View File

@ -25,44 +25,44 @@ public:
template<typename RhsT>
ResultInfoBuilder& operator == ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsEqualTo>( m_result, m_lhs, rhs );
}
template<typename RhsT>
ResultInfoBuilder& operator != ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsNotEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsNotEqualTo>( m_result, m_lhs, rhs );
}
template<typename RhsT>
ResultInfoBuilder& operator < ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsLessThan>( m_lhs, rhs );
return captureExpression<Internal::IsLessThan>( m_result, m_lhs, rhs );
}
template<typename RhsT>
ResultInfoBuilder& operator > ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsGreaterThan>( m_lhs, rhs );
return captureExpression<Internal::IsGreaterThan>( m_result, m_lhs, rhs );
}
template<typename RhsT>
ResultInfoBuilder& operator <= ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsLessThanOrEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsLessThanOrEqualTo>( m_result, m_lhs, rhs );
}
template<typename RhsT>
ResultInfoBuilder& operator >= ( const RhsT& rhs ) {
return m_result.captureExpression<Internal::IsGreaterThanOrEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsGreaterThanOrEqualTo>( m_result, m_lhs, rhs );
}
ResultInfoBuilder& operator == ( bool rhs ) {
return m_result.captureExpression<Internal::IsEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsEqualTo>( m_result, m_lhs, rhs );
}
ResultInfoBuilder& operator != ( bool rhs ) {
return m_result.captureExpression<Internal::IsNotEqualTo>( m_lhs, rhs );
return captureExpression<Internal::IsNotEqualTo>( m_result, m_lhs, rhs );
}
operator ResultInfoBuilder& () {
return m_result.captureBoolExpression( m_lhs );
return captureBoolExpression( m_result, m_lhs );
}
template<typename RhsT>

29
include/internal/catch_expression_builder.hpp
View File

@ -26,9 +26,14 @@ public:
const char* macroName,
const char* expr = "",
bool isNot = false )
: m_result( expr, isNot, lineInfo, macroName ),
m_messageStream()
{}
: m_messageStream()
{
m_result
.setCapturedExpression( expr )
.setIsFalse( isNot )
.setLineInfo( lineInfo )
.setMacroName( macroName );
}
template<typename T>
Expression<const T&> operator->* ( const T & operand ) {
@ -54,10 +59,11 @@ public:
std::string matcherAsString = Catch::toString( matcher );
if( matcherAsString == "{?}" )
matcherAsString = matcherCallAsString;
m_result.setLhs( Catch::toString( arg ) );
m_result.setRhs( matcherAsString );
m_result.setOp( "matches" );
m_result.setResultType( matcher( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
m_result
.setLhs( Catch::toString( arg ) )
.setRhs( matcherAsString )
.setOp( "matches" )
.setResultType( matcher( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
return *this;
}
@ -68,10 +74,11 @@ public:
std::string matcherAsString = Catch::toString( matcher );
if( matcherAsString == "{?}" )
matcherAsString = matcherCallAsString;
m_result.setLhs( Catch::toString( arg ) );
m_result.setRhs( matcherAsString );
m_result.setOp( "matches" );
m_result.setResultType( matcher( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
m_result
.setLhs( Catch::toString( arg ) )
.setRhs( matcherAsString )
.setOp( "matches" )
.setResultType( matcher( arg ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
return *this;
}

4
include/internal/catch_result_type.h
View File

@ -28,6 +28,10 @@ struct ResultWas { enum OfType {
}; };
inline bool isOk( ResultWas::OfType resultType ) {
return ( resultType & ResultWas::FailureBit ) == 0;
}
struct ResultAction { enum Value {
None,
Failed = 1, // Failure - but no debug break if Debug bit not set

16
include/internal/catch_resultinfo.h
View File

@ -13,9 +13,22 @@
namespace Catch {
struct ResultData
{
ResultData() : resultType( ResultWas::Unknown ) {}
std::string macroName;
SourceLineInfo lineInfo;
std::string capturedExpression;
std::string reconstructedExpression;
std::string message;
ResultWas::OfType resultType;
};
class ResultInfo {
public:
ResultInfo();
ResultInfo();
ResultInfo( const ResultData& data );
~ResultInfo();
bool ok() const;
@ -42,6 +55,7 @@ namespace Catch {
bool isNotExpression( const char* expr );
protected:
ResultData m_data;
std::string m_macroName;
SourceLineInfo m_lineInfo;
std::string m_expr, m_lhs, m_rhs, m_op;

2
include/internal/catch_resultinfo.hpp
View File

@ -23,6 +23,8 @@ namespace Catch {
m_isNot( false )
{}
ResultInfo::ResultInfo( const ResultData& data ) : m_data( data ) {}
ResultInfo::ResultInfo(const char* expr,
ResultWas::OfType result,
bool isNot,

60
include/internal/catch_resultinfo_builder.h
View File

@ -18,54 +18,56 @@ namespace Catch {
struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
class ResultInfoBuilder : public ResultInfo {
class ResultInfoBuilder : protected ResultInfo {
public:
ResultInfoBuilder();
ResultInfoBuilder();
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 );
std::string reconstructExpression() const;
const ResultInfo& build() const;
// Disable attempts to use || and && in expressions (without parantheses)
template<typename RhsT>
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( const RhsT& );
template<typename RhsT>
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( const RhsT& );
private:
ResultInfoBuilder( const char* expr,
bool isNot,
const SourceLineInfo& lineInfo,
const char* macroName );
friend class ExpressionBuilder;
template<typename T> friend class Expression;
template<typename T> friend class PtrExpression;
ResultInfoBuilder& captureBoolExpression( bool result );
template<Internal::Operator Op, typename T1, typename T2>
ResultInfoBuilder& captureExpression( const T1& lhs, const T2& rhs ) {
setResultType( Internal::compare<Op>( lhs, rhs ) ? ResultWas::Ok : ResultWas::ExpressionFailed );
m_lhs = Catch::toString( lhs );
m_rhs = Catch::toString( rhs );
m_op = Internal::OperatorTraits<Op>::getName();
return *this;
bool getIsFalse() const {
return m_isNot;
}
template<Internal::Operator Op, typename T>
ResultInfoBuilder& captureExpression( const T* lhs, int rhs ) {
return captureExpression<Op>( lhs, reinterpret_cast<const T*>( rhs ) );
}
private:
ResultData m_data;
};
template<Internal::Operator Op, typename T1, typename T2>
ResultInfoBuilder& captureExpression( ResultInfoBuilder& builder, const T1& lhs, const T2& rhs ) {
return builder
.setResultType( Internal::compare<Op>( lhs, rhs ) ? ResultWas::Ok : ResultWas::ExpressionFailed )
.setLhs( Catch::toString( lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
template<Internal::Operator Op, typename T>
ResultInfoBuilder& captureExpression( ResultInfoBuilder& builder, const T* lhs, int rhs ) {
return captureExpression<Op>( builder, lhs, reinterpret_cast<const T*>( rhs ) );
}
ResultInfoBuilder& captureBoolExpression( ResultInfoBuilder& builder, bool result );
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_RESULTINFO_BUILDER_H_INCLUDED

61
include/internal/catch_resultinfo_builder.hpp
View File

@ -12,13 +12,6 @@
namespace Catch {
ResultInfoBuilder::ResultInfoBuilder( const char* expr,
bool isNot,
const SourceLineInfo& lineInfo,
const char* macroName )
: ResultInfo( expr, ResultWas::Unknown, isNot, lineInfo, macroName, "" )
{}
ResultInfoBuilder::ResultInfoBuilder() {}
ResultInfoBuilder& ResultInfoBuilder::setResultType( ResultWas::OfType result ) {
@ -29,16 +22,34 @@ namespace Catch {
m_result = ResultWas::Ok;
else
m_result = result;
m_data.resultType = m_result;
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setCapturedExpression( const std::string& capturedExpression ) {
m_expr = capturedExpression;
m_data.capturedExpression = capturedExpression;
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setIsFalse( bool isFalse ) {
m_isNot = isFalse;
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setMessage( const std::string& message ) {
m_message = message;
m_data.message = message;
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setLineInfo( const SourceLineInfo& lineInfo ) {
m_lineInfo = lineInfo;
m_data.lineInfo = lineInfo;
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setMacroName( const std::string& macroName ) {
m_macroName = macroName;
m_data.macroName = macroName;
return *this;
}
@ -57,18 +68,38 @@ namespace Catch {
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::setMacroName( const std::string& macroName ) {
m_macroName = macroName;
ResultInfoBuilder& captureBoolExpression( ResultInfoBuilder& builder, bool result ) {
return builder
.setLhs( Catch::toString( result ) )
.setOp( builder.getIsFalse() ? "!" : "" )
.setResultType( result ? ResultWas::Ok : ResultWas::ExpressionFailed );
}
const ResultInfo& ResultInfoBuilder::build() const
{
ResultData data = m_data;
data.reconstructedExpression = reconstructExpression();
return *this;
}
ResultInfoBuilder& ResultInfoBuilder::captureBoolExpression( bool result ) {
m_lhs = Catch::toString( result );
m_op = m_isNot ? "!" : "";
setResultType( result ? ResultWas::Ok : ResultWas::ExpressionFailed );
return *this;
std::string ResultInfoBuilder::reconstructExpression() const {
if( m_op == "" || m_isNot )
return m_lhs.empty() ? m_expr : 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;
else
return "\n" + m_lhs + "\n" + m_op + "\n" + m_rhs + "\n\n";
}
else
return "{can't expand - use " + m_data.macroName + "_FALSE( " + m_expr.substr(1) + " ) instead of " + m_data.macroName + "( " + m_expr + " ) for better diagnostics}";
}
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_RESULTINFO_BUILDER_HPP_INCLUDED

6
include/internal/catch_runner_impl.hpp
View File

@ -242,9 +242,9 @@ namespace Catch {
private:
ResultAction::Value actOnCurrentResult() {
testEnded( m_currentResult );
m_lastResult = m_currentResult;
m_lastResult = m_currentResult.build();
testEnded( m_lastResult );
m_currentResult = ResultInfoBuilder();
ResultAction::Value action = ResultAction::None;