@ -46,11 +46,14 @@
# include <stdlib.h>
# if GTEST_HAS_PTHREAD
# include <pthread.h>
# endif // GTEST_HAS_PTHREAD
# ifdef GTEST_OS_LINUX
# include <string.h>
# include <signal.h>
# include <sys/stat.h>
# include <pthread.h>
# include <unistd.h>
# include <string>
# include <vector>
@ -68,8 +71,8 @@ using testing::internal::ParseInt32Flag;
namespace testing {
GTEST_DECLARE_string ( output ) ;
GTEST_DECLARE_string ( color ) ;
GTEST_DECLARE_string_ ( output ) ;
GTEST_DECLARE_string_ ( color ) ;
namespace internal {
bool ShouldUseColor ( bool stdout_is_tty ) ;
@ -114,6 +117,7 @@ using testing::internal::StreamableToString;
using testing : : internal : : String ;
using testing : : internal : : TestProperty ;
using testing : : internal : : TestResult ;
using testing : : internal : : ThreadLocal ;
using testing : : internal : : UnitTestImpl ;
using testing : : internal : : WideStringToUtf8 ;
@ -142,31 +146,31 @@ TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
EXPECT_STREQ ( " -3 " , FormatTimeInMillisAsSeconds ( - 3000 ) ) ;
}
# ifndef __SYMBIAN32__
# ifndef GTEST _OS _SYMBIAN
// NULL testing does not work with Symbian compilers.
// Tests that GTEST_IS_NULL_LITERAL(x) is true when x is a null
// Tests that GTEST_IS_NULL_LITERAL_ (x) is true when x is a null
// pointer literal.
TEST ( NullLiteralTest , IsTrueForNullLiterals ) {
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( NULL ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( 0 ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( 1 - 1 ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( 0U ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( 0L ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( false ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL ( true & & false ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( NULL ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( 0 ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( 1 - 1 ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( 0U ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( 0L ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( false ) ) ;
EXPECT_TRUE ( GTEST_IS_NULL_LITERAL_ ( true & & false ) ) ;
}
// Tests that GTEST_IS_NULL_LITERAL(x) is false when x is not a null
// Tests that GTEST_IS_NULL_LITERAL_ (x) is false when x is not a null
// pointer literal.
TEST ( NullLiteralTest , IsFalseForNonNullLiterals ) {
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL ( 1 ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL ( 0.0 ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL ( ' a ' ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL ( static_cast < void * > ( NULL ) ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL_ ( 1 ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL_ ( 0.0 ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL_ ( ' a ' ) ) ;
EXPECT_FALSE ( GTEST_IS_NULL_LITERAL_ ( static_cast < void * > ( NULL ) ) ) ;
}
# endif // __SYMBIAN32__
# endif // GTEST _OS _SYMBIAN
//
// Tests CodePointToUtf8().
@ -662,127 +666,160 @@ TEST(TestPropertyTest, ReplaceStringValue) {
EXPECT_STREQ ( " 2 " , property . value ( ) ) ;
}
// Tests the TestPartResult class.
// The test fixture for testing TestPartResult.
class TestPartResultTest : public Test {
class ScopedFakeTestPartResultReporterTest : public Test {
protected :
TestPartResultTest ( )
: r1_ ( TPRT_SUCCESS , " foo/bar.cc " , 10 , " Success! " ) ,
r2_ ( TPRT_NONFATAL_FAILURE , " foo/bar.cc " , - 1 , " Failure! " ) ,
r3_ ( TPRT_FATAL_FAILURE , NULL , - 1 , " Failure! " ) { }
TestPartResult r1_ , r2_ , r3_ ;
enum FailureMode {
FATAL_FAILURE ,
NONFATAL_FAILURE
} ;
static void AddFailure ( FailureMode failure ) {
if ( failure = = FATAL_FAILURE ) {
FAIL ( ) < < " Expected fatal failure. " ;
} else {
ADD_FAILURE ( ) < < " Expected non-fatal failure. " ;
}
}
} ;
// Tests TestPartResult::type()
TEST_F ( TestPartResultTest , type ) {
EXPECT_EQ ( TPRT_SUCCESS , r1_ . type ( ) ) ;
EXPECT_EQ ( TPRT_NONFATAL_FAILURE , r2_ . type ( ) ) ;
EXPECT_EQ ( TPRT_FATAL_FAILURE , r3_ . type ( ) ) ;
}
// Tests that ScopedFakeTestPartResultReporter intercepts test
// failures.
TEST_F ( ScopedFakeTestPartResultReporterTest , InterceptsTestFailures ) {
TestPartResultArray results ;
{
ScopedFakeTestPartResultReporter reporter (
ScopedFakeTestPartResultReporter : : INTERCEPT_ONLY_CURRENT_THREAD ,
& results ) ;
AddFailure ( NONFATAL_FAILURE ) ;
AddFailure ( FATAL_FAILURE ) ;
}
// Tests TestPartResult::file_name()
TEST_F ( TestPartResultTest , file_name ) {
EXPECT_STREQ ( " foo/bar.cc " , r1_ . file_name ( ) ) ;
EXPECT_STREQ ( NULL , r3_ . file_name ( ) ) ;
EXPECT_EQ ( 2 , results . size ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 0 ) . nonfatally_failed ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 1 ) . fatally_failed ( ) ) ;
}
// Tests TestPartResult::line_number()
TEST_F ( TestPartResultTest , line_number ) {
EXPECT_EQ ( 10 , r1_ . line_number ( ) ) ;
EXPECT_EQ ( - 1 , r2_ . line_number ( ) ) ;
TEST_F ( ScopedFakeTestPartResultReporterTest , DeprecatedConstructor ) {
TestPartResultArray results ;
{
// Tests, that the deprecated constructor still works.
ScopedFakeTestPartResultReporter reporter ( & results ) ;
AddFailure ( NONFATAL_FAILURE ) ;
}
EXPECT_EQ ( 1 , results . size ( ) ) ;
}
// Tests TestPartResult::message()
TEST_F ( TestPartResultTest , message ) {
EXPECT_STREQ ( " Success! " , r1_ . message ( ) ) ;
# if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
class ScopedFakeTestPartResultReporterWithThreadsTest
: public ScopedFakeTestPartResultReporterTest {
protected :
static void AddFailureInOtherThread ( FailureMode failure ) {
pthread_t tid ;
pthread_create ( & tid ,
NULL ,
ScopedFakeTestPartResultReporterWithThreadsTest : :
FailureThread ,
& failure ) ;
pthread_join ( tid , NULL ) ;
}
private :
static void * FailureThread ( void * attr ) {
FailureMode * failure = static_cast < FailureMode * > ( attr ) ;
AddFailure ( * failure ) ;
return NULL ;
}
} ;
TEST_F ( ScopedFakeTestPartResultReporterWithThreadsTest ,
InterceptsTestFailuresInAllThreads ) {
TestPartResultArray results ;
{
ScopedFakeTestPartResultReporter reporter (
ScopedFakeTestPartResultReporter : : INTERCEPT_ALL_THREADS , & results ) ;
AddFailure ( NONFATAL_FAILURE ) ;
AddFailure ( FATAL_FAILURE ) ;
AddFailureInOtherThread ( NONFATAL_FAILURE ) ;
AddFailureInOtherThread ( FATAL_FAILURE ) ;
}
EXPECT_EQ ( 4 , results . size ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 0 ) . nonfatally_failed ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 1 ) . fatally_failed ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 2 ) . nonfatally_failed ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 3 ) . fatally_failed ( ) ) ;
}
// Tests TestPartResult::passed()
TEST_F ( TestPartResultTest , Passed ) {
EXPECT_TRUE ( r1_ . passed ( ) ) ;
EXPECT_FALSE ( r2_ . passed ( ) ) ;
EXPECT_FALSE ( r3_ . passed ( ) ) ;
# endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
// Tests EXPECT_{,NON}FATAL_FAILURE{,ON_ALL_THREADS}.
typedef ScopedFakeTestPartResultReporterTest ExpectFailureTest ;
TEST_F ( ExpectFailureTest , ExpectFatalFaliure ) {
EXPECT_FATAL_FAILURE ( AddFailure ( FATAL_FAILURE ) , " Expected fatal failure. " ) ;
}
// Tests TestPartResult::failed()
TEST_F ( TestPartResultTest , Failed ) {
EXPECT_FALSE ( r1_ . failed ( ) ) ;
EXPECT_TRUE ( r2_ . failed ( ) ) ;
EXPECT_TRUE ( r3_ . failed ( ) ) ;
TEST_F ( ExpectFailureTest , ExpectNonFatalFailure ) {
EXPECT_NONFATAL_FAILURE ( AddFailure ( NONFATAL_FAILURE ) ,
" Expected non-fatal failure. " ) ;
}
// Tests TestPartResult::fatally_failed()
TEST_F ( TestPartResultTest , FatallyFailed ) {
EXPECT_FALSE ( r1_ . fatally_failed ( ) ) ;
EXPECT_FALSE ( r2_ . fatally_failed ( ) ) ;
EXPECT_TRUE ( r3_ . fatally_failed ( ) ) ;
TEST_F ( ExpectFailureTest , ExpectFatalFailureOnAllThreads ) {
EXPECT_FATAL_FAILURE_ON_ALL_THREADS ( AddFailure ( FATAL_FAILURE ) ,
" Expected fatal failure. " ) ;
}
// Tests TestPartResult::nonfatally_failed()
TEST_F ( TestPartResultTest , NonfatallyFailed ) {
EXPECT_FALSE ( r1_ . nonfatally_failed ( ) ) ;
EXPECT_TRUE ( r2_ . nonfatally_failed ( ) ) ;
EXPECT_FALSE ( r3_ . nonfatally_failed ( ) ) ;
TEST_F ( ExpectFailureTest , ExpectNonFatalFailureOnAllThreads ) {
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS ( AddFailure ( NONFATAL_FAILURE ) ,
" Expected non-fatal failure. " ) ;
}
// Tests the TestPartResultArray class.
// Tests that the EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS} accepts
// a statement that contains a macro which expands to code containing
// an unprotected comma.
class TestPartResultArrayTest : public Test {
protected :
TestPartResultArrayTest ( )
: r1_ ( TPRT_NONFATAL_FAILURE , " foo/bar.cc " , - 1 , " Failure 1 " ) ,
r2_ ( TPRT_FATAL_FAILURE , " foo/bar.cc " , - 1 , " Failure 2 " ) { }
static int global_var = 0 ;
# define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
const TestPartResult r1_ , r2_ ;
} ;
TEST_F ( ExpectFailureTest , AcceptsMacroThatExpandsToUnprotectedComma ) {
EXPECT_FATAL_FAILURE ( {
GTEST_USE_UNPROTECTED_COMMA_ ;
AddFailure ( FATAL_FAILURE ) ;
} , " " ) ;
// Tests that TestPartResultArray initially has size 0.
TEST_F ( TestPartResultArrayTest , InitialSizeIsZero ) {
TestPartResultArray results ;
EXPECT_EQ ( 0 , results . size ( ) ) ;
}
EXPECT_FATAL_FAILURE_ON_ALL_THREADS ( {
GTEST_USE_UNPROTECTED_COMMA_ ;
AddFailure ( FATAL_FAILURE ) ;
} , " " ) ;
// Tests that TestPartResultArray contains the given TestPartResult
// after one Append() operation.
TEST_F ( TestPartResultArrayTest , ContainsGivenResultAfterAppend ) {
TestPartResultArray results ;
results . Append ( r1_ ) ;
EXPECT_EQ ( 1 , results . size ( ) ) ;
EXPECT_STREQ ( " Failure 1 " , results . GetTestPartResult ( 0 ) . message ( ) ) ;
}
EXPECT_NONFATAL_FAILURE ( {
GTEST_USE_UNPROTECTED_COMMA_ ;
AddFailure ( NONFATAL_FAILURE ) ;
} , " " ) ;
// Tests that TestPartResultArray contains the given TestPartResults
// after two Append() operations.
TEST_F ( TestPartResultArrayTest , ContainsGivenResultsAfterTwoAppends ) {
TestPartResultArray results ;
results . Append ( r1_ ) ;
results . Append ( r2_ ) ;
EXPECT_EQ ( 2 , results . size ( ) ) ;
EXPECT_STREQ ( " Failure 1 " , results . GetTestPartResult ( 0 ) . message ( ) ) ;
EXPECT_STREQ ( " Failure 2 " , results . GetTestPartResult ( 1 ) . message ( ) ) ;
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS ( {
GTEST_USE_UNPROTECTED_COMMA_ ;
AddFailure ( NONFATAL_FAILURE ) ;
} , " " ) ;
}
void ScopedFakeTestPartResultReporterTestHelper ( ) {
FAIL ( ) < < " Expected fatal failure. " ;
}
# if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
// Tests that ScopedFakeTestPartResultReporter intercepts test
// failures.
TEST ( ScopedFakeTestPartResultReporterTest , InterceptsTestFailures ) {
TestPartResultArray results ;
{
ScopedFakeTestPartResultReporter reporter ( & results ) ;
ADD_FAILURE ( ) < < " Expected non-fatal failure. " ;
ScopedFakeTestPartResultReporterTestHelper ( ) ;
}
typedef ScopedFakeTestPartResultReporterWithThreadsTest
ExpectFailureWithThreadsTest ;
EXPECT_EQ ( 2 , results . size ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 0 ) . nonfatally_failed ( ) ) ;
EXPECT_TRUE ( results . GetTestPartResult ( 1 ) . fatally_failed ( ) ) ;
TEST_F ( ExpectFailureWithThreadsTest , ExpectFatalFailureOnAllThreads ) {
EXPECT_FATAL_FAILURE_ON_ALL_THREADS ( AddFailureInOtherThread ( FATAL_FAILURE ) ,
" Expected fatal failure. " ) ;
}
TEST_F ( ExpectFailureWithThreadsTest , ExpectNonFatalFailureOnAllThreads ) {
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS (
AddFailureInOtherThread ( NONFATAL_FAILURE ) , " Expected non-fatal failure. " ) ;
}
# endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
// Tests the TestResult class
// The test fixture for testing TestResult.
@ -1875,6 +1912,8 @@ TEST_F(FloatTest, LargeDiff) {
TEST_F ( FloatTest , Infinity ) {
EXPECT_FLOAT_EQ ( infinity_ , close_to_infinity_ ) ;
EXPECT_FLOAT_EQ ( - infinity_ , - close_to_infinity_ ) ;
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
EXPECT_NONFATAL_FAILURE ( EXPECT_FLOAT_EQ ( infinity_ , - infinity_ ) ,
" -infinity_ " ) ;
@ -1882,10 +1921,13 @@ TEST_F(FloatTest, Infinity) {
// are only 1 DLP apart.
EXPECT_NONFATAL_FAILURE ( EXPECT_FLOAT_EQ ( infinity_ , nan1_ ) ,
" nan1_ " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Tests that comparing with NAN always returns false.
TEST_F ( FloatTest , NaN ) {
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
EXPECT_NONFATAL_FAILURE ( EXPECT_FLOAT_EQ ( nan1_ , nan1_ ) ,
" nan1_ " ) ;
EXPECT_NONFATAL_FAILURE ( EXPECT_FLOAT_EQ ( nan1_ , nan2_ ) ,
@ -1895,6 +1937,7 @@ TEST_F(FloatTest, NaN) {
EXPECT_FATAL_FAILURE ( ASSERT_FLOAT_EQ ( nan1_ , infinity_ ) ,
" infinity_ " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Tests that *_FLOAT_EQ are reflexive.
@ -1956,6 +1999,8 @@ TEST_F(FloatTest, FloatLEFails) {
EXPECT_PRED_FORMAT2 ( FloatLE , further_from_one_ , 1.0f ) ;
} , " (further_from_one_) <= (1.0f) " ) ;
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
// or when either val1 or val2 is NaN.
EXPECT_NONFATAL_FAILURE ( { // NOLINT
EXPECT_PRED_FORMAT2 ( FloatLE , nan1_ , infinity_ ) ;
@ -1967,6 +2012,7 @@ TEST_F(FloatTest, FloatLEFails) {
EXPECT_FATAL_FAILURE ( { // NOLINT
ASSERT_PRED_FORMAT2 ( FloatLE , nan1_ , nan1_ ) ;
} , " (nan1_) <= (nan1_) " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
@ -2021,6 +2067,8 @@ TEST_F(DoubleTest, LargeDiff) {
TEST_F ( DoubleTest , Infinity ) {
EXPECT_DOUBLE_EQ ( infinity_ , close_to_infinity_ ) ;
EXPECT_DOUBLE_EQ ( - infinity_ , - close_to_infinity_ ) ;
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
EXPECT_NONFATAL_FAILURE ( EXPECT_DOUBLE_EQ ( infinity_ , - infinity_ ) ,
" -infinity_ " ) ;
@ -2028,22 +2076,29 @@ TEST_F(DoubleTest, Infinity) {
// are only 1 DLP apart.
EXPECT_NONFATAL_FAILURE ( EXPECT_DOUBLE_EQ ( infinity_ , nan1_ ) ,
" nan1_ " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Tests that comparing with NAN always returns false.
TEST_F ( DoubleTest , NaN ) {
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
EXPECT_NONFATAL_FAILURE ( EXPECT_DOUBLE_EQ ( nan1_ , nan1_ ) ,
" nan1_ " ) ;
EXPECT_NONFATAL_FAILURE ( EXPECT_DOUBLE_EQ ( nan1_ , nan2_ ) , " nan2_ " ) ;
EXPECT_NONFATAL_FAILURE ( EXPECT_DOUBLE_EQ ( 1.0 , nan1_ ) , " nan1_ " ) ;
EXPECT_FATAL_FAILURE ( ASSERT_DOUBLE_EQ ( nan1_ , infinity_ ) , " infinity_ " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Tests that *_DOUBLE_EQ are reflexive.
TEST_F ( DoubleTest , Reflexive ) {
EXPECT_DOUBLE_EQ ( 0.0 , 0.0 ) ;
EXPECT_DOUBLE_EQ ( 1.0 , 1.0 ) ;
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
ASSERT_DOUBLE_EQ ( infinity_ , infinity_ ) ;
# endif // ! GTEST_OS_SYMBIAN
}
// Tests that *_DOUBLE_EQ are commutative.
@ -2059,38 +2114,22 @@ TEST_F(DoubleTest, Commutative) {
TEST_F ( DoubleTest , EXPECT_NEAR ) {
EXPECT_NEAR ( - 1.0 , - 1.1 , 0.2 ) ;
EXPECT_NEAR ( 2.0 , 3.0 , 1.0 ) ;
# ifdef __SYMBIAN32__
// Symbian STLport has currently a buggy floating point output.
// TODO(mikie): fix STLport.
EXPECT_NONFATAL_FAILURE ( EXPECT_NEAR ( 1.0 , 1.2 , 0.1 ) , // NOLINT
" The difference between 1.0 and 1.2 is 0.19999:, "
" which exceeds 0.1 " ) ;
# else // !__SYMBIAN32__
EXPECT_NONFATAL_FAILURE ( EXPECT_NEAR ( 1.0 , 1.2 , 0.1 ) , // NOLINT
" The difference between 1.0 and 1.2 is 0.2, "
" which exceeds 0.1 " ) ;
// To work around a bug in gcc 2.95.0, there is intentionally no
// space after the first comma in the previous statement.
# endif // __SYMBIAN32__
}
// Tests ASSERT_NEAR.
TEST_F ( DoubleTest , ASSERT_NEAR ) {
ASSERT_NEAR ( - 1.0 , - 1.1 , 0.2 ) ;
ASSERT_NEAR ( 2.0 , 3.0 , 1.0 ) ;
# ifdef __SYMBIAN32__
// Symbian STLport has currently a buggy floating point output.
// TODO(mikie): fix STLport.
EXPECT_FATAL_FAILURE ( ASSERT_NEAR ( 1.0 , 1.2 , 0.1 ) , // NOLINT
" The difference between 1.0 and 1.2 is 0.19999:, "
" which exceeds 0.1 " ) ;
# else // ! __SYMBIAN32__
EXPECT_FATAL_FAILURE ( ASSERT_NEAR ( 1.0 , 1.2 , 0.1 ) , // NOLINT
" The difference between 1.0 and 1.2 is 0.2, "
" which exceeds 0.1 " ) ;
// To work around a bug in gcc 2.95.0, there is intentionally no
// space after the first comma in the previous statement.
# endif // __SYMBIAN32__
}
// Tests the cases where DoubleLE() should succeed.
@ -2113,6 +2152,8 @@ TEST_F(DoubleTest, DoubleLEFails) {
EXPECT_PRED_FORMAT2 ( DoubleLE , further_from_one_ , 1.0 ) ;
} , " (further_from_one_) <= (1.0) " ) ;
# ifndef GTEST_OS_SYMBIAN
// Nokia's STLport crashes if we try to output infinity or NaN.
// or when either val1 or val2 is NaN.
EXPECT_NONFATAL_FAILURE ( { // NOLINT
EXPECT_PRED_FORMAT2 ( DoubleLE , nan1_ , infinity_ ) ;
@ -2123,6 +2164,7 @@ TEST_F(DoubleTest, DoubleLEFails) {
EXPECT_FATAL_FAILURE ( { // NOLINT
ASSERT_PRED_FORMAT2 ( DoubleLE , nan1_ , nan1_ ) ;
} , " (nan1_) <= (nan1_) " ) ;
# endif // ! GTEST_OS_SYMBIAN
}
@ -2389,6 +2431,97 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
# endif // GTEST_HAS_EXCEPTIONS
// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
class NoFatalFailureTest : public Test {
protected :
void Succeeds ( ) { }
void FailsNonFatal ( ) {
ADD_FAILURE ( ) < < " some non-fatal failure " ;
}
void Fails ( ) {
FAIL ( ) < < " some fatal failure " ;
}
void DoAssertNoFatalFailureOnFails ( ) {
ASSERT_NO_FATAL_FAILURE ( Fails ( ) ) ;
ADD_FAILURE ( ) < < " shold not reach here. " ;
}
void DoExpectNoFatalFailureOnFails ( ) {
EXPECT_NO_FATAL_FAILURE ( Fails ( ) ) ;
ADD_FAILURE ( ) < < " other failure " ;
}
} ;
TEST_F ( NoFatalFailureTest , NoFailure ) {
EXPECT_NO_FATAL_FAILURE ( Succeeds ( ) ) ;
ASSERT_NO_FATAL_FAILURE ( Succeeds ( ) ) ;
}
TEST_F ( NoFatalFailureTest , NonFatalIsNoFailure ) {
EXPECT_NONFATAL_FAILURE (
EXPECT_NO_FATAL_FAILURE ( FailsNonFatal ( ) ) ,
" some non-fatal failure " ) ;
EXPECT_NONFATAL_FAILURE (
ASSERT_NO_FATAL_FAILURE ( FailsNonFatal ( ) ) ,
" some non-fatal failure " ) ;
}
TEST_F ( NoFatalFailureTest , AssertNoFatalFailureOnFatalFailure ) {
TestPartResultArray gtest_failures ;
{
ScopedFakeTestPartResultReporter gtest_reporter ( & gtest_failures ) ;
DoAssertNoFatalFailureOnFails ( ) ;
}
ASSERT_EQ ( 2 , gtest_failures . size ( ) ) ;
EXPECT_EQ ( testing : : TPRT_FATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 0 ) . type ( ) ) ;
EXPECT_EQ ( testing : : TPRT_FATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 1 ) . type ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " some fatal failure " ,
gtest_failures . GetTestPartResult ( 0 ) . message ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " it does " ,
gtest_failures . GetTestPartResult ( 1 ) . message ( ) ) ;
}
TEST_F ( NoFatalFailureTest , ExpectNoFatalFailureOnFatalFailure ) {
TestPartResultArray gtest_failures ;
{
ScopedFakeTestPartResultReporter gtest_reporter ( & gtest_failures ) ;
DoExpectNoFatalFailureOnFails ( ) ;
}
ASSERT_EQ ( 3 , gtest_failures . size ( ) ) ;
EXPECT_EQ ( testing : : TPRT_FATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 0 ) . type ( ) ) ;
EXPECT_EQ ( testing : : TPRT_NONFATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 1 ) . type ( ) ) ;
EXPECT_EQ ( testing : : TPRT_NONFATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 2 ) . type ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " some fatal failure " ,
gtest_failures . GetTestPartResult ( 0 ) . message ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " it does " ,
gtest_failures . GetTestPartResult ( 1 ) . message ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " other failure " ,
gtest_failures . GetTestPartResult ( 2 ) . message ( ) ) ;
}
TEST_F ( NoFatalFailureTest , MessageIsStreamable ) {
TestPartResultArray gtest_failures ;
{
ScopedFakeTestPartResultReporter gtest_reporter ( & gtest_failures ) ;
EXPECT_NO_FATAL_FAILURE ( FAIL ( ) < < " foo " ) < < " my message " ;
}
ASSERT_EQ ( 2 , gtest_failures . size ( ) ) ;
EXPECT_EQ ( testing : : TPRT_NONFATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 0 ) . type ( ) ) ;
EXPECT_EQ ( testing : : TPRT_NONFATAL_FAILURE ,
gtest_failures . GetTestPartResult ( 1 ) . type ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " foo " ,
gtest_failures . GetTestPartResult ( 0 ) . message ( ) ) ;
EXPECT_PRED_FORMAT2 ( testing : : IsSubstring , " my message " ,
gtest_failures . GetTestPartResult ( 1 ) . message ( ) ) ;
}
// Tests non-string assertions.
// Tests EqFailure(), used for implementing *EQ* assertions.
@ -2492,7 +2625,7 @@ TEST(AssertionTest, ASSERT_EQ) {
}
// Tests ASSERT_EQ(NULL, pointer).
# ifndef __SYMBIAN32__
# ifndef GTEST _OS _SYMBIAN
// The NULL-detection template magic fails to compile with
// the Nokia compiler and crashes the ARM compiler, hence
// not testing on Symbian.
@ -2506,7 +2639,7 @@ TEST(AssertionTest, ASSERT_EQ_NULL) {
EXPECT_FATAL_FAILURE ( ASSERT_EQ ( NULL , & n ) ,
" Value of: &n \n " ) ;
}
# endif // __SYMBIAN32__
# endif // GTEST _OS _SYMBIAN
// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be
// treated as a null pointer by the compiler, we need to make sure
@ -2807,7 +2940,7 @@ TEST(HRESULTAssertionTest, Streaming) {
# endif // defined(GTEST_OS_WINDOWS)
// Tests that the assertion macros behave like single statements.
TEST ( AssertionSyntaxTest , BehavesLikeSingleStatement ) {
TEST ( AssertionSyntaxTest , BasicAssertionsB ehavesLikeSingleStatement ) {
if ( false )
ASSERT_TRUE ( false ) < < " This should never be executed; "
" It's a compilation test only. " ;
@ -2824,8 +2957,10 @@ TEST(AssertionSyntaxTest, BehavesLikeSingleStatement) {
;
else
EXPECT_GT ( 3 , 2 ) < < " " ;
}
# if GTEST_HAS_EXCEPTIONS
TEST ( AssertionSyntaxTest , ExceptionAssertionsBehavesLikeSingleStatement ) {
if ( false )
EXPECT_THROW ( 1 , bool ) ;
@ -2849,7 +2984,30 @@ TEST(AssertionSyntaxTest, BehavesLikeSingleStatement) {
EXPECT_ANY_THROW ( ThrowAnInteger ( ) ) ;
else
;
}
# endif // GTEST_HAS_EXCEPTIONS
TEST ( AssertionSyntaxTest , NoFatalFailureAssertionsBehavesLikeSingleStatement ) {
if ( false )
EXPECT_NO_FATAL_FAILURE ( FAIL ( ) ) < < " This should never be executed. "
< < " It's a compilation test only. " ;
else
;
if ( false )
ASSERT_NO_FATAL_FAILURE ( FAIL ( ) ) < < " " ;
else
;
if ( true )
EXPECT_NO_FATAL_FAILURE ( SUCCEED ( ) ) ;
else
;
if ( false )
;
else
ASSERT_NO_FATAL_FAILURE ( SUCCEED ( ) ) ;
}
// Tests that the assertion macros work well with switch statements.
@ -2984,7 +3142,7 @@ TEST(ExpectTest, EXPECT_EQ_Double) {
" 5.1 " ) ;
}
# ifndef __SYMBIAN32__
# ifndef GTEST _OS _SYMBIAN
// Tests EXPECT_EQ(NULL, pointer).
TEST ( ExpectTest , EXPECT_EQ_NULL ) {
// A success.
@ -2996,7 +3154,7 @@ TEST(ExpectTest, EXPECT_EQ_NULL) {
EXPECT_NONFATAL_FAILURE ( EXPECT_EQ ( NULL , & n ) ,
" Value of: &n \n " ) ;
}
# endif // __SYMBIAN32__
# endif // GTEST _OS _SYMBIAN
// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be
// treated as a null pointer by the compiler, we need to make sure
@ -4739,7 +4897,24 @@ TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
# endif // GTEST_OS_WINDOWS
}
# ifndef __SYMBIAN32__
TEST ( ThreadLocalTest , DefaultConstructor ) {
ThreadLocal < int > t1 ;
EXPECT_EQ ( 0 , t1 . get ( ) ) ;
ThreadLocal < void * > t2 ;
EXPECT_TRUE ( t2 . get ( ) = = NULL ) ;
}
TEST ( ThreadLocalTest , Init ) {
ThreadLocal < int > t1 ( 123 ) ;
EXPECT_EQ ( 123 , t1 . get ( ) ) ;
int i = 0 ;
ThreadLocal < int * > t2 ( & i ) ;
EXPECT_EQ ( & i , t2 . get ( ) ) ;
}
# ifndef GTEST_OS_SYMBIAN
// We will want to integrate running the unittests to a different
// main application on Symbian.
int main ( int argc , char * * argv ) {
@ -4756,4 +4931,4 @@ int main(int argc, char** argv) {
// Runs all tests using Google Test.
return RUN_ALL_TESTS ( ) ;
}
# endif // __SYMBIAN32_
# endif // GTEST _OS _SYMBIAN
shiqian
16 years ago