2012-08-08 09:50:38 +02:00
|
|
|
/*
|
|
|
|
* Created by Phil on 28/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)
|
|
|
|
*/
|
2012-10-16 09:27:21 +02:00
|
|
|
#ifndef TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
|
|
|
|
#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
|
2012-08-08 09:50:38 +02:00
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include "catch_result_type.h"
|
|
|
|
|
|
|
|
namespace Catch {
|
|
|
|
|
2017-01-09 13:23:10 +01:00
|
|
|
struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
|
|
|
|
|
|
|
|
struct DecomposedExpression
|
|
|
|
{
|
|
|
|
virtual ~DecomposedExpression() {}
|
|
|
|
virtual bool isBinaryExpression() const {
|
|
|
|
return false;
|
|
|
|
}
|
2017-02-06 16:15:43 +01:00
|
|
|
virtual std::string reconstructExpression() const = 0;
|
|
|
|
|
|
|
|
std::string reconstructExpressionImpl( std::string const& lhs, std::string const& rhs, std::string const& op ) const {
|
|
|
|
std::string dest;
|
|
|
|
char delim = lhs.size() + rhs.size() < 40 &&
|
|
|
|
lhs.find('\n') == std::string::npos &&
|
|
|
|
rhs.find('\n') == std::string::npos ? ' ' : '\n';
|
|
|
|
dest.reserve( 7 + lhs.size() + rhs.size() );
|
|
|
|
// 2 for spaces around operator
|
|
|
|
// 2 for operator
|
|
|
|
// 2 for parentheses (conditionally added later)
|
|
|
|
// 1 for negation (conditionally added later)
|
|
|
|
dest = lhs;
|
|
|
|
dest += delim;
|
|
|
|
dest += op;
|
|
|
|
dest += delim;
|
|
|
|
dest += rhs;
|
|
|
|
return dest;
|
|
|
|
}
|
2017-01-09 13:23:10 +01:00
|
|
|
|
|
|
|
// Only simple binary comparisons can be decomposed.
|
|
|
|
// If more complex check is required then wrap sub-expressions in parentheses.
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
|
|
|
|
template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
|
|
|
|
};
|
|
|
|
|
2012-10-17 09:14:22 +02:00
|
|
|
struct AssertionInfo
|
|
|
|
{
|
|
|
|
AssertionInfo() {}
|
2013-04-23 19:58:56 +02:00
|
|
|
AssertionInfo( std::string const& _macroName,
|
|
|
|
SourceLineInfo const& _lineInfo,
|
|
|
|
std::string const& _capturedExpression,
|
2012-11-13 10:44:52 +01:00
|
|
|
ResultDisposition::Flags _resultDisposition );
|
2012-10-17 09:14:22 +02:00
|
|
|
|
|
|
|
std::string macroName;
|
|
|
|
SourceLineInfo lineInfo;
|
|
|
|
std::string capturedExpression;
|
2012-11-13 10:44:52 +01:00
|
|
|
ResultDisposition::Flags resultDisposition;
|
2012-10-17 09:14:22 +02:00
|
|
|
};
|
|
|
|
|
2012-10-16 09:33:13 +02:00
|
|
|
struct AssertionResultData
|
2012-10-05 19:35:01 +02:00
|
|
|
{
|
2017-01-09 13:23:10 +01:00
|
|
|
AssertionResultData() : decomposedExpression( CATCH_NULL )
|
|
|
|
, resultType( ResultWas::Unknown )
|
|
|
|
, negated( false )
|
|
|
|
, parenthesized( false ) {}
|
|
|
|
|
|
|
|
void negate( bool parenthesize ) {
|
|
|
|
negated = !negated;
|
|
|
|
parenthesized = parenthesize;
|
|
|
|
if( resultType == ResultWas::Ok )
|
|
|
|
resultType = ResultWas::ExpressionFailed;
|
|
|
|
else if( resultType == ResultWas::ExpressionFailed )
|
|
|
|
resultType = ResultWas::Ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string const& reconstructExpression() const {
|
|
|
|
if( decomposedExpression != CATCH_NULL ) {
|
2017-02-06 16:15:43 +01:00
|
|
|
reconstructedExpression = decomposedExpression->reconstructExpression();
|
2017-01-09 13:23:10 +01:00
|
|
|
if( parenthesized ) {
|
|
|
|
reconstructedExpression.insert( 0, 1, '(' );
|
|
|
|
reconstructedExpression.append( 1, ')' );
|
|
|
|
}
|
|
|
|
if( negated ) {
|
|
|
|
reconstructedExpression.insert( 0, 1, '!' );
|
|
|
|
}
|
|
|
|
decomposedExpression = CATCH_NULL;
|
|
|
|
}
|
|
|
|
return reconstructedExpression;
|
|
|
|
}
|
2012-10-05 19:35:01 +02:00
|
|
|
|
2017-01-09 13:23:10 +01:00
|
|
|
mutable DecomposedExpression const* decomposedExpression;
|
|
|
|
mutable std::string reconstructedExpression;
|
2012-10-05 19:35:01 +02:00
|
|
|
std::string message;
|
|
|
|
ResultWas::OfType resultType;
|
2017-01-09 13:23:10 +01:00
|
|
|
bool negated;
|
|
|
|
bool parenthesized;
|
2012-10-05 19:35:01 +02:00
|
|
|
};
|
|
|
|
|
2012-10-16 09:27:21 +02:00
|
|
|
class AssertionResult {
|
2012-08-08 09:50:38 +02:00
|
|
|
public:
|
2012-10-16 09:27:21 +02:00
|
|
|
AssertionResult();
|
2013-04-23 19:58:56 +02:00
|
|
|
AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
|
2012-10-16 09:27:21 +02:00
|
|
|
~AssertionResult();
|
2015-05-19 19:37:58 +02:00
|
|
|
# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
|
2014-03-20 12:48:19 +01:00
|
|
|
AssertionResult( AssertionResult const& ) = default;
|
|
|
|
AssertionResult( AssertionResult && ) = default;
|
|
|
|
AssertionResult& operator = ( AssertionResult const& ) = default;
|
|
|
|
AssertionResult& operator = ( AssertionResult && ) = default;
|
|
|
|
# endif
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2012-11-13 10:44:52 +01:00
|
|
|
bool isOk() const;
|
|
|
|
bool succeeded() const;
|
2012-08-08 09:50:38 +02:00
|
|
|
ResultWas::OfType getResultType() const;
|
|
|
|
bool hasExpression() const;
|
|
|
|
bool hasMessage() const;
|
|
|
|
std::string getExpression() const;
|
2013-05-17 20:35:33 +02:00
|
|
|
std::string getExpressionInMacro() const;
|
2012-08-08 09:50:38 +02:00
|
|
|
bool hasExpandedExpression() const;
|
|
|
|
std::string getExpandedExpression() const;
|
|
|
|
std::string getMessage() const;
|
2012-10-24 22:59:47 +02:00
|
|
|
SourceLineInfo getSourceInfo() const;
|
2012-08-08 09:50:38 +02:00
|
|
|
std::string getTestMacroName() const;
|
2017-01-09 13:23:10 +01:00
|
|
|
void discardDecomposedExpression() const;
|
|
|
|
void expandDecomposedExpression() const;
|
2012-08-08 09:50:38 +02:00
|
|
|
|
|
|
|
protected:
|
2012-10-24 22:59:47 +02:00
|
|
|
AssertionInfo m_info;
|
|
|
|
AssertionResultData m_resultData;
|
2012-08-08 09:50:38 +02:00
|
|
|
};
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2012-08-08 09:50:38 +02:00
|
|
|
} // end namespace Catch
|
|
|
|
|
2012-10-16 09:27:21 +02:00
|
|
|
#endif // TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
|