@ -1372,39 +1372,38 @@ namespace internal {
// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
// when calling EXPECT_* in a tight loop.
template < typename T1 , typename T2 >
AssertionResult CmpHelperEQFailure ( const char * expected _expression,
const char * actual _expression,
const T1 & expected , const T2 & actual ) {
return EqFailure ( expected _expression,
actual _expression,
FormatForComparisonFailureMessage ( expected , actual ) ,
FormatForComparisonFailureMessage ( actual , expected ) ,
AssertionResult CmpHelperEQFailure ( const char * lhs _expression,
const char * rhs _expression,
const T1 & lhs , const T2 & rhs ) {
return EqFailure ( lhs _expression,
rhs _expression,
FormatForComparisonFailureMessage ( lhs , rhs ) ,
FormatForComparisonFailureMessage ( rhs , lhs ) ,
false ) ;
}
// The helper function for {ASSERT|EXPECT}_EQ.
template < typename T1 , typename T2 >
AssertionResult CmpHelperEQ ( const char * expected _expression,
const char * actual _expression,
const T1 & expected ,
const T2 & actual ) {
AssertionResult CmpHelperEQ ( const char * lhs _expression,
const char * rhs _expression,
const T1 & lhs ,
const T2 & rhs ) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_ ( 4389 /* signed/unsigned mismatch */ )
if ( expected = = actual ) {
if ( lhs = = rhs ) {
return AssertionSuccess ( ) ;
}
GTEST_DISABLE_MSC_WARNINGS_POP_ ( )
return CmpHelperEQFailure ( expected_expression , actual_expression , expected ,
actual ) ;
return CmpHelperEQFailure ( lhs_expression , rhs_expression , lhs , rhs ) ;
}
// With this overloaded version, we allow anonymous enums to be used
// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
// can be implicitly cast to BiggestInt.
GTEST_API_ AssertionResult CmpHelperEQ ( const char * expected _expression,
const char * actual _expression,
BiggestInt expected ,
BiggestInt actual ) ;
GTEST_API_ AssertionResult CmpHelperEQ ( const char * lhs _expression,
const char * rhs _expression,
BiggestInt lhs ,
BiggestInt rhs ) ;
// The helper class for {ASSERT|EXPECT}_EQ. The template argument
// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
@ -1415,12 +1414,11 @@ class EqHelper {
public :
// This templatized version is for the general case.
template < typename T1 , typename T2 >
static AssertionResult Compare ( const char * expected_expression ,
const char * actual_expression ,
const T1 & expected ,
const T2 & actual ) {
return CmpHelperEQ ( expected_expression , actual_expression , expected ,
actual ) ;
static AssertionResult Compare ( const char * lhs_expression ,
const char * rhs_expression ,
const T1 & lhs ,
const T2 & rhs ) {
return CmpHelperEQ ( lhs_expression , rhs_expression , lhs , rhs ) ;
}
// With this overloaded version, we allow anonymous enums to be used
@ -1429,12 +1427,11 @@ class EqHelper {
//
// Even though its body looks the same as the above version, we
// cannot merge the two, as it will make anonymous enums unhappy.
static AssertionResult Compare ( const char * expected_expression ,
const char * actual_expression ,
BiggestInt expected ,
BiggestInt actual ) {
return CmpHelperEQ ( expected_expression , actual_expression , expected ,
actual ) ;
static AssertionResult Compare ( const char * lhs_expression ,
const char * rhs_expression ,
BiggestInt lhs ,
BiggestInt rhs ) {
return CmpHelperEQ ( lhs_expression , rhs_expression , lhs , rhs ) ;
}
} ;
@ -1449,37 +1446,36 @@ class EqHelper<true> {
// EXPECT_EQ(false, a_bool).
template < typename T1 , typename T2 >
static AssertionResult Compare (
const char * expected _expression,
const char * actual _expression,
const T1 & expected ,
const T2 & actual ,
const char * lhs _expression,
const char * rhs _expression,
const T1 & lhs ,
const T2 & rhs ,
// The following line prevents this overload from being considered if T2
// is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr)
// expands to Compare("", "", NULL, my_ptr), which requires a conversion
// to match the Secret* in the other overload, which would otherwise make
// this template match better.
typename EnableIf < ! is_pointer < T2 > : : value > : : type * = 0 ) {
return CmpHelperEQ ( expected_expression , actual_expression , expected ,
actual ) ;
return CmpHelperEQ ( lhs_expression , rhs_expression , lhs , rhs ) ;
}
// This version will be picked when the second argument to ASSERT_EQ() is a
// pointer, e.g. ASSERT_EQ(NULL, a_pointer).
template < typename T >
static AssertionResult Compare (
const char * expected _expression,
const char * actual _expression,
const char * lhs _expression,
const char * rhs _expression,
// We used to have a second template parameter instead of Secret*. That
// template parameter would deduce to 'long', making this a better match
// than the first overload even without the first overload's EnableIf.
// Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
// non-pointer argument" (even a deduced integral argument), so the old
// implementation caused warnings in user code.
Secret * /* expected (NULL) */ ,
T * actual ) {
// We already know that 'expected ' is a null pointer.
return CmpHelperEQ ( expected_expression , actual _expression,
static_cast < T * > ( NULL ) , actual ) ;
Secret * /* lhs (NULL) */ ,
T * rhs ) {
// We already know that 'lhs ' is a null pointer.
return CmpHelperEQ ( lhs_expression , rhs _expression,
static_cast < T * > ( NULL ) , rhs ) ;
}
} ;
@ -1538,18 +1534,18 @@ GTEST_IMPL_CMP_HELPER_(GT, >);
// The helper function for {ASSERT|EXPECT}_STREQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ ( const char * expected _expression,
const char * actual _expression,
const char * expected ,
const char * actual ) ;
GTEST_API_ AssertionResult CmpHelperSTREQ ( const char * s1 _expression,
const char * s2 _expression,
const char * s1 ,
const char * s2 ) ;
// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ ( const char * expected _expression,
const char * actual _expression,
const char * expected ,
const char * actual ) ;
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ ( const char * s1 _expression,
const char * s2 _expression,
const char * s1 ,
const char * s2 ) ;
// The helper function for {ASSERT|EXPECT}_STRNE.
//
@ -1571,10 +1567,10 @@ GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
// Helper function for *_STREQ on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ ( const char * expected _expression,
const char * actual _expression,
const wchar_t * expected ,
const wchar_t * actual ) ;
GTEST_API_ AssertionResult CmpHelperSTREQ ( const char * s1 _expression,
const char * s2 _expression,
const wchar_t * s1 ,
const wchar_t * s2 ) ;
// Helper function for *_STRNE on wide strings.
//
@ -1632,28 +1628,28 @@ namespace internal {
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template < typename RawType >
AssertionResult CmpHelperFloatingPointEQ ( const char * expected _expression,
const char * actual _expression,
RawType expected ,
RawType actual ) {
const FloatingPoint < RawType > lhs ( expected ) , rhs ( actual ) ;
AssertionResult CmpHelperFloatingPointEQ ( const char * lhs _expression,
const char * rhs _expression,
RawType lhs_valu e,
RawType rhs_value ) {
const FloatingPoint < RawType > lhs ( lhs_valu e) , rhs ( rhs_value ) ;
if ( lhs . AlmostEquals ( rhs ) ) {
return AssertionSuccess ( ) ;
}
: : std : : stringstream expected _ss;
expected _ss< < std : : setprecision ( std : : numeric_limits < RawType > : : digits10 + 2 )
< < expected ;
: : std : : stringstream lhs _ss;
lhs _ss< < std : : setprecision ( std : : numeric_limits < RawType > : : digits10 + 2 )
< < lhs_valu e;
: : std : : stringstream actual _ss;
actual _ss< < std : : setprecision ( std : : numeric_limits < RawType > : : digits10 + 2 )
< < actual ;
: : std : : stringstream rhs _ss;
rhs _ss< < std : : setprecision ( std : : numeric_limits < RawType > : : digits10 + 2 )
< < rhs_value ;
return EqFailure ( expected _expression,
actual _expression,
StringStreamToString ( & expected _ss) ,
StringStreamToString ( & actual _ss) ,
return EqFailure ( lhs _expression,
rhs _expression,
StringStreamToString ( & lhs _ss) ,
StringStreamToString ( & rhs _ss) ,
false ) ;
}
@ -1879,7 +1875,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
// Macros for testing equalities and inequalities.
//
// * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
// * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
@ -1906,8 +1902,8 @@ class TestWithParam : public Test, public WithParamInterface<T> {
// are related, not how their content is related. To compare two C
// strings by content, use {ASSERT|EXPECT}_STR*().
//
// 3. {ASSERT|EXPECT}_EQ(expected, actual ) is preferred to
// {ASSERT|EXPECT}_TRUE(expected == actual ), as the former tells you
// 3. {ASSERT|EXPECT}_EQ(v1, v2 ) is preferred to
// {ASSERT|EXPECT}_TRUE(v1 == v2 ), as the former tells you
// what the actual value is when it fails, and similarly for the
// other comparisons.
//
@ -1923,12 +1919,12 @@ class TestWithParam : public Test, public WithParamInterface<T> {
// ASSERT_LT(i, array_size);
// ASSERT_GT(records.size(), 0) << "There is no record left.";
# define EXPECT_EQ(expected, actual ) \
# define EXPECT_EQ(val1, val2 ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : \
EqHelper < GTEST_IS_NULL_LITERAL_ ( expected ) > : : Compare , \
expected , actual )
# define EXPECT_NE(expected, actual ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperNE , expected , actual )
EqHelper < GTEST_IS_NULL_LITERAL_ ( val1 ) > : : Compare , \
val1 , val2 )
# define EXPECT_NE(val1, val2 ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperNE , val1 , val2 )
# define EXPECT_LE(val1, val2) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperLE , val1 , val2 )
# define EXPECT_LT(val1, val2) \
@ -1938,10 +1934,10 @@ class TestWithParam : public Test, public WithParamInterface<T> {
# define EXPECT_GT(val1, val2) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperGT , val1 , val2 )
# define GTEST_ASSERT_EQ(expected, actual ) \
# define GTEST_ASSERT_EQ(val1, val2 ) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : \
EqHelper < GTEST_IS_NULL_LITERAL_ ( expected ) > : : Compare , \
expected , actual )
EqHelper < GTEST_IS_NULL_LITERAL_ ( val1 ) > : : Compare , \
val1 , val2 )
# define GTEST_ASSERT_NE(val1, val2) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperNE , val1 , val2 )
# define GTEST_ASSERT_LE(val1, val2) \
@ -1996,29 +1992,29 @@ class TestWithParam : public Test, public WithParamInterface<T> {
//
// These macros evaluate their arguments exactly once.
# define EXPECT_STREQ(expected, actual ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTREQ , expected , actual )
# define EXPECT_STREQ(s1, s2 ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTREQ , s1 , s2 )
# define EXPECT_STRNE(s1, s2) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRNE , s1 , s2 )
# define EXPECT_STRCASEEQ(expected, actual ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASEEQ , expected , actual )
# define EXPECT_STRCASEEQ(s1, s2 ) \
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASEEQ , s1 , s2 )
# define EXPECT_STRCASENE(s1, s2)\
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASENE , s1 , s2 )
# define ASSERT_STREQ(expected, actual ) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTREQ , expected , actual )
# define ASSERT_STREQ(s1, s2 ) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTREQ , s1 , s2 )
# define ASSERT_STRNE(s1, s2) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRNE , s1 , s2 )
# define ASSERT_STRCASEEQ(expected, actual ) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASEEQ , expected , actual )
# define ASSERT_STRCASEEQ(s1, s2 ) \
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASEEQ , s1 , s2 )
# define ASSERT_STRCASENE(s1, s2)\
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperSTRCASENE , s1 , s2 )
// Macros for comparing floating-point numbers.
//
// * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual ):
// * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2 ):
// Tests that two float values are almost equal.
// * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual ):
// * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2 ):
// Tests that two double values are almost equal.
// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
// Tests that v1 and v2 are within the given distance to each other.
@ -2028,21 +2024,21 @@ class TestWithParam : public Test, public WithParamInterface<T> {
// FloatingPoint template class in gtest-internal.h if you are
// interested in the implementation details.
# define EXPECT_FLOAT_EQ(expected, actual )\
# define EXPECT_FLOAT_EQ(val1, val2 )\
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperFloatingPointEQ < float > , \
expected , actual )
val1 , val2 )
# define EXPECT_DOUBLE_EQ(expected, actual )\
# define EXPECT_DOUBLE_EQ(val1, val2 )\
EXPECT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperFloatingPointEQ < double > , \
expected , actual )
val1 , val2 )
# define ASSERT_FLOAT_EQ(expected, actual )\
# define ASSERT_FLOAT_EQ(val1, val2 )\
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperFloatingPointEQ < float > , \
expected , actual )
val1 , val2 )
# define ASSERT_DOUBLE_EQ(expected, actual )\
# define ASSERT_DOUBLE_EQ(val1, val2 )\
ASSERT_PRED_FORMAT2 ( : : testing : : internal : : CmpHelperFloatingPointEQ < double > , \
expected , actual )
val1 , val2 )
# define EXPECT_NEAR(val1, val2, abs_error)\
EXPECT_PRED_FORMAT3 ( : : testing : : internal : : DoubleNearPredFormat , \
Alexey Sokolov
9 years ago