Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorPhil Nash2011-04-01 08:15:08 +0100
committerPhil Nash2011-04-01 08:15:08 +0100
commit751c8bd7f7b0be3a7954b00e6ea4372b5127abbf (patch)
treed16849d3d3faf00fc1e3b8b68585c5bee015537b
parent24b352f6b80ebb1db2bac20038dbd808633395cc (diff)
downloadcatch3-751c8bd7f7b0be3a7954b00e6ea4372b5127abbf.tar.gz
Removed special case logic around comparisons between unsigned ints and negative signed ints (as it was non-standard)
-rw-r--r--internal/catch_evaluate.hpp86
1 files changed, 20 insertions, 66 deletions
diff --git a/internal/catch_evaluate.hpp b/internal/catch_evaluate.hpp
index 0bfe373f..e4f2fe5e 100644
--- a/internal/catch_evaluate.hpp
+++ b/internal/catch_evaluate.hpp
@@ -48,21 +48,6 @@ namespace Internal
template<>
struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
- // Because we capture the LHS and RHS of a binary condition expression by reference, then
- // compare the referenced values later, we may get compiler warnings when comparing unsigned
- // integer types with integer literals (which are signed - int or long, specifically).
- // To avoid this warning we filter out the problem cases as a set of overloads of the compare
- // function. In those overloads we cast the unsigned type to its signed equivalent then
- // perform the comparison. However we also have to handle the case where the signed value is
- // negative. Comparing a negative value with an unsigned value (which will always be positive)
- // has fixed logic per operator, so this is captured seperately as an enum value.
- enum LostSign
- {
- None = 0,
- LhsSignWasLost = 1,
- RhsSignWasLost = 2
- };
-
// 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.
template<typename T1, typename T2, Operator Op>
@@ -71,87 +56,56 @@ namespace Internal
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsEqualTo>
{
- enum{ failsWhen = LhsSignWasLost | RhsSignWasLost };
-
static bool evaluate( const T1& lhs, const T2& rhs)
{
- return lhs == rhs;
+ return const_cast<T1&>( lhs ) == const_cast<T2&>( rhs );
}
};
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsNotEqualTo>
{
- enum{ failsWhen = None };
-
static bool evaluate( const T1& lhs, const T2& rhs )
{
- return lhs != rhs;
+ return const_cast<T1&>( lhs ) != const_cast<T2&>( rhs );
}
};
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsLessThan>
{
- enum{ failsWhen = RhsSignWasLost };
-
static bool evaluate( const T1& lhs, const T2& rhs )
{
- return lhs < rhs;
+ return const_cast<T1&>( lhs ) < const_cast<T2&>( rhs );
}
};
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsGreaterThan>
{
- enum{ failsWhen = LhsSignWasLost };
-
static bool evaluate( const T1& lhs, const T2& rhs )
{
- return lhs > rhs;
+ return const_cast<T1&>( lhs ) > const_cast<T2&>( rhs );
}
};
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsGreaterThanOrEqualTo>
{
- enum{ failsWhen = LhsSignWasLost };
-
static bool evaluate( const T1& lhs, const T2& rhs )
{
- return lhs >= rhs;
+ return const_cast<T1&>( lhs ) >= const_cast<T2&>( rhs );
}
};
template<typename T1, typename T2>
struct Evaluator<T1, T2, IsLessThanOrEqualTo>
{
- enum{ failsWhen = RhsSignWasLost };
-
static bool evaluate( const T1& lhs, const T2& rhs )
{
- return lhs <= rhs;
+ return const_cast<T1&>( lhs ) <= const_cast<T2&>( rhs );
}
};
- // All the special case signed/ unsigned overloads of compare forward to this function,
- // which, for negative numbers checks the special case fixed logic, otherwise forwards on
- // to the specialised Evaluator for the operator enum
template<Operator Op, typename T1, typename T2>
- bool applyEvaluator( const T1& lhs, const T2& rhs, LostSign lostSign )
+ bool applyEvaluator( const T1& lhs, const T2& rhs )
{
- typedef Evaluator<T1, T2, Op> EvaluatorType;
- return lostSign == None
- ? EvaluatorType::evaluate( lhs, rhs )
- : ( EvaluatorType::failsWhen & lostSign ) != lostSign;
- }
-
-
- template<typename T>
- LostSign testLhsSign( T lhs )
- {
- return lhs < 0 ? LhsSignWasLost : None;
- }
-
- template<typename T>
- LostSign testRhsSign( T rhs )
- {
- return rhs < 0 ? RhsSignWasLost : None;
+ return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
}
// "base" overload
@@ -164,57 +118,57 @@ namespace Internal
// unsigned X to int
template<Operator Op> bool compare( unsigned int lhs, int rhs )
{
- return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ), testRhsSign( 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 ), testRhsSign( 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 ), testRhsSign( 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 ), testRhsSign( 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 ), testRhsSign( 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 ), testRhsSign( 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, testLhsSign( lhs ) );
+ 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, testLhsSign( lhs ) );
+ 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, testLhsSign( lhs ) );
+ 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, testLhsSign( lhs ) );
+ return applyEvaluator<Op>( static_cast<unsigned long>( lhs ) );
}
template<Operator Op> bool compare( long lhs, unsigned long rhs )
{
- return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs, testLhsSign( lhs ) );
+ return applyEvaluator<Op>( static_cast<unsigned long>( lhs ) );
}
template<Operator Op> bool compare( long lhs, unsigned char rhs )
{
- return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs, testLhsSign( lhs ) );
+ return applyEvaluator<Op>( static_cast<unsigned long>( lhs ) );
}
template<Operator Op, typename T>