catch2/include/internal/catch_evaluate.hpp

181 lines
7.0 KiB
C++
Raw Normal View History

/*
* Created by Phil on 04/03/2011.
* Copyright 2011 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)
*/
2011-03-09 10:38:33 +01:00
#ifndef TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
2013-03-25 09:46:48 +01:00
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#endif
#include <cstddef>
2012-05-15 08:42:26 +02:00
namespace Catch {
namespace Internal {
enum Operator {
2011-03-09 10:33:33 +01:00
IsEqualTo,
IsNotEqualTo,
IsLessThan,
IsGreaterThan,
IsLessThanOrEqualTo,
IsGreaterThanOrEqualTo
};
template<Operator Op> struct OperatorTraits { static const char* getName(){ return "*error*"; } };
template<> struct OperatorTraits<IsEqualTo> { static const char* getName(){ return "=="; } };
template<> struct OperatorTraits<IsNotEqualTo> { static const char* getName(){ return "!="; } };
template<> struct OperatorTraits<IsLessThan> { static const char* getName(){ return "<"; } };
template<> struct OperatorTraits<IsGreaterThan> { static const char* getName(){ return ">"; } };
template<> struct OperatorTraits<IsLessThanOrEqualTo> { static const char* getName(){ return "<="; } };
template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
template<typename T>
inline T& opCast(T const& t) { return const_cast<T&>(t); }
// nullptr_t support based on pull request #154 from Konstantin Baumann
#ifdef CATCH_CONFIG_CPP11_NULLPTR
inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
#endif // CATCH_CONFIG_CPP11_NULLPTR
2013-03-25 09:46:48 +01:00
// 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.
2011-03-09 10:33:33 +01:00
template<typename T1, typename T2, Operator Op>
class Evaluator{};
2011-03-09 10:33:33 +01:00
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsEqualTo> {
static bool evaluate( T1 const& lhs, T2 const& rhs) {
return opCast( lhs ) == opCast( rhs );
2011-03-09 10:33:33 +01:00
}
};
2011-03-09 10:33:33 +01:00
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsNotEqualTo> {
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) != opCast( rhs );
2011-03-09 10:33:33 +01:00
}
};
2011-03-09 10:33:33 +01:00
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsLessThan> {
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) < opCast( rhs );
}
2011-03-09 10:33:33 +01:00
};
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsGreaterThan> {
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) > opCast( rhs );
}
};
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) >= opCast( rhs );
}
2011-03-09 10:33:33 +01:00
};
template<typename T1, typename T2>
2012-05-15 08:42:26 +02:00
struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) <= opCast( rhs );
}
};
2012-11-06 20:13:25 +01:00
template<Operator Op, typename T1, typename T2>
bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
}
2012-11-06 20:13:25 +01:00
// This level of indirection allows us to specialise for integer types
// to avoid signed/ unsigned warnings
// "base" overload
2011-03-09 10:33:33 +01:00
template<Operator Op, typename T1, typename T2>
bool compare( T1 const& lhs, T2 const& rhs ) {
2011-03-09 10:33:33 +01:00
return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
}
2012-11-06 20:13:25 +01:00
2011-03-09 10:33:33 +01:00
// unsigned X to int
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2011-03-09 10:33:33 +01:00
// unsigned X to long
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
2011-03-09 10:33:33 +01:00
}
2011-03-09 10:33:33 +01:00
// int to unsigned X
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2011-03-09 10:33:33 +01:00
// long to unsigned X
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2012-05-15 08:42:26 +02:00
template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
2011-03-09 10:33:33 +01:00
}
2011-03-18 20:08:33 +01:00
// pointer to long (when comparing against NULL)
2012-11-06 20:13:25 +01:00
template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
2011-03-18 20:08:33 +01:00
return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
}
2012-11-06 20:13:25 +01:00
template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
2012-05-15 08:42:26 +02:00
}
// pointer to int (when comparing against NULL)
2012-11-06 20:13:25 +01:00
template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
}
2012-11-06 20:13:25 +01:00
template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
}
#ifdef CATCH_CONFIG_CPP11_NULLPTR
// pointer to nullptr_t (when comparing against nullptr)
template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
return Evaluator<T*, T*, Op>::evaluate( CATCH_NULL, rhs );
}
template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
return Evaluator<T*, T*, Op>::evaluate( lhs, CATCH_NULL );
}
#endif // CATCH_CONFIG_CPP11_NULLPTR
} // end of namespace Internal
} // end of namespace Catch
2013-03-25 09:46:48 +01:00
#ifdef _MSC_VER
#pragma warning(pop)
#endif
2011-03-09 10:38:33 +01:00
#endif // TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED