diff options
| author | Phil Nash | 2011-04-01 08:15:08 +0100 |
|---|---|---|
| committer | Phil Nash | 2011-04-01 08:15:08 +0100 |
| commit | 751c8bd7f7b0be3a7954b00e6ea4372b5127abbf (patch) | |
| tree | d16849d3d3faf00fc1e3b8b68585c5bee015537b | |
| parent | 24b352f6b80ebb1db2bac20038dbd808633395cc (diff) | |
| download | catch3-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.hpp | 86 |
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> |