gtest_unittest.cc File Reference

#include "gtest/gtest.h"
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <map>
#include <vector>
#include <ostream>
#include "gtest/gtest-spi.h"
#include "src/gtest-internal-inl.h"

Go to the source code of this file.

Classes
class	testing::internal::TestEventListenersAccessor
class	testing::internal::UnitTestRecordPropertyTestHelper
class	TestingVector
struct	ConvertibleToAssertionResult
class	Base
class	namespace1::MyTypeInNameSpace1
class	namespace2::MyTypeInNameSpace2
class	testing::TestInfoTest
class	testing::CodeLocationForTESTF
class	testing::CodeLocationForTESTP
class	testing::CodeLocationForTYPEDTEST< T >
class	testing::CodeLocationForTYPEDTESTP< T >
class	testing::SetUpTestCaseTest
struct	testing::Flags
class	testing::InitGoogleTestTest
class	testing::CurrentTestInfoTest
class	my_namespace::testing::Test
class	my_namespace::testing::Message
class	my_namespace::testing::AssertionResult
class	ProtectedFixtureMethodsTest
class	StaticAssertTypeEqTestHelper< T >
class	TestListener
class	SequenceTestingListener
class	ConversionHelperBase
class	ConversionHelperDerived
class	NonContainer

Namespaces
	testing
	testing::internal
	namespace1
	namespace2
	my_namespace
	my_namespace::testing

Macros
#define	GTEST_IMPLEMENTATION_   1
#define	GTEST_USE_UNPROTECTED_COMMA_   global_var++, global_var++
#define	VERIFY_CODE_LOCATION
#define	GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help)

Typedefs
typedef int	IntAlias

Enumerations
enum	NamedEnum
enum

Functions
	TEST (CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded)
::std::ostream &	operator<< (::std::ostream &os, const TestingVector &vector)
	testing::TEST (SuccessfulAssertionTest, SUCCEED)
	testing::TEST (SuccessfulAssertionTest, EXPECT)
	testing::TEST (SuccessfulAssertionTest, EXPECT_STR)
	testing::TEST (SuccessfulAssertionTest, ASSERT)
	testing::TEST (SuccessfulAssertionTest, ASSERT_STR)
	TEST (AssertionResultTest, CopyConstructorWorksWhenNotOptimied)
	TEST (AssertionResultTest, ConstructionWorks)
	TEST (AssertionResultTest, NegationWorks)
	TEST (AssertionResultTest, StreamingWorks)
	TEST (AssertionResultTest, CanStreamOstreamManipulators)
	TEST (AssertionResultTest, ConstructibleFromImplicitlyConvertible)
std::ostream &	operator<< (std::ostream &os, const Base &val)
std::ostream &	operator<< (std::ostream &os, const Base *pointer)
	TEST (MessageTest, CanStreamUserTypeInGlobalNameSpace)
	TEST (MessageTest, CanStreamUserTypeInUnnamedNameSpace)
std::ostream &	namespace1::operator<< (std::ostream &os, const MyTypeInNameSpace1 &val)
std::ostream &	namespace1::operator<< (std::ostream &os, const MyTypeInNameSpace1 *pointer)
	TEST (MessageTest, CanStreamUserTypeInUserNameSpace)
std::ostream &	operator<< (std::ostream &os, const namespace2::MyTypeInNameSpace2 &val)
std::ostream &	operator<< (std::ostream &os, const namespace2::MyTypeInNameSpace2 *pointer)
	TEST (MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal)
	TEST (MessageTest, NullPointers)
	TEST (MessageTest, WideStrings)
	testing::TEST_F (TestInfoTest, Names)
	testing::TEST_F (TestInfoTest, result)
	testing::TEST (CodeLocationForTEST, Verify)
	testing::TEST_F (CodeLocationForTESTF, Verify)
	testing::TEST_P (CodeLocationForTESTP, Verify)
	testing::INSTANTIATE_TEST_CASE_P (, CodeLocationForTESTP, Values(0))
	testing::TYPED_TEST_CASE (CodeLocationForTYPEDTEST, int)
	testing::TYPED_TEST (CodeLocationForTYPEDTEST, Verify)
	testing::TYPED_TEST_CASE_P (CodeLocationForTYPEDTESTP)
	testing::TYPED_TEST_P (CodeLocationForTYPEDTESTP, Verify)
	testing::REGISTER_TYPED_TEST_CASE_P (CodeLocationForTYPEDTESTP, Verify)
	testing::INSTANTIATE_TYPED_TEST_CASE_P (My, CodeLocationForTYPEDTESTP, int)
	testing::TEST_F (SetUpTestCaseTest, Test1)
	testing::TEST_F (SetUpTestCaseTest, Test2)
	testing::TEST_F (InitGoogleTestTest, Empty)
	testing::TEST_F (InitGoogleTestTest, NoFlag)
	testing::TEST_F (InitGoogleTestTest, FilterBad)
	testing::TEST_F (InitGoogleTestTest, FilterEmpty)
	testing::TEST_F (InitGoogleTestTest, FilterNonEmpty)
	testing::TEST_F (InitGoogleTestTest, BreakOnFailureWithoutValue)
	testing::TEST_F (InitGoogleTestTest, BreakOnFailureFalse_0)
	testing::TEST_F (InitGoogleTestTest, BreakOnFailureFalse_f)
	testing::TEST_F (InitGoogleTestTest, BreakOnFailureFalse_F)
	testing::TEST_F (InitGoogleTestTest, BreakOnFailureTrue)
	testing::TEST_F (InitGoogleTestTest, CatchExceptions)
	testing::TEST_F (InitGoogleTestTest, DeathTestUseFork)
	testing::TEST_F (InitGoogleTestTest, DuplicatedFlags)
	testing::TEST_F (InitGoogleTestTest, UnrecognizedFlag)
	testing::TEST_F (InitGoogleTestTest, ListTestsFlag)
	testing::TEST_F (InitGoogleTestTest, ListTestsTrue)
	testing::TEST_F (InitGoogleTestTest, ListTestsFalse)
	testing::TEST_F (InitGoogleTestTest, ListTestsFalse_f)
	testing::TEST_F (InitGoogleTestTest, ListTestsFalse_F)
	testing::TEST_F (InitGoogleTestTest, OutputEmpty)
	testing::TEST_F (InitGoogleTestTest, OutputXml)
	testing::TEST_F (InitGoogleTestTest, OutputXmlFile)
	testing::TEST_F (InitGoogleTestTest, OutputXmlDirectory)
	testing::TEST_F (InitGoogleTestTest, PrintTimeFlag)
	testing::TEST_F (InitGoogleTestTest, PrintTimeTrue)
	testing::TEST_F (InitGoogleTestTest, PrintTimeFalse)
	testing::TEST_F (InitGoogleTestTest, PrintTimeFalse_f)
	testing::TEST_F (InitGoogleTestTest, PrintTimeFalse_F)
	testing::TEST_F (InitGoogleTestTest, RandomSeed)
	testing::TEST_F (InitGoogleTestTest, Repeat)
	testing::TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsFlag)
	testing::TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsTrue)
	testing::TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsFalse)
	testing::TEST_F (InitGoogleTestTest, ShuffleWithoutValue)
	testing::TEST_F (InitGoogleTestTest, ShuffleFalse_0)
	testing::TEST_F (InitGoogleTestTest, ShuffleTrue)
	testing::TEST_F (InitGoogleTestTest, StackTraceDepth)
	testing::TEST_F (InitGoogleTestTest, StreamResultTo)
	testing::TEST_F (InitGoogleTestTest, ThrowOnFailureWithoutValue)
	testing::TEST_F (InitGoogleTestTest, ThrowOnFailureFalse_0)
	testing::TEST_F (InitGoogleTestTest, ThrowOnFailureTrue)
	testing::TEST_F (CurrentTestInfoTest, WorksForFirstTestInATestCase)
	testing::TEST_F (CurrentTestInfoTest, WorksForSecondTestInATestCase)
	my_namespace::testing::TEST (NestedTestingNamespaceTest, Success)
	my_namespace::testing::TEST (NestedTestingNamespaceTest, Failure)
	TEST (StreamingAssertionsTest, Unconditional)
	TEST (StreamingAssertionsTest, Truth)
	TEST (StreamingAssertionsTest, Truth2)
	TEST (StreamingAssertionsTest, IntegerEquals)
	TEST (StreamingAssertionsTest, IntegerLessThan)
	TEST (StreamingAssertionsTest, StringsEqual)
	TEST (StreamingAssertionsTest, StringsNotEqual)
	TEST (StreamingAssertionsTest, StringsEqualIgnoringCase)
	TEST (StreamingAssertionsTest, StringNotEqualIgnoringCase)
	TEST (StreamingAssertionsTest, FloatingPointEquals)
	TEST (ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes)
	TEST (ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes)
	TEST (ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo)
	TEST (ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid)
	TEST (ColoredOutputTest, UsesColorsWhenStdoutIsTty)
	TEST (ColoredOutputTest, UsesColorsWhenTermSupportsColors)
	TEST (StaticAssertTypeEqTest, WorksInClass)
	TEST (StaticAssertTypeEqTest, CompilesForEqualTypes)
	TEST (GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace)
	TEST (HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure)
static void	FailFatally ()
	TEST (HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure)
	TEST (HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure)
	TEST (HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures)
static bool	HasNonfatalFailureHelper ()
	TEST (HasNonfatalFailureTest, WorksOutsideOfTestBody)
	TEST (HasNonfatalFailureTest, WorksOutsideOfTestBody2)
	TEST (HasFailureTest, ReturnsFalseWhenThereIsNoFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereIsFatalFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures)
static bool	HasFailureHelper ()
	TEST (HasFailureTest, WorksOutsideOfTestBody)
	TEST (HasFailureTest, WorksOutsideOfTestBody2)
	TEST (TestEventListenersTest, ConstructionWorks)
	TEST (TestEventListenersTest, DestructionWorks)
	TEST (TestEventListenersTest, Append)
	TEST (EventListenerTest, AppendKeepsOrder)
	TEST (TestEventListenersTest, Release)
	TEST (EventListenerTest, SuppressEventForwarding)
	TEST (EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses)
	TEST (EventListenerTest, default_result_printer)
	TEST (EventListenerTest, RemovingDefaultResultPrinterWorks)
	TEST (EventListenerTest, default_xml_generator)
	TEST (EventListenerTest, RemovingDefaultXmlGeneratorWorks)
	GTEST_TEST (AlternativeNameTest, Works)
	TEST (IsAProtocolMessageTest, ValueIsCompileTimeConstant)
	TEST (IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage)
	TEST (IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage)
	TEST (CompileAssertTypesEqual, CompilesWhenTypesAreEqual)
	TEST (RemoveReferenceTest, DoesNotAffectNonReferenceType)
	TEST (RemoveReferenceTest, RemovesReference)
template<typename T1 , typename T2 >
void	TestGTestRemoveReference ()
	TEST (RemoveReferenceTest, MacroVersion)
	TEST (RemoveConstTest, DoesNotAffectNonConstType)
	TEST (RemoveConstTest, RemovesConst)
template<typename T1 , typename T2 >
void	TestGTestRemoveConst ()
	TEST (RemoveConstTest, MacroVersion)
template<typename T1 , typename T2 >
void	TestGTestRemoveReferenceAndConst ()
	TEST (RemoveReferenceToConstTest, Works)
	TEST (AddReferenceTest, DoesNotAffectReferenceType)
	TEST (AddReferenceTest, AddsReference)
template<typename T1 , typename T2 >
void	TestGTestAddReference ()
	TEST (AddReferenceTest, MacroVersion)
template<typename T1 , typename T2 >
void	TestGTestReferenceToConst ()
	TEST (GTestReferenceToConstTest, Works)
	TEST (ImplicitlyConvertibleTest, ValueIsCompileTimeConstant)
	TEST (ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible)
	TEST (ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible)
	TEST (IsContainerTestTest, WorksForNonContainer)
	TEST (IsContainerTestTest, WorksForContainer)
	TEST (ArrayEqTest, WorksForDegeneratedArrays)
	TEST (ArrayEqTest, WorksForOneDimensionalArrays)
	TEST (ArrayEqTest, WorksForTwoDimensionalArrays)
	TEST (ArrayAwareFindTest, WorksForOneDimensionalArray)
	TEST (ArrayAwareFindTest, WorksForTwoDimensionalArray)
	TEST (CopyArrayTest, WorksForDegeneratedArrays)
	TEST (CopyArrayTest, WorksForOneDimensionalArrays)
	TEST (CopyArrayTest, WorksForTwoDimensionalArrays)
	TEST (NativeArrayTest, ConstructorFromArrayWorks)
	TEST (NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo)
	TEST (NativeArrayTest, TypeMembersAreCorrect)
	TEST (NativeArrayTest, MethodsWork)
	TEST (NativeArrayTest, WorksForTwoDimensionalArray)
	TEST (SkipPrefixTest, SkipsWhenPrefixMatches)
	TEST (SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch)

Variables
static bool dummy1	GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>()

Macro Definition Documentation

#define GTEST_IMPLEMENTATION_   1

Definition at line 75 of file gtest_unittest.cc.

#define GTEST_TEST_PARSING_FLAGS_	(		argv1,
			argv2,
			expected,
			should_print_help
	)

Value:

TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
                   expected, should_print_help)

Definition at line 5705 of file gtest_unittest.cc.

#define GTEST_USE_UNPROTECTED_COMMA_   global_var++, global_var++

Definition at line 1238 of file gtest_unittest.cc.

#define VERIFY_CODE_LOCATION

Value:

const int expected_line = __LINE__ - 1; \
  const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
  ASSERT_TRUE(test_info); \
  EXPECT_STREQ(__FILE__, test_info->file()); \
  EXPECT_EQ(expected_line, test_info->line())

Definition at line 5337 of file gtest_unittest.cc.

Typedef Documentation

typedef int IntAlias

Definition at line 6884 of file gtest_unittest.cc.

Enumeration Type Documentation

anonymous enum

Definition at line 3899 of file gtest_unittest.cc.

     {
  kCaseA = -1,

# if GTEST_OS_LINUX

  // We want to test the case where the size of the anonymous enum is
  // larger than sizeof(int), to make sure our implementation of the
  // assertions doesn't truncate the enums.  However, MSVC
  // (incorrectly) doesn't allow an enum value to exceed the range of
  // an int, so this has to be conditionally compiled.
  //
  // On Linux, kCaseB and kCaseA have the same value when truncated to
  // int size.  We want to test whether this will confuse the
  // assertions.
  kCaseB = testing::internal::kMaxBiggestInt,

# else

  kCaseB = INT_MAX,

# endif  // GTEST_OS_LINUX

  kCaseC = 42
};

enum NamedEnum

Definition at line 3880 of file gtest_unittest.cc.

               {
  kE1 = 0,
  kE2 = 1
};

Function Documentation

static void FailFatally ( )

static

Definition at line 6903 of file gtest_unittest.cc.

References FAIL.

Referenced by TEST().

{ FAIL(); }

GTEST_TEST	(	AlternativeNameTest	,
		Works
	)

Definition at line 7305 of file gtest_unittest.cc.

References EXPECT_FATAL_FAILURE, GTEST_ASSERT_EQ, GTEST_ASSERT_GE, GTEST_ASSERT_GT, GTEST_ASSERT_LE, GTEST_ASSERT_LT, GTEST_ASSERT_NE, GTEST_FAIL, and GTEST_SUCCEED.

                                       {  // GTEST_TEST is the same as TEST.
  GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.

  // GTEST_FAIL is the same as FAIL.
  EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
                       "An expected failure");

  // GTEST_ASSERT_XY is the same as ASSERT_XY.

  GTEST_ASSERT_EQ(0, 0);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
                       "An expected failure");
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
                       "An expected failure");

  GTEST_ASSERT_NE(0, 1);
  GTEST_ASSERT_NE(1, 0);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
                       "An expected failure");

  GTEST_ASSERT_LE(0, 0);
  GTEST_ASSERT_LE(0, 1);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
                       "An expected failure");

  GTEST_ASSERT_LT(0, 1);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
                       "An expected failure");
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
                       "An expected failure");

  GTEST_ASSERT_GE(0, 0);
  GTEST_ASSERT_GE(1, 0);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
                       "An expected failure");

  GTEST_ASSERT_GT(1, 0);
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
                       "An expected failure");
  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
                       "An expected failure");
}

static bool HasFailureHelper ( )

static

Definition at line 6970 of file gtest_unittest.cc.

References testing::Test::HasFailure().

Referenced by TEST().

{ return testing::Test::HasFailure(); }

static bool HasNonfatalFailureHelper ( )

static

Definition at line 6928 of file gtest_unittest.cc.

References testing::Test::HasNonfatalFailure().

Referenced by TEST().

                                       {
  return testing::Test::HasNonfatalFailure();
}

::std::ostream& operator<<	(	::std::ostream &	os,
		const TestingVector &	vector
	)

Definition at line 305 of file gtest_unittest.cc.

References a, ADD_FAILURE, ASSERT_PRED1, ASSERT_TRUE, folly::test::begin(), testing::internal::String::CaseInsensitiveWideCStringEquals(), testing::internal::TestResultAccessor::ClearTestPartResults(), testing::internal::CodePointToUtf8(), testing::internal::CountIf(), folly::test::end(), testing::internal::String::EndsWithCaseInsensitive(), EXPECT_DEATH_IF_SUPPORTED, EXPECT_EQ, EXPECT_FALSE, EXPECT_FATAL_FAILURE, EXPECT_FATAL_FAILURE_ON_ALL_THREADS, EXPECT_LE, EXPECT_LT, EXPECT_NE, EXPECT_PRED3, EXPECT_STREQ, EXPECT_TRUE, FAIL, testing::TestPartResult::fatally_failed(), testing::internal::ForEach(), testing::internal::FormatEpochTimeInMillisAsIso8601(), testing::internal::FormatTimeInMillisAsSeconds(), bm::free(), testing::internal::Random::Generate(), testing::internal::GetElementOr(), testing::internal::GetNextRandomSeed(), testing::internal::GetRandomSeedFromFlag(), testing::TestPartResultArray::GetTestPartResult(), testing::internal::GetTestTypeId(), testing::internal::GetUnitTestImpl(), GTEST_DISABLE_MSC_WARNINGS_POP_, GTEST_DISABLE_MSC_WARNINGS_PUSH_, GTEST_IS_NULL_LITERAL_, i, testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, testing::ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, testing::gmock_matchers_test::IsPositive(), testing::TestProperty::key(), testing::internal::kMaxRandomSeed, testing::internal::Random::kMaxRange, kSeed, testing::internal::kTestTypeIdInGoogleTest, testing::TestPartResult::nonfatally_failed(), random(), testing::internal::Random::Reseed(), s, seed, testing::internal::String::ShowWideCString(), testing::internal::Shuffle(), testing::internal::ShuffleRange(), testing::TestPartResultArray::size(), string, testing::internal::TEST(), testing::internal::TEST_F(), v, testing::TestProperty::value(), values(), and testing::internal::WideStringToUtf8().

                                                        {
  os << "{ ";
  for (size_t i = 0; i < vector.size(); i++) {
    os << vector[i] << " ";
  }
  os << "}";
  return os;
}

std::ostream& operator<<	(	std::ostream &	os,
		const Base &	val
	)

Definition at line 5162 of file gtest_unittest.cc.

                                          {
  return os << val.x();
}

std::ostream& operator<<	(	std::ostream &	os,
		const Base *	pointer
	)

Definition at line 5166 of file gtest_unittest.cc.

                                              {
  return os << "(" << pointer->x() << ")";
}

std::ostream& operator<<	(	std::ostream &	os,
		const namespace2::MyTypeInNameSpace2 &	val
	)

Definition at line 5237 of file gtest_unittest.cc.

                                                                  {
  return os << val.x();
}

std::ostream& operator<<	(	std::ostream &	os,
		const namespace2::MyTypeInNameSpace2 *	pointer
	)

Definition at line 5241 of file gtest_unittest.cc.

                                                                      {
  return os << "(" << pointer->x() << ")";
}

TEST	(	CommandLineFlagsTest	,
		CanBeAccessedInCodeOnceGTestHIsIncluded
	)

Definition at line 40 of file gtest_unittest.cc.

References dummy(), EXPECT_TRUE, folly::pushmi::operators::filter, GTEST_FLAG, gmock_output_test::output, and repeat().

                                                                    {
  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
      || testing::GTEST_FLAG(break_on_failure)
      || testing::GTEST_FLAG(catch_exceptions)
      || testing::GTEST_FLAG(color) != "unknown"
      || testing::GTEST_FLAG(filter) != "unknown"
      || testing::GTEST_FLAG(list_tests)
      || testing::GTEST_FLAG(output) != "unknown"
      || testing::GTEST_FLAG(print_time)
      || testing::GTEST_FLAG(random_seed)
      || testing::GTEST_FLAG(repeat) > 0
      || testing::GTEST_FLAG(show_internal_stack_frames)
      || testing::GTEST_FLAG(shuffle)
      || testing::GTEST_FLAG(stack_trace_depth) > 0
      || testing::GTEST_FLAG(stream_result_to) != "unknown"
      || testing::GTEST_FLAG(throw_on_failure);
  EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
}

TEST	(	AssertionResultTest	,
		CopyConstructorWorksWhenNotOptimied
	)

Definition at line 5067 of file gtest_unittest.cc.

References testing::AssertionSuccess(), EXPECT_EQ, EXPECT_STREQ, and testing::AssertionResult::message().

                                                               {
  // Checks that the copy constructor doesn't try to dereference NULL pointers
  // in the source object.
  AssertionResult r1 = AssertionSuccess();
  AssertionResult r2 = r1;
  // The following line is added to prevent the compiler from optimizing
  // away the constructor call.
  r1 << "abc";

  AssertionResult r3 = r1;
  EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
  EXPECT_STREQ("abc", r1.message());
}

TEST	(	AssertionResultTest	,
		ConstructionWorks
	)

Definition at line 5083 of file gtest_unittest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), EXPECT_FALSE, EXPECT_STREQ, EXPECT_TRUE, and testing::AssertionResult::message().

                                             {
  AssertionResult r1 = AssertionSuccess();
  EXPECT_TRUE(r1);
  EXPECT_STREQ("", r1.message());

  AssertionResult r2 = AssertionSuccess() << "abc";
  EXPECT_TRUE(r2);
  EXPECT_STREQ("abc", r2.message());

  AssertionResult r3 = AssertionFailure();
  EXPECT_FALSE(r3);
  EXPECT_STREQ("", r3.message());

  AssertionResult r4 = AssertionFailure() << "def";
  EXPECT_FALSE(r4);
  EXPECT_STREQ("def", r4.message());

  AssertionResult r5 = AssertionFailure(Message() << "ghi");
  EXPECT_FALSE(r5);
  EXPECT_STREQ("ghi", r5.message());
}

TEST	(	AssertionResultTest	,
		NegationWorks
	)

Definition at line 5106 of file gtest_unittest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), EXPECT_FALSE, EXPECT_STREQ, EXPECT_TRUE, and message.

                                         {
  AssertionResult r1 = AssertionSuccess() << "abc";
  EXPECT_FALSE(!r1);
  EXPECT_STREQ("abc", (!r1).message());

  AssertionResult r2 = AssertionFailure() << "def";
  EXPECT_TRUE(!r2);
  EXPECT_STREQ("def", (!r2).message());
}

TEST	(	AssertionResultTest	,
		StreamingWorks
	)

Definition at line 5116 of file gtest_unittest.cc.

References testing::AssertionSuccess(), EXPECT_STREQ, and testing::AssertionResult::message().

                                          {
  AssertionResult r = AssertionSuccess();
  r << "abc" << 'd' << 0 << true;
  EXPECT_STREQ("abcd0true", r.message());
}

TEST	(	AssertionResultTest	,
		CanStreamOstreamManipulators
	)

Definition at line 5122 of file gtest_unittest.cc.

References testing::AssertionSuccess(), EXPECT_FALSE, EXPECT_STREQ, EXPECT_TRUE, testing::AssertionResult::message(), testing::internal::TEST(), and value.

                                                        {
  AssertionResult r = AssertionSuccess();
  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
  EXPECT_STREQ("Data\n\\0Will be visible", r.message());
}

TEST	(	AssertionResultTest	,
		ConstructibleFromImplicitlyConvertible
	)

Definition at line 5148 of file gtest_unittest.cc.

References EXPECT_TRUE.

                                                                  {
  ConvertibleToAssertionResult obj;
  EXPECT_TRUE(obj);
}

TEST	(	MessageTest	,
		CanStreamUserTypeInGlobalNameSpace
	)

Definition at line 5171 of file gtest_unittest.cc.

References a, EXPECT_STREQ, testing::Message::GetString(), testing::operator<<(), and val.

                                                      {
  Message msg;
  Base a(1);

  msg << a << &a;  // Uses ::operator<<.
  EXPECT_STREQ("1(1)", msg.GetString().c_str());
}

TEST	(	MessageTest	,
		CanStreamUserTypeInUnnamedNameSpace
	)

Definition at line 5196 of file gtest_unittest.cc.

References a, EXPECT_STREQ, and testing::Message::GetString().

                                                       {
  Message msg;
  MyTypeInUnnamedNameSpace a(1);

  msg << a << &a;  // Uses <unnamed_namespace>::operator<<.
  EXPECT_STREQ("1(1)", msg.GetString().c_str());
}

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpace
	)

Definition at line 5221 of file gtest_unittest.cc.

References a, EXPECT_STREQ, and testing::Message::GetString().

                                                    {
  Message msg;
  namespace1::MyTypeInNameSpace1 a(1);

  msg << a << &a;  // Uses namespace1::operator<<.
  EXPECT_STREQ("1(1)", msg.GetString().c_str());
}

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal
	)

Definition at line 5246 of file gtest_unittest.cc.

References a, EXPECT_STREQ, and testing::Message::GetString().

                                                                              {
  Message msg;
  namespace2::MyTypeInNameSpace2 a(1);

  msg << a << &a;  // Uses ::operator<<.
  EXPECT_STREQ("1(1)", msg.GetString().c_str());
}

TEST	(	MessageTest	,
		NullPointers
	)

Definition at line 5255 of file gtest_unittest.cc.

References ASSERT_STREQ, and testing::Message::GetString().

                                {
  Message msg;
  char* const p1 = NULL;
  unsigned char* const p2 = NULL;
  int* p3 = NULL;
  double* p4 = NULL;
  bool* p5 = NULL;
  Message* p6 = NULL;

  msg << p1 << p2 << p3 << p4 << p5 << p6;
  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
               msg.GetString().c_str());
}

TEST	(	MessageTest	,
		WideStrings
	)

Definition at line 5270 of file gtest_unittest.cc.

References EXPECT_STREQ.

                               {
  // Streams a NULL of type const wchar_t*.
  const wchar_t* const_wstr = NULL;
  EXPECT_STREQ("(null)",
               (Message() << const_wstr).GetString().c_str());

  // Streams a NULL of type wchar_t*.
  wchar_t* wstr = NULL;
  EXPECT_STREQ("(null)",
               (Message() << wstr).GetString().c_str());

  // Streams a non-NULL of type const wchar_t*.
  const_wstr = L"abc\x8119";
  EXPECT_STREQ("abc\xe8\x84\x99",
               (Message() << const_wstr).GetString().c_str());

  // Streams a non-NULL of type wchar_t*.
  wstr = const_cast<wchar_t*>(const_wstr);
  EXPECT_STREQ("abc\xe8\x84\x99",
               (Message() << wstr).GetString().c_str());
}

TEST	(	StreamingAssertionsTest	,
		Unconditional
	)

Definition at line 6609 of file gtest_unittest.cc.

References ADD_FAILURE, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, FAIL, and SUCCEED.

                                             {
  SUCCEED() << "expected success";
  EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		Truth
	)

Definition at line 6622 of file gtest_unittest.cc.

References ASSERT_TRUE, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, and EXPECT_TRUE.

                                     {
  EXPECT_TRUE(true) << "unexpected failure";
  ASSERT_TRUE(true) << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		Truth2
	)

Definition at line 6631 of file gtest_unittest.cc.

References ASSERT_FALSE, EXPECT_FALSE, EXPECT_FATAL_FAILURE, and EXPECT_NONFATAL_FAILURE.

                                      {
  EXPECT_FALSE(false) << "unexpected failure";
  ASSERT_FALSE(false) << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		IntegerEquals
	)

Definition at line 6645 of file gtest_unittest.cc.

References ASSERT_EQ, EXPECT_EQ, EXPECT_FATAL_FAILURE, and EXPECT_NONFATAL_FAILURE.

                                             {
  EXPECT_EQ(1, 1) << "unexpected failure";
  ASSERT_EQ(1, 1) << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		IntegerLessThan
	)

Definition at line 6654 of file gtest_unittest.cc.

References ASSERT_LT, EXPECT_FATAL_FAILURE, EXPECT_LT, and EXPECT_NONFATAL_FAILURE.

                                               {
  EXPECT_LT(1, 2) << "unexpected failure";
  ASSERT_LT(1, 2) << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		StringsEqual
	)

Definition at line 6663 of file gtest_unittest.cc.

References ASSERT_STREQ, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, and EXPECT_STREQ.

                                            {
  EXPECT_STREQ("foo", "foo") << "unexpected failure";
  ASSERT_STREQ("foo", "foo") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		StringsNotEqual
	)

Definition at line 6672 of file gtest_unittest.cc.

References ASSERT_STRNE, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, and EXPECT_STRNE.

                                               {
  EXPECT_STRNE("foo", "bar") << "unexpected failure";
  ASSERT_STRNE("foo", "bar") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		StringsEqualIgnoringCase
	)

Definition at line 6681 of file gtest_unittest.cc.

References ASSERT_STRCASEEQ, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, and EXPECT_STRCASEEQ.

                                                        {
  EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
  ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		StringNotEqualIgnoringCase
	)

Definition at line 6690 of file gtest_unittest.cc.

References ASSERT_STRCASENE, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, and EXPECT_STRCASENE.

                                                          {
  EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
  ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
                       "expected failure");
}

TEST	(	StreamingAssertionsTest	,
		FloatingPointEquals
	)

Definition at line 6699 of file gtest_unittest.cc.

References ASSERT_ANY_THROW, ASSERT_FLOAT_EQ, ASSERT_NO_THROW, ASSERT_THROW, EXPECT_ANY_THROW, EXPECT_FATAL_FAILURE, EXPECT_FLOAT_EQ, EXPECT_NO_THROW, EXPECT_NONFATAL_FAILURE, EXPECT_THROW, and testing::internal::TEST().

                                                   {
  EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
  ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
                          "expected failure");
  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
                       "expected failure");
}

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsYes
	)

Definition at line 6741 of file gtest_unittest.cc.

References EXPECT_TRUE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                           {
  GTEST_FLAG(color) = "yes";

  SetEnv("TERM", "xterm");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
}

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsAliasOfYes
	)

Definition at line 6753 of file gtest_unittest.cc.

References EXPECT_TRUE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                                  {
  SetEnv("TERM", "dumb");  // TERM doesn't support colors.

  GTEST_FLAG(color) = "True";
  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

  GTEST_FLAG(color) = "t";
  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

  GTEST_FLAG(color) = "1";
  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
}

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsNo
	)

Definition at line 6766 of file gtest_unittest.cc.

References EXPECT_FALSE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                           {
  GTEST_FLAG(color) = "no";

  SetEnv("TERM", "xterm");  // TERM supports colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.

  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
}

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsInvalid
	)

Definition at line 6778 of file gtest_unittest.cc.

References EXPECT_FALSE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                                {
  SetEnv("TERM", "xterm");  // TERM supports colors.

  GTEST_FLAG(color) = "F";
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  GTEST_FLAG(color) = "0";
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  GTEST_FLAG(color) = "unknown";
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
}

TEST	(	ColoredOutputTest	,
		UsesColorsWhenStdoutIsTty
	)

Definition at line 6791 of file gtest_unittest.cc.

References EXPECT_FALSE, EXPECT_TRUE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                   {
  GTEST_FLAG(color) = "auto";

  SetEnv("TERM", "xterm");  // TERM supports colors.
  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
  EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
}

TEST	(	ColoredOutputTest	,
		UsesColorsWhenTermSupportsColors
	)

Definition at line 6799 of file gtest_unittest.cc.

References EXPECT_FALSE, EXPECT_TRUE, GTEST_FLAG, and testing::internal::ShouldUseColor().

                                                          {
  GTEST_FLAG(color) = "auto";

#if GTEST_OS_WINDOWS
  // On Windows, we ignore the TERM variable as it's usually not set.

  SetEnv("TERM", "dumb");
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "");
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "xterm");
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
#else
  // On non-Windows platforms, we rely on TERM to determine if the
  // terminal supports colors.

  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "emacs");  // TERM doesn't support colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "vt100");  // TERM doesn't support colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "xterm");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "xterm-color");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "xterm-256color");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "screen");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "screen-256color");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "tmux");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "tmux-256color");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "rxvt-unicode");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "rxvt-unicode-256color");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "linux");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

  SetEnv("TERM", "cygwin");  // TERM supports colors.
  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
#endif  // GTEST_OS_WINDOWS
}

TEST	(	StaticAssertTypeEqTest	,
		WorksInClass
	)

Definition at line 6878 of file gtest_unittest.cc.

                                           {
  StaticAssertTypeEqTestHelper<bool>();
}

TEST	(	StaticAssertTypeEqTest	,
		CompilesForEqualTypes
	)

Definition at line 6886 of file gtest_unittest.cc.

                                                    {
  StaticAssertTypeEq<int, IntAlias>();
  StaticAssertTypeEq<int*, IntAlias*>();
}

TEST	(	GetCurrentOsStackTraceExceptTopTest	,
		ReturnsTheStackTrace
	)

Definition at line 6891 of file gtest_unittest.cc.

References EXPECT_STREQ, testing::internal::GetCurrentOsStackTraceExceptTop(), and testing::UnitTest::GetInstance().

                                                                {
  testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();

  // We don't have a stack walker in Google Test yet.
  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
}

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsNoFailure
	)

Definition at line 6899 of file gtest_unittest.cc.

References EXPECT_FALSE.

                                                               {
  EXPECT_FALSE(HasNonfatalFailure());
}

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsOnlyFatalFailure
	)

Definition at line 6905 of file gtest_unittest.cc.

References EXPECT_FALSE, and FailFatally().

                                                                      {
  FailFatally();
  const bool has_nonfatal_failure = HasNonfatalFailure();
  ClearCurrentTestPartResults();
  EXPECT_FALSE(has_nonfatal_failure);
}

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure
	)

Definition at line 6912 of file gtest_unittest.cc.

References ADD_FAILURE, and EXPECT_TRUE.

                                                                    {
  ADD_FAILURE();
  const bool has_nonfatal_failure = HasNonfatalFailure();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_nonfatal_failure);
}

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures
	)

Definition at line 6919 of file gtest_unittest.cc.

References ADD_FAILURE, EXPECT_TRUE, and FailFatally().

                                                                              {
  FailFatally();
  ADD_FAILURE();
  const bool has_nonfatal_failure = HasNonfatalFailure();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_nonfatal_failure);
}

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody
	)

Definition at line 6932 of file gtest_unittest.cc.

References EXPECT_FALSE, and HasNonfatalFailureHelper().

                                                     {
  EXPECT_FALSE(HasNonfatalFailureHelper());
}

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody2
	)

Definition at line 6936 of file gtest_unittest.cc.

References ADD_FAILURE, EXPECT_TRUE, and HasNonfatalFailureHelper().

                                                      {
  ADD_FAILURE();
  const bool has_nonfatal_failure = HasNonfatalFailureHelper();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_nonfatal_failure);
}

TEST	(	HasFailureTest	,
		ReturnsFalseWhenThereIsNoFailure
	)

Definition at line 6943 of file gtest_unittest.cc.

References EXPECT_FALSE.

                                                       {
  EXPECT_FALSE(HasFailure());
}

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsFatalFailure
	)

Definition at line 6947 of file gtest_unittest.cc.

References EXPECT_TRUE, and FailFatally().

                                                         {
  FailFatally();
  const bool has_failure = HasFailure();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_failure);
}

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure
	)

Definition at line 6954 of file gtest_unittest.cc.

References ADD_FAILURE, and EXPECT_TRUE.

                                                            {
  ADD_FAILURE();
  const bool has_failure = HasFailure();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_failure);
}

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures
	)

Definition at line 6961 of file gtest_unittest.cc.

References ADD_FAILURE, EXPECT_TRUE, and FailFatally().

                                                                      {
  FailFatally();
  ADD_FAILURE();
  const bool has_failure = HasFailure();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_failure);
}

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody
	)

Definition at line 6972 of file gtest_unittest.cc.

References EXPECT_FALSE, and HasFailureHelper().

                                             {
  EXPECT_FALSE(HasFailureHelper());
}

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody2
	)

Definition at line 6976 of file gtest_unittest.cc.

References ADD_FAILURE, EXPECT_TRUE, and HasFailureHelper().

                                              {
  ADD_FAILURE();
  const bool has_failure = HasFailureHelper();
  ClearCurrentTestPartResults();
  EXPECT_TRUE(has_failure);
}

TEST	(	TestEventListenersTest	,
		ConstructionWorks
	)

Definition at line 7007 of file gtest_unittest.cc.

References testing::TestEventListeners::default_result_printer(), testing::TestEventListeners::default_xml_generator(), EXPECT_TRUE, and testing::internal::TestEventListenersAccessor::GetRepeater().

                                                {
  TestEventListeners listeners;

  EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
  EXPECT_TRUE(listeners.default_result_printer() == NULL);
  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
}

TEST	(	TestEventListenersTest	,
		DestructionWorks
	)

Definition at line 7017 of file gtest_unittest.cc.

References testing::TestEventListeners::Append(), EXPECT_TRUE, testing::internal::TestEventListenersAccessor::SetDefaultResultPrinter(), and testing::internal::TestEventListenersAccessor::SetDefaultXmlGenerator().

                                               {
  bool default_result_printer_is_destroyed = false;
  bool default_xml_printer_is_destroyed = false;
  bool extra_listener_is_destroyed = false;
  TestListener* default_result_printer = new TestListener(
      NULL, &default_result_printer_is_destroyed);
  TestListener* default_xml_printer = new TestListener(
      NULL, &default_xml_printer_is_destroyed);
  TestListener* extra_listener = new TestListener(
      NULL, &extra_listener_is_destroyed);

  {
    TestEventListeners listeners;
    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
                                                        default_result_printer);
    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
                                                       default_xml_printer);
    listeners.Append(extra_listener);
  }
  EXPECT_TRUE(default_result_printer_is_destroyed);
  EXPECT_TRUE(default_xml_printer_is_destroyed);
  EXPECT_TRUE(extra_listener_is_destroyed);
}

TEST	(	TestEventListenersTest	,
		Append
	)

Definition at line 7043 of file gtest_unittest.cc.

References testing::TestEventListeners::Append(), EXPECT_EQ, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), and testing::TestEventListener::OnTestProgramStart().

                                     {
  int on_start_counter = 0;
  bool is_destroyed = false;
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
  {
    TestEventListeners listeners;
    listeners.Append(listener);
    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
        *UnitTest::GetInstance());
    EXPECT_EQ(1, on_start_counter);
  }
  EXPECT_TRUE(is_destroyed);
}

TEST	(	EventListenerTest	,
		AppendKeepsOrder
	)

Definition at line 7097 of file gtest_unittest.cc.

References testing::TestEventListeners::Append(), ASSERT_EQ, EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestIterationEnd(), testing::TestEventListener::OnTestIterationStart(), testing::TestEventListener::OnTestProgramEnd(), and testing::TestEventListener::OnTestProgramStart().

                                          {
  std::vector<std::string> vec;
  TestEventListeners listeners;
  listeners.Append(new SequenceTestingListener(&vec, "1st"));
  listeners.Append(new SequenceTestingListener(&vec, "2nd"));
  listeners.Append(new SequenceTestingListener(&vec, "3rd"));

  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());
  ASSERT_EQ(3U, vec.size());
  EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
  EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
  EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());

  vec.clear();
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
      *UnitTest::GetInstance());
  ASSERT_EQ(3U, vec.size());
  EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
  EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
  EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());

  vec.clear();
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
      *UnitTest::GetInstance(), 0);
  ASSERT_EQ(3U, vec.size());
  EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
  EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
  EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());

  vec.clear();
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
      *UnitTest::GetInstance(), 0);
  ASSERT_EQ(3U, vec.size());
  EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
  EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
  EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str());
}

TEST	(	TestEventListenersTest	,
		Release
	)

Definition at line 7138 of file gtest_unittest.cc.

References testing::TestEventListeners::Append(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), and testing::TestEventListeners::Release().

                                      {
  int on_start_counter = 0;
  bool is_destroyed = false;
  // Although Append passes the ownership of this object to the list,
  // the following calls release it, and we need to delete it before the
  // test ends.
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
  {
    TestEventListeners listeners;
    listeners.Append(listener);
    EXPECT_EQ(listener, listeners.Release(listener));
    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
        *UnitTest::GetInstance());
    EXPECT_TRUE(listeners.Release(listener) == NULL);
  }
  EXPECT_EQ(0, on_start_counter);
  EXPECT_FALSE(is_destroyed);
  delete listener;
}

TEST	(	EventListenerTest	,
		SuppressEventForwarding
	)

Definition at line 7159 of file gtest_unittest.cc.

References testing::TestEventListeners::Append(), ASSERT_FALSE, ASSERT_TRUE, testing::internal::TestEventListenersAccessor::EventForwardingEnabled(), EXPECT_EQ, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), and testing::internal::TestEventListenersAccessor::SuppressEventForwarding().

                                                 {
  int on_start_counter = 0;
  TestListener* listener = new TestListener(&on_start_counter, NULL);

  TestEventListeners listeners;
  listeners.Append(listener);
  ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
  TestEventListenersAccessor::SuppressEventForwarding(&listeners);
  ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());
  EXPECT_EQ(0, on_start_counter);
}

TEST	(	EventListenerDeathTest	,
		EventsNotForwardedInDeathTestSubprecesses
	)

Definition at line 7175 of file gtest_unittest.cc.

References testing::internal::TestEventListenersAccessor::EventForwardingEnabled(), EXPECT_DEATH_IF_SUPPORTED, testing::internal::GetUnitTestImpl(), and GTEST_CHECK_.

                                                                        {
  EXPECT_DEATH_IF_SUPPORTED({
      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
          *GetUnitTestImpl()->listeners())) << "expected failure";},
      "expected failure");
}

TEST	(	EventListenerTest	,
		default_result_printer
	)

Definition at line 7185 of file gtest_unittest.cc.

References testing::TestEventListeners::default_result_printer(), EXPECT_EQ, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), and testing::internal::TestEventListenersAccessor::SetDefaultResultPrinter().

                                                {
  int on_start_counter = 0;
  bool is_destroyed = false;
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

  TestEventListeners listeners;
  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);

  EXPECT_EQ(listener, listeners.default_result_printer());

  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());

  EXPECT_EQ(1, on_start_counter);

  // Replacing default_result_printer with something else should remove it
  // from the list and destroy it.
  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);

  EXPECT_TRUE(listeners.default_result_printer() == NULL);
  EXPECT_TRUE(is_destroyed);

  // After broadcasting an event the counter is still the same, indicating
  // the listener is not in the list anymore.
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());
  EXPECT_EQ(1, on_start_counter);
}

TEST	(	EventListenerTest	,
		RemovingDefaultResultPrinterWorks
	)

Definition at line 7216 of file gtest_unittest.cc.

References testing::TestEventListeners::default_result_printer(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), testing::TestEventListeners::Release(), and testing::internal::TestEventListenersAccessor::SetDefaultResultPrinter().

                                                           {
  int on_start_counter = 0;
  bool is_destroyed = false;
  // Although Append passes the ownership of this object to the list,
  // the following calls release it, and we need to delete it before the
  // test ends.
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
  {
    TestEventListeners listeners;
    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);

    EXPECT_EQ(listener, listeners.Release(listener));
    EXPECT_TRUE(listeners.default_result_printer() == NULL);
    EXPECT_FALSE(is_destroyed);

    // Broadcasting events now should not affect default_result_printer.
    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
        *UnitTest::GetInstance());
    EXPECT_EQ(0, on_start_counter);
  }
  // Destroying the list should not affect the listener now, too.
  EXPECT_FALSE(is_destroyed);
  delete listener;
}

TEST	(	EventListenerTest	,
		default_xml_generator
	)

Definition at line 7244 of file gtest_unittest.cc.

References testing::TestEventListeners::default_xml_generator(), EXPECT_EQ, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), and testing::internal::TestEventListenersAccessor::SetDefaultXmlGenerator().

                                               {
  int on_start_counter = 0;
  bool is_destroyed = false;
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

  TestEventListeners listeners;
  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);

  EXPECT_EQ(listener, listeners.default_xml_generator());

  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());

  EXPECT_EQ(1, on_start_counter);

  // Replacing default_xml_generator with something else should remove it
  // from the list and destroy it.
  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);

  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
  EXPECT_TRUE(is_destroyed);

  // After broadcasting an event the counter is still the same, indicating
  // the listener is not in the list anymore.
  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
      *UnitTest::GetInstance());
  EXPECT_EQ(1, on_start_counter);
}

TEST	(	EventListenerTest	,
		RemovingDefaultXmlGeneratorWorks
	)

Definition at line 7275 of file gtest_unittest.cc.

References testing::TestEventListeners::default_xml_generator(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::UnitTest::GetInstance(), testing::internal::TestEventListenersAccessor::GetRepeater(), testing::TestEventListener::OnTestProgramStart(), testing::TestEventListeners::Release(), and testing::internal::TestEventListenersAccessor::SetDefaultXmlGenerator().

                                                          {
  int on_start_counter = 0;
  bool is_destroyed = false;
  // Although Append passes the ownership of this object to the list,
  // the following calls release it, and we need to delete it before the
  // test ends.
  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
  {
    TestEventListeners listeners;
    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);

    EXPECT_EQ(listener, listeners.Release(listener));
    EXPECT_TRUE(listeners.default_xml_generator() == NULL);
    EXPECT_FALSE(is_destroyed);

    // Broadcasting events now should not affect default_xml_generator.
    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
        *UnitTest::GetInstance());
    EXPECT_EQ(0, on_start_counter);
  }
  // Destroying the list should not affect the listener now, too.
  EXPECT_FALSE(is_destroyed);
  delete listener;
}

TEST	(	IsAProtocolMessageTest	,
		ValueIsCompileTimeConstant
	)

Definition at line 7356 of file gtest_unittest.cc.

References GTEST_COMPILE_ASSERT_.

                                                         {
  GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
                        const_true);
  GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
}

TEST	(	IsAProtocolMessageTest	,
		ValueIsTrueWhenTypeIsAProtocolMessage
	)

Definition at line 7364 of file gtest_unittest.cc.

References EXPECT_TRUE.

                                                                    {
  EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
  EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
}

TEST	(	IsAProtocolMessageTest	,
		ValueIsFalseWhenTypeIsNotAProtocolMessage
	)

Definition at line 7371 of file gtest_unittest.cc.

References EXPECT_FALSE.

                                                                        {
  EXPECT_FALSE(IsAProtocolMessage<int>::value);
  EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
}

TEST	(	CompileAssertTypesEqual	,
		CompilesWhenTypesAreEqual
	)

Definition at line 7378 of file gtest_unittest.cc.

                                                         {
  CompileAssertTypesEqual<void, void>();
  CompileAssertTypesEqual<int*, int*>();
}

TEST	(	RemoveReferenceTest	,
		DoesNotAffectNonReferenceType
	)

Definition at line 7384 of file gtest_unittest.cc.

                                                         {
  CompileAssertTypesEqual<int, RemoveReference<int>::type>();
  CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
}

TEST	(	RemoveReferenceTest	,
		RemovesReference
	)

Definition at line 7390 of file gtest_unittest.cc.

                                            {
  CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
  CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
}

TEST	(	RemoveReferenceTest	,
		MacroVersion
	)

Definition at line 7402 of file gtest_unittest.cc.

                                        {
  TestGTestRemoveReference<int, int>();
  TestGTestRemoveReference<const char, const char&>();
}

TEST	(	RemoveConstTest	,
		DoesNotAffectNonConstType
	)

Definition at line 7409 of file gtest_unittest.cc.

                                                 {
  CompileAssertTypesEqual<int, RemoveConst<int>::type>();
  CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
}

TEST	(	RemoveConstTest	,
		RemovesConst
	)

Definition at line 7415 of file gtest_unittest.cc.

                                    {
  CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
  CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
  CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
}

TEST	(	RemoveConstTest	,
		MacroVersion
	)

Definition at line 7428 of file gtest_unittest.cc.

                                    {
  TestGTestRemoveConst<int, int>();
  TestGTestRemoveConst<double&, double&>();
  TestGTestRemoveConst<char, const char>();
}

TEST	(	RemoveReferenceToConstTest	,
		Works
	)

Definition at line 7441 of file gtest_unittest.cc.

                                        {
  TestGTestRemoveReferenceAndConst<int, int>();
  TestGTestRemoveReferenceAndConst<double, double&>();
  TestGTestRemoveReferenceAndConst<char, const char>();
  TestGTestRemoveReferenceAndConst<char, const char&>();
  TestGTestRemoveReferenceAndConst<const char*, const char*>();
}

TEST	(	AddReferenceTest	,
		DoesNotAffectReferenceType
	)

Definition at line 7450 of file gtest_unittest.cc.

                                                   {
  CompileAssertTypesEqual<int&, AddReference<int&>::type>();
  CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
}

TEST	(	AddReferenceTest	,
		AddsReference
	)

Definition at line 7456 of file gtest_unittest.cc.

                                      {
  CompileAssertTypesEqual<int&, AddReference<int>::type>();
  CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
}

TEST	(	AddReferenceTest	,
		MacroVersion
	)

Definition at line 7468 of file gtest_unittest.cc.

                                     {
  TestGTestAddReference<int&, int>();
  TestGTestAddReference<const char&, const char&>();
}

TEST	(	GTestReferenceToConstTest	,
		Works
	)

Definition at line 7480 of file gtest_unittest.cc.

                                       {
  TestGTestReferenceToConst<const char&, char>();
  TestGTestReferenceToConst<const int&, const int>();
  TestGTestReferenceToConst<const double&, double>();
  TestGTestReferenceToConst<const std::string&, const std::string&>();
}

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsCompileTimeConstant
	)

Definition at line 7488 of file gtest_unittest.cc.

References GTEST_COMPILE_ASSERT_.

                                                            {
  GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
  GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
                        const_false);
}

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsTrueWhenConvertible
	)

Definition at line 7496 of file gtest_unittest.cc.

References EXPECT_TRUE, and value.

                                                            {
  EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
  EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
  EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
  EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
  EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
                                     const ConversionHelperBase&>::value));
  EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
                                     ConversionHelperBase>::value));
}

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsFalseWhenNotConvertible
	)

Definition at line 7509 of file gtest_unittest.cc.

References EXPECT_FALSE, and value.

                                                                {
  EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
  EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
  EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
  EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
                                      ConversionHelperDerived&>::value));
}

TEST	(	IsContainerTestTest	,
		WorksForNonContainer
	)

Definition at line 7521 of file gtest_unittest.cc.

References EXPECT_EQ, and testing::internal::IsContainerTest().

                                                {
  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
}

TEST	(	IsContainerTestTest	,
		WorksForContainer
	)

Definition at line 7527 of file gtest_unittest.cc.

References EXPECT_EQ, and testing::internal::IsContainerTest().

                                             {
  EXPECT_EQ(sizeof(IsContainer),
            sizeof(IsContainerTest<std::vector<bool> >(0)));
  EXPECT_EQ(sizeof(IsContainer),
            sizeof(IsContainerTest<std::map<int, double> >(0)));
}

TEST	(	ArrayEqTest	,
		WorksForDegeneratedArrays
	)

Definition at line 7536 of file gtest_unittest.cc.

References testing::internal::ArrayEq(), EXPECT_FALSE, and EXPECT_TRUE.

                                             {
  EXPECT_TRUE(ArrayEq(5, 5L));
  EXPECT_FALSE(ArrayEq('a', 0));
}

TEST	(	ArrayEqTest	,
		WorksForOneDimensionalArrays
	)

Definition at line 7541 of file gtest_unittest.cc.

References a, testing::internal::ArrayEq(), b, EXPECT_FALSE, and EXPECT_TRUE.

                                                {
  // Note that a and b are distinct but compatible types.
  const int a[] = { 0, 1 };
  long b[] = { 0, 1 };
  EXPECT_TRUE(ArrayEq(a, b));
  EXPECT_TRUE(ArrayEq(a, 2, b));

  b[0] = 2;
  EXPECT_FALSE(ArrayEq(a, b));
  EXPECT_FALSE(ArrayEq(a, 1, b));
}

TEST	(	ArrayEqTest	,
		WorksForTwoDimensionalArrays
	)

Definition at line 7553 of file gtest_unittest.cc.

References a, testing::internal::ArrayEq(), b, c, EXPECT_FALSE, and EXPECT_TRUE.

                                                {
  const char a[][3] = { "hi", "lo" };
  const char b[][3] = { "hi", "lo" };
  const char c[][3] = { "hi", "li" };

  EXPECT_TRUE(ArrayEq(a, b));
  EXPECT_TRUE(ArrayEq(a, 2, b));

  EXPECT_FALSE(ArrayEq(a, c));
  EXPECT_FALSE(ArrayEq(a, 2, c));
}

TEST	(	ArrayAwareFindTest	,
		WorksForOneDimensionalArray
	)

Definition at line 7567 of file gtest_unittest.cc.

References a, testing::internal::ArrayAwareFind(), and EXPECT_EQ.

                                                      {
  const char a[] = "hello";
  EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
  EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
}

TEST	(	ArrayAwareFindTest	,
		WorksForTwoDimensionalArray
	)

Definition at line 7573 of file gtest_unittest.cc.

References a, testing::internal::ArrayAwareFind(), b, c, and EXPECT_EQ.

                                                      {
  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
  const int b[2] = { 2, 3 };
  EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));

  const int c[2] = { 6, 7 };
  EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
}

TEST	(	CopyArrayTest	,
		WorksForDegeneratedArrays
	)

Definition at line 7584 of file gtest_unittest.cc.

References testing::internal::CopyArray(), and EXPECT_EQ.

                                               {
  int n = 0;
  CopyArray('a', &n);
  EXPECT_EQ('a', n);
}

TEST	(	CopyArrayTest	,
		WorksForOneDimensionalArrays
	)

Definition at line 7590 of file gtest_unittest.cc.

References a, testing::internal::ArrayEq(), b, c, testing::internal::CopyArray(), and EXPECT_TRUE.

                                                  {
  const char a[3] = "hi";
  int b[3];
#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
  CopyArray(a, &b);
  EXPECT_TRUE(ArrayEq(a, b));
#endif

  int c[3];
  CopyArray(a, 3, c);
  EXPECT_TRUE(ArrayEq(a, c));
}

TEST	(	CopyArrayTest	,
		WorksForTwoDimensionalArrays
	)

Definition at line 7603 of file gtest_unittest.cc.

References a, testing::internal::ArrayEq(), b, c, testing::internal::CopyArray(), and EXPECT_TRUE.

                                                  {
  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
  int b[2][3];
#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
  CopyArray(a, &b);
  EXPECT_TRUE(ArrayEq(a, b));
#endif

  int c[2][3];
  CopyArray(a, 2, c);
  EXPECT_TRUE(ArrayEq(a, c));
}

TEST	(	NativeArrayTest	,
		ConstructorFromArrayWorks
	)

Definition at line 7618 of file gtest_unittest.cc.

References a, testing::internal::NativeArray< Element >::begin(), EXPECT_EQ, and testing::internal::NativeArray< Element >::size().

                                                 {
  const int a[3] = { 0, 1, 2 };
  NativeArray<int> na(a, 3, RelationToSourceReference());
  EXPECT_EQ(3U, na.size());
  EXPECT_EQ(a, na.begin());
}

TEST	(	NativeArrayTest	,
		CreatesAndDeletesCopyOfArrayWhenAskedTo
	)

Definition at line 7625 of file gtest_unittest.cc.

References a, testing::internal::NativeArray< Element >::begin(), EXPECT_EQ, and EXPECT_NE.

                                                               {
  typedef int Array[2];
  Array* a = new Array[1];
  (*a)[0] = 0;
  (*a)[1] = 1;
  NativeArray<int> na(*a, 2, RelationToSourceCopy());
  EXPECT_NE(*a, na.begin());
  delete[] a;
  EXPECT_EQ(0, na.begin()[0]);
  EXPECT_EQ(1, na.begin()[1]);

  // We rely on the heap checker to verify that na deletes the copy of
  // array.
}

TEST	(	NativeArrayTest	,
		TypeMembersAreCorrect
	)

Definition at line 7640 of file gtest_unittest.cc.

                                             {
  StaticAssertTypeEq<char, NativeArray<char>::value_type>();
  StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();

  StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
  StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
}

TEST	(	NativeArrayTest	,
		MethodsWork
	)

Definition at line 7648 of file gtest_unittest.cc.

References a, ASSERT_EQ, testing::internal::NativeArray< Element >::begin(), testing::internal::NativeArray< Element >::end(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and testing::internal::NativeArray< Element >::size().

                                   {
  const int a[3] = { 0, 1, 2 };
  NativeArray<int> na(a, 3, RelationToSourceCopy());
  ASSERT_EQ(3U, na.size());
  EXPECT_EQ(3, na.end() - na.begin());

  NativeArray<int>::const_iterator it = na.begin();
  EXPECT_EQ(0, *it);
  ++it;
  EXPECT_EQ(1, *it);
  it++;
  EXPECT_EQ(2, *it);
  ++it;
  EXPECT_EQ(na.end(), it);

  EXPECT_TRUE(na == na);

  NativeArray<int> na2(a, 3, RelationToSourceReference());
  EXPECT_TRUE(na == na2);

  const int b1[3] = { 0, 1, 1 };
  const int b2[4] = { 0, 1, 2, 3 };
  EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
  EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
}

TEST	(	NativeArrayTest	,
		WorksForTwoDimensionalArray
	)

Definition at line 7674 of file gtest_unittest.cc.

References a, ASSERT_EQ, testing::internal::NativeArray< Element >::begin(), EXPECT_EQ, and testing::internal::NativeArray< Element >::size().

                                                   {
  const char a[2][3] = { "hi", "lo" };
  NativeArray<char[3]> na(a, 2, RelationToSourceReference());
  ASSERT_EQ(2U, na.size());
  EXPECT_EQ(a, na.begin());
}

TEST	(	SkipPrefixTest	,
		SkipsWhenPrefixMatches
	)

Definition at line 7683 of file gtest_unittest.cc.

References EXPECT_EQ, EXPECT_TRUE, and testing::internal::SkipPrefix().

                                             {
  const char* const str = "hello";

  const char* p = str;
  EXPECT_TRUE(SkipPrefix("", &p));
  EXPECT_EQ(str, p);

  p = str;
  EXPECT_TRUE(SkipPrefix("hell", &p));
  EXPECT_EQ(str + 4, p);
}

TEST	(	SkipPrefixTest	,
		DoesNotSkipWhenPrefixDoesNotMatch
	)

Definition at line 7695 of file gtest_unittest.cc.

References EXPECT_EQ, EXPECT_FALSE, and testing::internal::SkipPrefix().

                                                        {
  const char* const str = "world";

  const char* p = str;
  EXPECT_FALSE(SkipPrefix("W", &p));
  EXPECT_EQ(str, p);

  p = str;
  EXPECT_FALSE(SkipPrefix("world!", &p));
  EXPECT_EQ(str, p);
}

template<typename T1 , typename T2 >

void TestGTestAddReference

(

)

Definition at line 7464 of file gtest_unittest.cc.

                             {
  CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
}

template<typename T1 , typename T2 >

void TestGTestReferenceToConst

(

)

Definition at line 7476 of file gtest_unittest.cc.

                                 {
  CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
}

template<typename T1 , typename T2 >

void TestGTestRemoveConst

(

)

Definition at line 7424 of file gtest_unittest.cc.

                            {
  CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
}

template<typename T1 , typename T2 >

void TestGTestRemoveReference

(

)

Definition at line 7398 of file gtest_unittest.cc.

                                {
  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
}

template<typename T1 , typename T2 >

void TestGTestRemoveReferenceAndConst

(

)

Definition at line 7437 of file gtest_unittest.cc.

                                        {
  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
}

Variable Documentation

bool dummy2 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>()

static

Definition at line 6866 of file gtest_unittest.cc.