3rd-party
/
catch2
mirror of https://github.com/catchorg/Catch2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "First cut of Evaluate refactoring to remove int specialisations, among other things" 

This reverts commit 39753558eb.
This commit is contained in:
Phil Nash 2017-02-06 22:37:23 +00:00
parent 23600609c0
commit 2b74613c54
5 changed files with 150 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/internal/catch_assertionresult.h
View File

@ -21,25 +21,7 @@ namespace Catch {
virtual bool isBinaryExpression() const { virtual bool isBinaryExpression() const {
return false; return false;
} }
virtual std::string reconstructExpression() const = 0; virtual void reconstructExpression( std::string& dest ) 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;
}
// Only simple binary comparisons can be decomposed. // Only simple binary comparisons can be decomposed.
// If more complex check is required then wrap sub-expressions in parentheses. // If more complex check is required then wrap sub-expressions in parentheses.
@ -84,7 +66,7 @@ namespace Catch {
std::string const& reconstructExpression() const { std::string const& reconstructExpression() const {
if( decomposedExpression != CATCH_NULL ) { if( decomposedExpression != CATCH_NULL ) {
reconstructedExpression = decomposedExpression->reconstructExpression(); decomposedExpression->reconstructExpression( reconstructedExpression );
if( parenthesized ) { if( parenthesized ) {
reconstructedExpression.insert( 0, 1, '(' ); reconstructedExpression.insert( 0, 1, '(' );
reconstructedExpression.append( 1, ')' ); reconstructedExpression.append( 1, ')' );

168
include/internal/catch_evaluate.hpp
View File

@ -46,86 +46,166 @@ namespace Internal {
// So the compare overloads can be operator agnostic we convey the operator as a template // So the compare overloads can be operator agnostic we convey the operator as a template
// enum, which is used to specialise an Evaluator for doing the comparison. // enum, which is used to specialise an Evaluator for doing the comparison.
template<Operator Op> template<typename T1, typename T2, Operator Op>
class Evaluator{}; class Evaluator{};
template<> template<typename T1, typename T2>
struct Evaluator<IsEqualTo> { struct Evaluator<T1, T2, IsEqualTo> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs) {
static bool evaluate( T1& lhs, T2& rhs) { return bool( opCast( lhs ) == opCast( rhs ) );
return static_cast<bool>( lhs == rhs );
} }
}; };
template<> template<typename T1, typename T2>
struct Evaluator<IsNotEqualTo> { struct Evaluator<T1, T2, IsNotEqualTo> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs ) {
static bool evaluate( T1& lhs, T2& rhs ) { return bool( opCast( lhs ) != opCast( rhs ) );
return bool( lhs != rhs );
} }
}; };
template<> template<typename T1, typename T2>
struct Evaluator<IsLessThan> { struct Evaluator<T1, T2, IsLessThan> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs ) {
static bool evaluate( T1& lhs, T2& rhs ) { return bool( opCast( lhs ) < opCast( rhs ) );
return bool( lhs < rhs );
} }
}; };
template<> template<typename T1, typename T2>
struct Evaluator<IsGreaterThan> { struct Evaluator<T1, T2, IsGreaterThan> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs ) {
static bool evaluate( T1& lhs, T2& rhs ) { return bool( opCast( lhs ) > opCast( rhs ) );
return bool( lhs > rhs );
} }
}; };
template<> template<typename T1, typename T2>
struct Evaluator<IsGreaterThanOrEqualTo> { struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs ) {
static bool evaluate( T1& lhs, T2& rhs ) { return bool( opCast( lhs ) >= opCast( rhs ) );
return bool( lhs >= rhs );
} }
}; };
template<> template<typename T1, typename T2>
struct Evaluator<IsLessThanOrEqualTo> { struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
template<typename T1, typename T2> static bool evaluate( T1 const& lhs, T2 const& rhs ) {
static bool evaluate( T1& lhs, T2& rhs ) { return bool( opCast( lhs ) <= opCast( rhs ) );
return bool( lhs <= rhs );
} }
}; };
template<Operator Op, typename T1, typename T2>
bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
}
// This level of indirection allows us to specialise for integer types // This level of indirection allows us to specialise for integer types
// to avoid signed/ unsigned warnings // to avoid signed/ unsigned warnings
// "base" overload // "base" overload
template<Operator Op, typename T1, typename T2> template<Operator Op, typename T1, typename T2>
bool compare( T1 const& lhs, T2 const& rhs ) { bool compare( T1 const& lhs, T2 const& rhs ) {
return Evaluator<Op>::evaluate( opCast( lhs ), opCast( rhs ) ); return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
}
// unsigned X to int
template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
}
template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
}
template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
}
// unsigned X to long
template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
}
template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
}
template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
}
// int to unsigned X
template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
}
template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
}
template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
}
// long to unsigned X
template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
} }
// pointer to long (when comparing against NULL) // pointer to long (when comparing against NULL)
template<Operator Op, typename T> bool compare( long lhs, T* rhs ) { template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
return Evaluator<Op>::evaluate( opCast( reinterpret_cast<T*>( lhs ) ), opCast( rhs ) ); return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
} }
template<Operator Op, typename T> bool compare( T* lhs, long rhs ) { template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
return Evaluator<Op>::evaluate( opCast( lhs ), opCast( reinterpret_cast<T*>( rhs ) ) ); return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
} }
// pointer to int (when comparing against NULL) // pointer to int (when comparing against NULL)
template<Operator Op, typename T> bool compare( int lhs, T* rhs ) { template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
return Evaluator<Op>::evaluate( opCast( reinterpret_cast<T*>( lhs ) ), opCast( rhs ) ); return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
} }
template<Operator Op, typename T> bool compare( T* lhs, int rhs ) { template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
return Evaluator<Op>::evaluate( opCast( lhs ), opCast( reinterpret_cast<T*>( rhs ) ) ); return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
} }
// Needed? #ifdef CATCH_CONFIG_CPP11_LONG_LONG
// long long to unsigned X
template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
}
// unsigned long long to X
template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
}
template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
}
template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
}
template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
}
// pointer to long long (when comparing against NULL)
template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
}
template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
}
#endif // CATCH_CONFIG_CPP11_LONG_LONG
#ifdef CATCH_CONFIG_CPP11_NULLPTR #ifdef CATCH_CONFIG_CPP11_NULLPTR
// // pointer to nullptr_t (when comparing against nullptr) // pointer to nullptr_t (when comparing against nullptr)
// template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) { template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
// return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs ); return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
// } }
// template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) { template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
// return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr ); return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
// } }
#endif // CATCH_CONFIG_CPP11_NULLPTR #endif // CATCH_CONFIG_CPP11_NULLPTR
} // end of namespace Internal } // end of namespace Internal

31
include/internal/catch_expression_lhs.hpp
View File

@ -78,8 +78,8 @@ public:
.endExpression( *this ); .endExpression( *this );
} }
virtual std::string reconstructExpression() const CATCH_OVERRIDE { virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
return Catch::toString( m_truthy ); dest = Catch::toString( m_truthy );
} }
private: private:
@ -115,11 +115,22 @@ public:
return true; return true;
} }
virtual std::string reconstructExpression() const CATCH_OVERRIDE { virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
return reconstructExpressionImpl std::string lhs = Catch::toString( m_lhs );
(Catch::toString( m_lhs ), std::string rhs = Catch::toString( m_rhs );
Catch::toString( m_rhs ), char delim = lhs.size() + rhs.size() < 40 &&
Internal::OperatorTraits<Op>::getName() ); 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 += Internal::OperatorTraits<Op>::getName();
dest += delim;
dest += rhs;
} }
private: private:
@ -138,14 +149,14 @@ public:
return true; return true;
} }
virtual std::string reconstructExpression() const CATCH_OVERRIDE { virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
std::string matcherAsString = m_matcher.toString(); std::string matcherAsString = m_matcher.toString();
std::string dest = Catch::toString( m_arg ) + " "; dest = Catch::toString( m_arg );
dest += ' ';
if( matcherAsString == Detail::unprintableString ) if( matcherAsString == Detail::unprintableString )
dest += m_matcherString; dest += m_matcherString;
else else
dest += matcherAsString; dest += matcherAsString;
return dest;
} }
private: private:

2
include/internal/catch_result_builder.h
View File

@ -55,7 +55,7 @@ namespace Catch {
void endExpression( DecomposedExpression const& expr ); void endExpression( DecomposedExpression const& expr );
virtual std::string reconstructExpression() const CATCH_OVERRIDE; virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE;
AssertionResult build() const; AssertionResult build() const;
AssertionResult build( DecomposedExpression const& expr ) const; AssertionResult build( DecomposedExpression const& expr ) const;

4
include/internal/catch_result_builder.hpp
View File

@ -132,8 +132,8 @@ namespace Catch {
return AssertionResult( m_assertionInfo, data ); return AssertionResult( m_assertionInfo, data );
} }
std::string ResultBuilder::reconstructExpression() const { void ResultBuilder::reconstructExpression( std::string& dest ) const {
return m_assertionInfo.capturedExpression; dest = m_assertionInfo.capturedExpression;
} }
} // end namespace Catch } // end namespace Catch