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"

Include dependency graph for gtest_unittest.cc:

This graph shows which files directly or indirectly include this file:

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::ParseFlagsTest
class	testing::CurrentTestInfoTest
class	my_namespace::testing::Test
class	my_namespace::testing::Message
class	my_namespace::testing::AssertionResult
class	ProtectedFixtureMethodsTest
class	StaticAssertTypeEqTestHelper< T >
struct	TestListener
class	SequenceTestingListener
class	ConversionHelperBase
class	ConversionHelperDerived
class	NonContainer
struct	AHashTable
struct	NotReallyAHashTable
class	AdHocTestResultTest

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

Macros
#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

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 (ParseFlagsTest, Empty)
	testing::TEST_F (ParseFlagsTest, NoFlag)
	testing::TEST_F (ParseFlagsTest, FilterBad)
	testing::TEST_F (ParseFlagsTest, FilterEmpty)
	testing::TEST_F (ParseFlagsTest, FilterNonEmpty)
	testing::TEST_F (ParseFlagsTest, BreakOnFailureWithoutValue)
	testing::TEST_F (ParseFlagsTest, BreakOnFailureFalse_0)
	testing::TEST_F (ParseFlagsTest, BreakOnFailureFalse_f)
	testing::TEST_F (ParseFlagsTest, BreakOnFailureFalse_F)
	testing::TEST_F (ParseFlagsTest, BreakOnFailureTrue)
	testing::TEST_F (ParseFlagsTest, CatchExceptions)
	testing::TEST_F (ParseFlagsTest, DeathTestUseFork)
	testing::TEST_F (ParseFlagsTest, DuplicatedFlags)
	testing::TEST_F (ParseFlagsTest, UnrecognizedFlag)
	testing::TEST_F (ParseFlagsTest, ListTestsFlag)
	testing::TEST_F (ParseFlagsTest, ListTestsTrue)
	testing::TEST_F (ParseFlagsTest, ListTestsFalse)
	testing::TEST_F (ParseFlagsTest, ListTestsFalse_f)
	testing::TEST_F (ParseFlagsTest, ListTestsFalse_F)
	testing::TEST_F (ParseFlagsTest, OutputEmpty)
	testing::TEST_F (ParseFlagsTest, OutputXml)
	testing::TEST_F (ParseFlagsTest, OutputXmlFile)
	testing::TEST_F (ParseFlagsTest, OutputXmlDirectory)
	testing::TEST_F (ParseFlagsTest, PrintTimeFlag)
	testing::TEST_F (ParseFlagsTest, PrintTimeTrue)
	testing::TEST_F (ParseFlagsTest, PrintTimeFalse)
	testing::TEST_F (ParseFlagsTest, PrintTimeFalse_f)
	testing::TEST_F (ParseFlagsTest, PrintTimeFalse_F)
	testing::TEST_F (ParseFlagsTest, RandomSeed)
	testing::TEST_F (ParseFlagsTest, Repeat)
	testing::TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFlag)
	testing::TEST_F (ParseFlagsTest, AlsoRunDisabledTestsTrue)
	testing::TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFalse)
	testing::TEST_F (ParseFlagsTest, ShuffleWithoutValue)
	testing::TEST_F (ParseFlagsTest, ShuffleFalse_0)
	testing::TEST_F (ParseFlagsTest, ShuffleTrue)
	testing::TEST_F (ParseFlagsTest, StackTraceDepth)
	testing::TEST_F (ParseFlagsTest, StreamResultTo)
	testing::TEST_F (ParseFlagsTest, ThrowOnFailureWithoutValue)
	testing::TEST_F (ParseFlagsTest, ThrowOnFailureFalse_0)
	testing::TEST_F (ParseFlagsTest, 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 (HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure)
	TEST (HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure)
	TEST (HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure)
	TEST (HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures)
	TEST (HasNonfatalFailureTest, WorksOutsideOfTestBody)
	TEST (HasNonfatalFailureTest, WorksOutsideOfTestBody2)
	TEST (HasFailureTest, ReturnsFalseWhenThereIsNoFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereIsFatalFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure)
	TEST (HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures)
	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 (IsHashTable, Basic)
	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)
	TEST_F (AdHocTestResultTest, AdHocTestResultForTestCaseShowsFailure)
	TEST_F (AdHocTestResultTest, AdHocTestResultTestForUnitTestDoesNotShowFailure)

Macro Definition Documentation

GTEST_TEST_PARSING_FLAGS_

#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 5739 of file gtest_unittest.cc.

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

GTEST_USE_UNPROTECTED_COMMA_

#define GTEST_USE_UNPROTECTED_COMMA_   global_var++, global_var++

Definition at line 1261 of file gtest_unittest.cc.

VERIFY_CODE_LOCATION

#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 5370 of file gtest_unittest.cc.

#define VERIFY_CODE_LOCATION \
  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())

Typedef Documentation

IntAlias

typedef int IntAlias

Definition at line 6918 of file gtest_unittest.cc.

Function Documentation

GTEST_TEST()

GTEST_TEST	(	AlternativeNameTest	,
		Works	)

Definition at line 7331 of file gtest_unittest.cc.

                                       {  // 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");
}

operator<<() [1/5]

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

Definition at line 301 of file gtest_unittest.cc.

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

operator<<() [2/5]

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

Definition at line 5195 of file gtest_unittest.cc.

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

operator<<() [3/5]

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

Definition at line 5199 of file gtest_unittest.cc.

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

operator<<() [4/5]

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

Definition at line 5270 of file gtest_unittest.cc.

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

operator<<() [5/5]

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

Definition at line 5274 of file gtest_unittest.cc.

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

TEST() [1/90]

TEST	(	AddReferenceTest	,
		AddsReference	)

Definition at line 7482 of file gtest_unittest.cc.

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

TEST() [2/90]

TEST	(	AddReferenceTest	,
		DoesNotAffectReferenceType	)

Definition at line 7476 of file gtest_unittest.cc.

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

TEST() [3/90]

TEST	(	AddReferenceTest	,
		MacroVersion	)

Definition at line 7494 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [4/90]

TEST	(	ArrayAwareFindTest	,
		WorksForOneDimensionalArray	)

Definition at line 7637 of file gtest_unittest.cc.

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

TEST() [5/90]

TEST	(	ArrayAwareFindTest	,
		WorksForTwoDimensionalArray	)

Definition at line 7643 of file gtest_unittest.cc.

                                                      {
  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() [6/90]

TEST	(	ArrayEqTest	,
		WorksForDegeneratedArrays	)

Definition at line 7606 of file gtest_unittest.cc.

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

TEST() [7/90]

TEST	(	ArrayEqTest	,
		WorksForOneDimensionalArrays	)

Definition at line 7611 of file gtest_unittest.cc.

                                                {
  // 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() [8/90]

TEST	(	ArrayEqTest	,
		WorksForTwoDimensionalArrays	)

Definition at line 7623 of file gtest_unittest.cc.

                                                {
  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() [9/90]

TEST	(	AssertionResultTest	,
		CanStreamOstreamManipulators	)

Definition at line 5155 of file gtest_unittest.cc.

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

TEST() [10/90]

TEST	(	AssertionResultTest	,
		ConstructibleFromImplicitlyConvertible	)

Definition at line 5181 of file gtest_unittest.cc.

                                                                  {
  ConvertibleToAssertionResult obj;
  EXPECT_TRUE(obj);
}

TEST() [11/90]

TEST	(	AssertionResultTest	,
		ConstructionWorks	)

Definition at line 5116 of file gtest_unittest.cc.

                                             {
  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());
}

Here is the call graph for this function:

TEST() [12/90]

TEST	(	AssertionResultTest	,
		CopyConstructorWorksWhenNotOptimied	)

Definition at line 5100 of file gtest_unittest.cc.

                                                               {
  // 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());
}

Here is the call graph for this function:

TEST() [13/90]

TEST	(	AssertionResultTest	,
		NegationWorks	)

Definition at line 5139 of file gtest_unittest.cc.

                                         {
  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() [14/90]

TEST	(	AssertionResultTest	,
		StreamingWorks	)

Definition at line 5149 of file gtest_unittest.cc.

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

TEST() [15/90]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsAliasOfYes	)

Definition at line 6787 of file gtest_unittest.cc.

                                                                  {
  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() [16/90]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsYes	)

Definition at line 6775 of file gtest_unittest.cc.

                                                           {
  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() [17/90]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenStdoutIsTty	)

Definition at line 6825 of file gtest_unittest.cc.

                                                   {
  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() [18/90]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenTermSupportsColors	)

Definition at line 6833 of file gtest_unittest.cc.

                                                          {
  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() [19/90]

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsInvalid	)

Definition at line 6812 of file gtest_unittest.cc.

                                                                {
  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() [20/90]

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsNo	)

Definition at line 6800 of file gtest_unittest.cc.

                                                           {
  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() [21/90]

TEST	(	CommandLineFlagsTest	,
		CanBeAccessedInCodeOnceGTestHIsIncluded	)

Definition at line 40 of file gtest_unittest.cc.

                                                                    {
  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() [22/90]

TEST	(	CompileAssertTypesEqual	,
		CompilesWhenTypesAreEqual	)

Definition at line 7404 of file gtest_unittest.cc.

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

TEST() [23/90]

TEST	(	CopyArrayTest	,
		WorksForDegeneratedArrays	)

Definition at line 7654 of file gtest_unittest.cc.

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

TEST() [24/90]

TEST	(	CopyArrayTest	,
		WorksForOneDimensionalArrays	)

Definition at line 7660 of file gtest_unittest.cc.

                                                  {
  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() [25/90]

TEST	(	CopyArrayTest	,
		WorksForTwoDimensionalArrays	)

Definition at line 7673 of file gtest_unittest.cc.

                                                  {
  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() [26/90]

TEST	(	EventListenerDeathTest	,
		EventsNotForwardedInDeathTestSubprecesses	)

Definition at line 7201 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [27/90]

TEST	(	EventListenerTest	,
		AppendKeepsOrder	)

Definition at line 7123 of file gtest_unittest.cc.

                                          {
  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());
}

Here is the call graph for this function:

TEST() [28/90]

TEST	(	EventListenerTest	,
		default_result_printer	)

Definition at line 7211 of file gtest_unittest.cc.

                                                {
  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);
}

Here is the call graph for this function:

TEST() [29/90]

TEST	(	EventListenerTest	,
		default_xml_generator	)

Definition at line 7270 of file gtest_unittest.cc.

                                               {
  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);
}

Here is the call graph for this function:

TEST() [30/90]

TEST	(	EventListenerTest	,
		RemovingDefaultResultPrinterWorks	)

Definition at line 7242 of file gtest_unittest.cc.

                                                           {
  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;
}

Here is the call graph for this function:

TEST() [31/90]

TEST	(	EventListenerTest	,
		RemovingDefaultXmlGeneratorWorks	)

Definition at line 7301 of file gtest_unittest.cc.

                                                          {
  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;
}

Here is the call graph for this function:

TEST() [32/90]

TEST	(	EventListenerTest	,
		SuppressEventForwarding	)

Definition at line 7185 of file gtest_unittest.cc.

                                                 {
  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);
}

Here is the call graph for this function:

TEST() [33/90]

TEST	(	GTestReferenceToConstTest	,
		Works	)

Definition at line 7506 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&>();
}

Here is the call graph for this function:

TEST() [34/90]

TEST	(	HasFailureTest	,
		ReturnsFalseWhenThereIsNoFailure	)

Definition at line 6969 of file gtest_unittest.cc.

                                                       {
  EXPECT_FALSE(HasFailure());
}

TEST() [35/90]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures	)

Definition at line 6987 of file gtest_unittest.cc.

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

TEST() [36/90]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsFatalFailure	)

Definition at line 6973 of file gtest_unittest.cc.

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

TEST() [37/90]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure	)

Definition at line 6980 of file gtest_unittest.cc.

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

TEST() [38/90]

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody	)

Definition at line 6998 of file gtest_unittest.cc.

                                             {
  EXPECT_FALSE(HasFailureHelper());
}

TEST() [39/90]

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody2	)

Definition at line 7002 of file gtest_unittest.cc.

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

TEST() [40/90]

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsNoFailure	)

Definition at line 6925 of file gtest_unittest.cc.

                                                               {
  EXPECT_FALSE(HasNonfatalFailure());
}

TEST() [41/90]

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsOnlyFatalFailure	)

Definition at line 6931 of file gtest_unittest.cc.

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

TEST() [42/90]

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures	)

Definition at line 6945 of file gtest_unittest.cc.

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

TEST() [43/90]

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure	)

Definition at line 6938 of file gtest_unittest.cc.

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

TEST() [44/90]

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody	)

Definition at line 6958 of file gtest_unittest.cc.

                                                     {
  EXPECT_FALSE(HasNonfatalFailureHelper());
}

TEST() [45/90]

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody2	)

Definition at line 6962 of file gtest_unittest.cc.

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

TEST() [46/90]

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsCompileTimeConstant	)

Definition at line 7514 of file gtest_unittest.cc.

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

TEST() [47/90]

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsFalseWhenNotConvertible	)

Definition at line 7535 of file gtest_unittest.cc.

                                                                {
  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() [48/90]

TEST	(	ImplicitlyConvertibleTest	,
		ValueIsTrueWhenConvertible	)

Definition at line 7522 of file gtest_unittest.cc.

                                                            {
  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() [49/90]

TEST	(	IsAProtocolMessageTest	,
		ValueIsCompileTimeConstant	)

Definition at line 7382 of file gtest_unittest.cc.

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

TEST() [50/90]

TEST	(	IsAProtocolMessageTest	,
		ValueIsFalseWhenTypeIsNotAProtocolMessage	)

Definition at line 7397 of file gtest_unittest.cc.

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

TEST() [51/90]

TEST	(	IsAProtocolMessageTest	,
		ValueIsTrueWhenTypeIsAProtocolMessage	)

Definition at line 7390 of file gtest_unittest.cc.

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

TEST() [52/90]

TEST	(	IsContainerTestTest	,
		WorksForContainer	)

Definition at line 7553 of file gtest_unittest.cc.

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

TEST() [53/90]

TEST	(	IsContainerTestTest	,
		WorksForNonContainer	)

Definition at line 7547 of file gtest_unittest.cc.

                                                {
  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() [54/90]

TEST	(	IsHashTable	,
		Basic	)

Definition at line 7592 of file gtest_unittest.cc.

                         {
  EXPECT_TRUE(testing::internal::IsHashTable<AHashTable>::value);
  EXPECT_FALSE(testing::internal::IsHashTable<NotReallyAHashTable>::value);
#if GTEST_LANG_CXX11
  EXPECT_FALSE(testing::internal::IsHashTable<std::vector<int>>::value);
  EXPECT_TRUE(testing::internal::IsHashTable<std::unordered_set<int>>::value);
#endif  // GTEST_LANG_CXX11
#if GTEST_HAS_HASH_SET_
  EXPECT_TRUE(testing::internal::IsHashTable<__gnu_cxx::hash_set<int>>::value);
#endif  // GTEST_HAS_HASH_SET_
}

TEST() [55/90]

TEST	(	MessageTest	,
		CanStreamUserTypeInGlobalNameSpace	)

Definition at line 5204 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [56/90]

TEST	(	MessageTest	,
		CanStreamUserTypeInUnnamedNameSpace	)

Definition at line 5229 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [57/90]

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpace	)

Definition at line 5254 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [58/90]

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal	)

Definition at line 5279 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [59/90]

TEST	(	MessageTest	,
		NullPointers	)

Definition at line 5288 of file gtest_unittest.cc.

                                {
  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());
}

Here is the call graph for this function:

TEST() [60/90]

TEST	(	MessageTest	,
		WideStrings	)

Definition at line 5303 of file gtest_unittest.cc.

                               {
  // 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() [61/90]

TEST	(	NativeArrayTest	,
		ConstructorFromArrayWorks	)

Definition at line 7688 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [62/90]

TEST	(	NativeArrayTest	,
		CreatesAndDeletesCopyOfArrayWhenAskedTo	)

Definition at line 7695 of file gtest_unittest.cc.

                                                               {
  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.
}

Here is the call graph for this function:

TEST() [63/90]

TEST	(	NativeArrayTest	,
		MethodsWork	)

Definition at line 7718 of file gtest_unittest.cc.

                                   {
  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()));
}

Here is the call graph for this function:

TEST() [64/90]

TEST	(	NativeArrayTest	,
		TypeMembersAreCorrect	)

Definition at line 7710 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() [65/90]

TEST	(	NativeArrayTest	,
		WorksForTwoDimensionalArray	)

Definition at line 7744 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [66/90]

TEST	(	RemoveConstTest	,
		DoesNotAffectNonConstType	)

Definition at line 7435 of file gtest_unittest.cc.

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

TEST() [67/90]

TEST	(	RemoveConstTest	,
		MacroVersion	)

Definition at line 7454 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [68/90]

TEST	(	RemoveConstTest	,
		RemovesConst	)

Definition at line 7441 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() [69/90]

TEST	(	RemoveReferenceTest	,
		DoesNotAffectNonReferenceType	)

Definition at line 7410 of file gtest_unittest.cc.

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

TEST() [70/90]

TEST	(	RemoveReferenceTest	,
		MacroVersion	)

Definition at line 7428 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [71/90]

TEST	(	RemoveReferenceTest	,
		RemovesReference	)

Definition at line 7416 of file gtest_unittest.cc.

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

TEST() [72/90]

TEST	(	RemoveReferenceToConstTest	,
		Works	)

Definition at line 7467 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [73/90]

TEST	(	SkipPrefixTest	,
		DoesNotSkipWhenPrefixDoesNotMatch	)

Definition at line 7765 of file gtest_unittest.cc.

                                                        {
  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);
}

TEST() [74/90]

TEST	(	SkipPrefixTest	,
		SkipsWhenPrefixMatches	)

Definition at line 7753 of file gtest_unittest.cc.

                                             {
  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() [75/90]

TEST	(	StaticAssertTypeEqTest	,
		CompilesForEqualTypes	)

Definition at line 6920 of file gtest_unittest.cc.

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

TEST() [76/90]

TEST	(	StaticAssertTypeEqTest	,
		WorksInClass	)

Definition at line 6912 of file gtest_unittest.cc.

                                           {
  StaticAssertTypeEqTestHelper<bool>();
}

TEST() [77/90]

TEST	(	StreamingAssertionsTest	,
		FloatingPointEquals	)

Definition at line 6733 of file gtest_unittest.cc.

                                                   {
  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() [78/90]

TEST	(	StreamingAssertionsTest	,
		IntegerEquals	)

Definition at line 6679 of file gtest_unittest.cc.

                                             {
  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() [79/90]

TEST	(	StreamingAssertionsTest	,
		IntegerLessThan	)

Definition at line 6688 of file gtest_unittest.cc.

                                               {
  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() [80/90]

TEST	(	StreamingAssertionsTest	,
		StringNotEqualIgnoringCase	)

Definition at line 6724 of file gtest_unittest.cc.

                                                          {
  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() [81/90]

TEST	(	StreamingAssertionsTest	,
		StringsEqual	)

Definition at line 6697 of file gtest_unittest.cc.

                                            {
  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() [82/90]

TEST	(	StreamingAssertionsTest	,
		StringsEqualIgnoringCase	)

Definition at line 6715 of file gtest_unittest.cc.

                                                        {
  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() [83/90]

TEST	(	StreamingAssertionsTest	,
		StringsNotEqual	)

Definition at line 6706 of file gtest_unittest.cc.

                                               {
  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() [84/90]

TEST	(	StreamingAssertionsTest	,
		Truth	)

Definition at line 6656 of file gtest_unittest.cc.

                                     {
  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() [85/90]

TEST	(	StreamingAssertionsTest	,
		Truth2	)

Definition at line 6665 of file gtest_unittest.cc.

                                      {
  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() [86/90]

TEST	(	StreamingAssertionsTest	,
		Unconditional	)

Definition at line 6643 of file gtest_unittest.cc.

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

TEST() [87/90]

TEST	(	TestEventListenersTest	,
		Append	)

Definition at line 7069 of file gtest_unittest.cc.

                                     {
  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);
}

Here is the call graph for this function:

TEST() [88/90]

TEST	(	TestEventListenersTest	,
		ConstructionWorks	)

Definition at line 7033 of file gtest_unittest.cc.

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

Here is the call graph for this function:

TEST() [89/90]

TEST	(	TestEventListenersTest	,
		DestructionWorks	)

Definition at line 7043 of file gtest_unittest.cc.

                                               {
  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);
}

Here is the call graph for this function:

TEST() [90/90]

TEST	(	TestEventListenersTest	,
		Release	)

Definition at line 7164 of file gtest_unittest.cc.

                                      {
  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;
}

Here is the call graph for this function:

TEST_F() [1/2]

TEST_F	(	AdHocTestResultTest	,
		AdHocTestResultForTestCaseShowsFailure	)

Definition at line 7786 of file gtest_unittest.cc.

                                                                    {
  const testing::TestResult& test_result = testing::UnitTest::GetInstance()
                                               ->current_test_case()
                                               ->ad_hoc_test_result();
  EXPECT_TRUE(test_result.Failed());
}

Here is the call graph for this function:

TEST_F() [2/2]

TEST_F	(	AdHocTestResultTest	,
		AdHocTestResultTestForUnitTestDoesNotShowFailure	)

Definition at line 7793 of file gtest_unittest.cc.

                                                                              {
  const testing::TestResult& test_result =
      testing::UnitTest::GetInstance()->ad_hoc_test_result();
  EXPECT_FALSE(test_result.Failed());
}

Here is the call graph for this function:

TestGTestAddReference()

template<typename T1 , typename T2 >

void TestGTestAddReference

(

)

Definition at line 7490 of file gtest_unittest.cc.

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

Here is the caller graph for this function:

TestGTestReferenceToConst()

template<typename T1 , typename T2 >

void TestGTestReferenceToConst

(

)

Definition at line 7502 of file gtest_unittest.cc.

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

Here is the caller graph for this function:

TestGTestRemoveConst()

template<typename T1 , typename T2 >

void TestGTestRemoveConst

(

)

Definition at line 7450 of file gtest_unittest.cc.

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

Here is the caller graph for this function:

TestGTestRemoveReference()

template<typename T1 , typename T2 >

void TestGTestRemoveReference

(

)

Definition at line 7424 of file gtest_unittest.cc.

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

Here is the caller graph for this function:

TestGTestRemoveReferenceAndConst()

template<typename T1 , typename T2 >

void TestGTestRemoveReferenceAndConst

(

)

Definition at line 7463 of file gtest_unittest.cc.

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

Here is the caller graph for this function: