3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-26 07:16:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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, ')' );

156
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<>
struct Evaluator<IsEqualTo> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs) { struct Evaluator<T1, T2, IsEqualTo> {
return static_cast<bool>( lhs == rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs) {
return bool( opCast( lhs ) == opCast( rhs ) );
} }
}; };
template<>
struct Evaluator<IsNotEqualTo> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs ) { struct Evaluator<T1, T2, IsNotEqualTo> {
return bool( lhs != rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return bool( opCast( lhs ) != opCast( rhs ) );
} }
}; };
template<>
struct Evaluator<IsLessThan> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs ) { struct Evaluator<T1, T2, IsLessThan> {
return bool( lhs < rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return bool( opCast( lhs ) < opCast( rhs ) );
} }
}; };
template<>
struct Evaluator<IsGreaterThan> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs ) { struct Evaluator<T1, T2, IsGreaterThan> {
return bool( lhs > rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return bool( opCast( lhs ) > opCast( rhs ) );
} }
}; };
template<>
struct Evaluator<IsGreaterThanOrEqualTo> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs ) { struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
return bool( lhs >= rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return bool( opCast( lhs ) >= opCast( rhs ) );
} }
}; };
template<>
struct Evaluator<IsLessThanOrEqualTo> {
template<typename T1, typename T2> template<typename T1, typename T2>
static bool evaluate( T1& lhs, T2& rhs ) { struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
return bool( lhs <= rhs ); static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return bool( opCast( lhs ) <= opCast( 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