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