gtest_unittest.cc File Reference

#include "gtest/gtest.h"
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <cstdint>
#include <map>
#include <ostream>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>
#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
class	testing::SetUpTestSuiteTest
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 >
class	TestListener
class	SequenceTestingListener
class	ConversionHelperBase
class	ConversionHelperDerived
struct	HasDebugStringMethods
struct	InheritsDebugStringMethods
struct	WrongTypeDebugStringMethod
struct	NotConstDebugStringMethod
struct	MissingDebugStringMethod
class	NonContainer
struct	ConstOnlyContainerWithPointerIterator
struct	ConstOnlyContainerWithClassIterator
struct	ConstOnlyContainerWithClassIterator::const_iterator
struct	AHashTable
struct	NotReallyAHashTable
struct	ConstructionCounting
class	DynamicUnitTestFixture
class	DynamicTest< Pass >

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)
#define	GTEST_FLAT_TUPLE_INT8   int, int, int, int, int, int, int, int,
#define	GTEST_FLAT_TUPLE_INT16   GTEST_FLAT_TUPLE_INT8 GTEST_FLAT_TUPLE_INT8
#define	GTEST_FLAT_TUPLE_INT32   GTEST_FLAT_TUPLE_INT16 GTEST_FLAT_TUPLE_INT16
#define	GTEST_FLAT_TUPLE_INT64   GTEST_FLAT_TUPLE_INT32 GTEST_FLAT_TUPLE_INT32
#define	GTEST_FLAT_TUPLE_INT128   GTEST_FLAT_TUPLE_INT64 GTEST_FLAT_TUPLE_INT64
#define	GTEST_FLAT_TUPLE_INT256   GTEST_FLAT_TUPLE_INT128 GTEST_FLAT_TUPLE_INT128

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, ConstructibleFromContextuallyConvertibleToBool)
	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_SUITE_P (, CodeLocationForTESTP, Values(0))
	testing::TYPED_TEST_SUITE (CodeLocationForTYPEDTEST, int)
	testing::TYPED_TEST (CodeLocationForTYPEDTEST, Verify)
	testing::TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP)
	testing::TYPED_TEST_P (CodeLocationForTYPEDTESTP, Verify)
	testing::REGISTER_TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP, Verify)
	testing::INSTANTIATE_TYPED_TEST_SUITE_P (My, CodeLocationForTYPEDTESTP, int)
	testing::TEST_F (SetUpTestCaseTest, Test1)
	testing::TEST_F (SetUpTestCaseTest, Test2)
	testing::TEST_F (SetUpTestSuiteTest, TestSetupTestSuite1)
	testing::TEST_F (SetUpTestSuiteTest, TestSetupTestSuite2)
	testing::TEST_F (ParseFlagsTest, Empty)
	testing::TEST_F (ParseFlagsTest, NoFlag)
	testing::TEST_F (ParseFlagsTest, FailFast)
	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, BriefFlag)
	testing::TEST_F (ParseFlagsTest, BriefFlagTrue)
	testing::TEST_F (ParseFlagsTest, BriefFlagFalse)
	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, WorksForFirstTestInATestSuite)
	testing::TEST_F (CurrentTestInfoTest, WorksForSecondTestInATestSuite)
	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 (HasDebugStringAndShortDebugStringTest, ValueIsCompileTimeConstant)
	TEST (HasDebugStringAndShortDebugStringTest, ValueIsTrueWhenTypeHasDebugStringAndShortDebugString)
	TEST (HasDebugStringAndShortDebugStringTest, ValueIsFalseWhenTypeIsNotAProtocolMessage)
template<typename T1 , typename T2 >
void	TestGTestRemoveReferenceAndConst ()
	TEST (RemoveReferenceToConstTest, Works)
template<typename T1 , typename T2 >
void	TestGTestReferenceToConst ()
	TEST (GTestReferenceToConstTest, Works)
	TEST (IsContainerTestTest, WorksForNonContainer)
	TEST (IsContainerTestTest, WorksForContainer)
	TEST (IsContainerTestTest, ConstOnlyContainer)
	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 (IndexSequence, MakeIndexSequence)
	TEST (ElemFromList, Basic)
	TEST (FlatTuple, Basic)
	TEST (FlatTuple, Apply)
	TEST (FlatTuple, ConstructorCalls)
	TEST (FlatTuple, ManyTypes)
	TEST (SkipPrefixTest, SkipsWhenPrefixMatches)
	TEST (SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch)
	TEST (AdHocTestResultTest, AdHocTestResultForUnitTestDoesNotShowFailure)
	TEST (RegisterTest, WasRegistered)

Variables
auto *	dynamic_test

Macro Definition Documentation

GTEST_FLAT_TUPLE_INT128

#define GTEST_FLAT_TUPLE_INT128   GTEST_FLAT_TUPLE_INT64 GTEST_FLAT_TUPLE_INT64

GTEST_FLAT_TUPLE_INT16

#define GTEST_FLAT_TUPLE_INT16   GTEST_FLAT_TUPLE_INT8 GTEST_FLAT_TUPLE_INT8

GTEST_FLAT_TUPLE_INT256

#define GTEST_FLAT_TUPLE_INT256   GTEST_FLAT_TUPLE_INT128 GTEST_FLAT_TUPLE_INT128

GTEST_FLAT_TUPLE_INT32

#define GTEST_FLAT_TUPLE_INT32   GTEST_FLAT_TUPLE_INT16 GTEST_FLAT_TUPLE_INT16

GTEST_FLAT_TUPLE_INT64

#define GTEST_FLAT_TUPLE_INT64   GTEST_FLAT_TUPLE_INT32 GTEST_FLAT_TUPLE_INT32

GTEST_FLAT_TUPLE_INT8

#define GTEST_FLAT_TUPLE_INT8   int, int, int, int, int, int, int, int,

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

GTEST_USE_UNPROTECTED_COMMA_

#define GTEST_USE_UNPROTECTED_COMMA_   global_var++, global_var++

Definition at line 1305 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 5387 of file gtest_unittest.cc.

Typedef Documentation

IntAlias

typedef int IntAlias

Definition at line 6750 of file gtest_unittest.cc.

Function Documentation

GTEST_TEST()

GTEST_TEST	(	AlternativeNameTest	,
		Works
	)

Definition at line 7162 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 297 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 5212 of file gtest_unittest.cc.

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

operator<<() [3/5]

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

Definition at line 5216 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 5287 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 5291 of file gtest_unittest.cc.

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

TEST() [1/87]

TEST	(	AdHocTestResultTest	,
		AdHocTestResultForUnitTestDoesNotShowFailure
	)

Definition at line 7753 of file gtest_unittest.cc.

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

TEST() [2/87]

TEST	(	ArrayAwareFindTest	,
		WorksForOneDimensionalArray
	)

Definition at line 7397 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() [3/87]

TEST	(	ArrayAwareFindTest	,
		WorksForTwoDimensionalArray
	)

Definition at line 7403 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() [4/87]

TEST	(	ArrayEqTest	,
		WorksForDegeneratedArrays
	)

Definition at line 7366 of file gtest_unittest.cc.

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

TEST() [5/87]

TEST	(	ArrayEqTest	,
		WorksForOneDimensionalArrays
	)

Definition at line 7371 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() [6/87]

TEST	(	ArrayEqTest	,
		WorksForTwoDimensionalArrays
	)

Definition at line 7383 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() [7/87]

TEST	(	AssertionResultTest	,
		CanStreamOstreamManipulators
	)

Definition at line 5175 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() [8/87]

TEST	(	AssertionResultTest	,
		ConstructibleFromContextuallyConvertibleToBool
	)

Definition at line 5183 of file gtest_unittest.cc.

                                                                          {
  struct ExplicitlyConvertibleToBool {
    explicit operator bool() const { return value; }
    bool value;
  };
  ExplicitlyConvertibleToBool v1 = {false};
  ExplicitlyConvertibleToBool v2 = {true};
  EXPECT_FALSE(v1);
  EXPECT_TRUE(v2);
}

TEST() [9/87]

TEST	(	AssertionResultTest	,
		ConstructibleFromImplicitlyConvertible
	)

Definition at line 5198 of file gtest_unittest.cc.

                                                                  {
  ConvertibleToAssertionResult obj;
  EXPECT_TRUE(obj);
}

TEST() [10/87]

TEST	(	AssertionResultTest	,
		ConstructionWorks
	)

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

TEST() [11/87]

TEST	(	AssertionResultTest	,
		CopyConstructorWorksWhenNotOptimied
	)

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

TEST() [12/87]

TEST	(	AssertionResultTest	,
		NegationWorks
	)

Definition at line 5159 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() [13/87]

TEST	(	AssertionResultTest	,
		StreamingWorks
	)

Definition at line 5169 of file gtest_unittest.cc.

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

TEST() [14/87]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsAliasOfYes
	)

Definition at line 6619 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() [15/87]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenGTestColorFlagIsYes
	)

Definition at line 6607 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() [16/87]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenStdoutIsTty
	)

Definition at line 6657 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() [17/87]

TEST	(	ColoredOutputTest	,
		UsesColorsWhenTermSupportsColors
	)

Definition at line 6665 of file gtest_unittest.cc.

                                                          {
  GTEST_FLAG(color) = "auto";
 
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
  // 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() [18/87]

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsInvalid
	)

Definition at line 6644 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() [19/87]

TEST	(	ColoredOutputTest	,
		UsesNoColorWhenGTestColorFlagIsNo
	)

Definition at line 6632 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() [20/87]

TEST	(	CommandLineFlagsTest	,
		CanBeAccessedInCodeOnceGTestHIsIncluded
	)

Definition at line 39 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(fail_fast) ||
               testing::GTEST_FLAG(filter) != "unknown" ||
               testing::GTEST_FLAG(list_tests) ||
               testing::GTEST_FLAG(output) != "unknown" ||
               testing::GTEST_FLAG(brief) || 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() [21/87]

TEST	(	CopyArrayTest	,
		WorksForDegeneratedArrays
	)

Definition at line 7414 of file gtest_unittest.cc.

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

TEST() [22/87]

TEST	(	CopyArrayTest	,
		WorksForOneDimensionalArrays
	)

Definition at line 7420 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() [23/87]

TEST	(	CopyArrayTest	,
		WorksForTwoDimensionalArrays
	)

Definition at line 7433 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() [24/87]

TEST	(	ElemFromList	,
		Basic
	)

Definition at line 7528 of file gtest_unittest.cc.

                          {
  using testing::internal::ElemFromList;
  EXPECT_TRUE(
      (std::is_same<int, ElemFromList<0, int, double, char>::type>::value));
  EXPECT_TRUE(
      (std::is_same<double, ElemFromList<1, int, double, char>::type>::value));
  EXPECT_TRUE(
      (std::is_same<char, ElemFromList<2, int, double, char>::type>::value));
  EXPECT_TRUE((
      std::is_same<char, ElemFromList<7, int, int, int, int, int, int, int,
                                      char, int, int, int, int>::type>::value));
}

TEST() [25/87]

TEST	(	EventListenerDeathTest	,
		EventsNotForwardedInDeathTestSubprecesses
	)

Definition at line 7032 of file gtest_unittest.cc.

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

TEST() [26/87]

TEST	(	EventListenerTest	,
		AppendKeepsOrder
	)

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

TEST() [27/87]

TEST	(	EventListenerTest	,
		default_result_printer
	)

Definition at line 7042 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, nullptr);
 
  EXPECT_TRUE(listeners.default_result_printer() == nullptr);
  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() [28/87]

TEST	(	EventListenerTest	,
		default_xml_generator
	)

Definition at line 7101 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, nullptr);
 
  EXPECT_TRUE(listeners.default_xml_generator() == nullptr);
  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() [29/87]

TEST	(	EventListenerTest	,
		RemovingDefaultResultPrinterWorks
	)

Definition at line 7073 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() == nullptr);
    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() [30/87]

TEST	(	EventListenerTest	,
		RemovingDefaultXmlGeneratorWorks
	)

Definition at line 7132 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() == nullptr);
    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() [31/87]

TEST	(	EventListenerTest	,
		SuppressEventForwarding
	)

Definition at line 7016 of file gtest_unittest.cc.

                                                 {
  int on_start_counter = 0;
  TestListener* listener = new TestListener(&on_start_counter, nullptr);
 
  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() [32/87]

TEST	(	FlatTuple	,
		Apply
	)

Definition at line 7566 of file gtest_unittest.cc.

                       {
  using testing::internal::FlatTuple;
 
  FlatTuple<int, std::string> tuple{testing::internal::FlatTupleConstructTag{},
                                    5, "Hello"};
 
  // Lambda.
  EXPECT_TRUE(tuple.Apply([](int i, const std::string& s) -> bool {
    return i == static_cast<int>(s.size());
  }));
 
  // Function.
  EXPECT_EQ(tuple.Apply(AddIntToString), "Hello5");
 
  // Mutating operations.
  tuple.Apply([](int& i, std::string& s) {
    ++i;
    s += s;
  });
  EXPECT_EQ(tuple.Get<0>(), 6);
  EXPECT_EQ(tuple.Get<1>(), "HelloHello");
}

TEST() [33/87]

TEST	(	FlatTuple	,
		Basic
	)

Definition at line 7542 of file gtest_unittest.cc.

                       {
  using testing::internal::FlatTuple;
 
  FlatTuple<int, double, const char*> tuple = {};
  EXPECT_EQ(0, tuple.Get<0>());
  EXPECT_EQ(0.0, tuple.Get<1>());
  EXPECT_EQ(nullptr, tuple.Get<2>());
 
  tuple = FlatTuple<int, double, const char*>(
      testing::internal::FlatTupleConstructTag{}, 7, 3.2, "Foo");
  EXPECT_EQ(7, tuple.Get<0>());
  EXPECT_EQ(3.2, tuple.Get<1>());
  EXPECT_EQ(std::string("Foo"), tuple.Get<2>());
 
  tuple.Get<1>() = 5.1;
  EXPECT_EQ(5.1, tuple.Get<1>());
}

TEST() [34/87]

TEST	(	FlatTuple	,
		ConstructorCalls
	)

Definition at line 7627 of file gtest_unittest.cc.

                                  {
  using testing::internal::FlatTuple;
 
  // Default construction.
  ConstructionCounting::Reset();
  { FlatTuple<ConstructionCounting> tuple; }
  EXPECT_EQ(ConstructionCounting::default_ctor_calls, 1);
  EXPECT_EQ(ConstructionCounting::dtor_calls, 1);
  EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::copy_assignment_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_assignment_calls, 0);
 
  // Copy construction.
  ConstructionCounting::Reset();
  {
    ConstructionCounting elem;
    FlatTuple<ConstructionCounting> tuple{
        testing::internal::FlatTupleConstructTag{}, elem};
  }
  EXPECT_EQ(ConstructionCounting::default_ctor_calls, 1);
  EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
  EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 1);
  EXPECT_EQ(ConstructionCounting::move_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::copy_assignment_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_assignment_calls, 0);
 
  // Move construction.
  ConstructionCounting::Reset();
  {
    FlatTuple<ConstructionCounting> tuple{
        testing::internal::FlatTupleConstructTag{}, ConstructionCounting{}};
  }
  EXPECT_EQ(ConstructionCounting::default_ctor_calls, 1);
  EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
  EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_ctor_calls, 1);
  EXPECT_EQ(ConstructionCounting::copy_assignment_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_assignment_calls, 0);
 
  // Copy assignment.
  // TODO(ofats): it should be testing assignment operator of FlatTuple, not its
  // elements
  ConstructionCounting::Reset();
  {
    FlatTuple<ConstructionCounting> tuple;
    ConstructionCounting elem;
    tuple.Get<0>() = elem;
  }
  EXPECT_EQ(ConstructionCounting::default_ctor_calls, 2);
  EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
  EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::copy_assignment_calls, 1);
  EXPECT_EQ(ConstructionCounting::move_assignment_calls, 0);
 
  // Move assignment.
  // TODO(ofats): it should be testing assignment operator of FlatTuple, not its
  // elements
  ConstructionCounting::Reset();
  {
    FlatTuple<ConstructionCounting> tuple;
    tuple.Get<0>() = ConstructionCounting{};
  }
  EXPECT_EQ(ConstructionCounting::default_ctor_calls, 2);
  EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
  EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_ctor_calls, 0);
  EXPECT_EQ(ConstructionCounting::copy_assignment_calls, 0);
  EXPECT_EQ(ConstructionCounting::move_assignment_calls, 1);
 
  ConstructionCounting::Reset();
}

TEST() [35/87]

TEST	(	FlatTuple	,
		ManyTypes
	)

Definition at line 7701 of file gtest_unittest.cc.

                           {
  using testing::internal::FlatTuple;
 
  // Instantiate FlatTuple with 257 ints.
  // Tests show that we can do it with thousands of elements, but very long
  // compile times makes it unusuitable for this test.
#define GTEST_FLAT_TUPLE_INT8 int, int, int, int, int, int, int, int,
#define GTEST_FLAT_TUPLE_INT16 GTEST_FLAT_TUPLE_INT8 GTEST_FLAT_TUPLE_INT8
#define GTEST_FLAT_TUPLE_INT32 GTEST_FLAT_TUPLE_INT16 GTEST_FLAT_TUPLE_INT16
#define GTEST_FLAT_TUPLE_INT64 GTEST_FLAT_TUPLE_INT32 GTEST_FLAT_TUPLE_INT32
#define GTEST_FLAT_TUPLE_INT128 GTEST_FLAT_TUPLE_INT64 GTEST_FLAT_TUPLE_INT64
#define GTEST_FLAT_TUPLE_INT256 GTEST_FLAT_TUPLE_INT128 GTEST_FLAT_TUPLE_INT128
 
  // Let's make sure that we can have a very long list of types without blowing
  // up the template instantiation depth.
  FlatTuple<GTEST_FLAT_TUPLE_INT256 int> tuple;
 
  tuple.Get<0>() = 7;
  tuple.Get<99>() = 17;
  tuple.Get<256>() = 1000;
  EXPECT_EQ(7, tuple.Get<0>());
  EXPECT_EQ(17, tuple.Get<99>());
  EXPECT_EQ(1000, tuple.Get<256>());
}

TEST() [36/87]

TEST	(	GTestReferenceToConstTest	,
		Works
	)

Definition at line 7302 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() [37/87]

TEST	(	HasDebugStringAndShortDebugStringTest	,
		ValueIsCompileTimeConstant
	)

Definition at line 7236 of file gtest_unittest.cc.

                                                                        {
  GTEST_COMPILE_ASSERT_(
      HasDebugStringAndShortDebugString<HasDebugStringMethods>::value,
      const_true);
  GTEST_COMPILE_ASSERT_(
      HasDebugStringAndShortDebugString<InheritsDebugStringMethods>::value,
      const_true);
  GTEST_COMPILE_ASSERT_(HasDebugStringAndShortDebugString<
                            const InheritsDebugStringMethods>::value,
                        const_true);
  GTEST_COMPILE_ASSERT_(
      !HasDebugStringAndShortDebugString<WrongTypeDebugStringMethod>::value,
      const_false);
  GTEST_COMPILE_ASSERT_(
      !HasDebugStringAndShortDebugString<NotConstDebugStringMethod>::value,
      const_false);
  GTEST_COMPILE_ASSERT_(
      !HasDebugStringAndShortDebugString<MissingDebugStringMethod>::value,
      const_false);
  GTEST_COMPILE_ASSERT_(
      !HasDebugStringAndShortDebugString<IncompleteType>::value, const_false);
  GTEST_COMPILE_ASSERT_(!HasDebugStringAndShortDebugString<int>::value,
                        const_false);
}

TEST() [38/87]

TEST	(	HasDebugStringAndShortDebugStringTest	,
		ValueIsFalseWhenTypeIsNotAProtocolMessage
	)

Definition at line 7271 of file gtest_unittest.cc.

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

TEST() [39/87]

TEST	(	HasDebugStringAndShortDebugStringTest	,
		ValueIsTrueWhenTypeHasDebugStringAndShortDebugString
	)

Definition at line 7263 of file gtest_unittest.cc.

                                                           {
  EXPECT_TRUE(
      HasDebugStringAndShortDebugString<InheritsDebugStringMethods>::value);
}

TEST() [40/87]

TEST	(	HasFailureTest	,
		ReturnsFalseWhenThereIsNoFailure
	)

Definition at line 6801 of file gtest_unittest.cc.

                                                       {
  EXPECT_FALSE(HasFailure());
}

TEST() [41/87]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures
	)

Definition at line 6819 of file gtest_unittest.cc.

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

TEST() [42/87]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsFatalFailure
	)

Definition at line 6805 of file gtest_unittest.cc.

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

TEST() [43/87]

TEST	(	HasFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure
	)

Definition at line 6812 of file gtest_unittest.cc.

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

TEST() [44/87]

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody
	)

Definition at line 6830 of file gtest_unittest.cc.

                                             {
  EXPECT_FALSE(HasFailureHelper());
}

TEST() [45/87]

TEST	(	HasFailureTest	,
		WorksOutsideOfTestBody2
	)

Definition at line 6834 of file gtest_unittest.cc.

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

TEST() [46/87]

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsNoFailure
	)

Definition at line 6757 of file gtest_unittest.cc.

                                                               {
  EXPECT_FALSE(HasNonfatalFailure());
}

TEST() [47/87]

TEST	(	HasNonfatalFailureTest	,
		ReturnsFalseWhenThereIsOnlyFatalFailure
	)

Definition at line 6763 of file gtest_unittest.cc.

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

TEST() [48/87]

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereAreFatalAndNonfatalFailures
	)

Definition at line 6777 of file gtest_unittest.cc.

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

TEST() [49/87]

TEST	(	HasNonfatalFailureTest	,
		ReturnsTrueWhenThereIsNonfatalFailure
	)

Definition at line 6770 of file gtest_unittest.cc.

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

TEST() [50/87]

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody
	)

Definition at line 6790 of file gtest_unittest.cc.

                                                     {
  EXPECT_FALSE(HasNonfatalFailureHelper());
}

TEST() [51/87]

TEST	(	HasNonfatalFailureTest	,
		WorksOutsideOfTestBody2
	)

Definition at line 6794 of file gtest_unittest.cc.

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

TEST() [52/87]

TEST	(	IndexSequence	,
		MakeIndexSequence
	)

Definition at line 7512 of file gtest_unittest.cc.

                                       {
  using testing::internal::IndexSequence;
  using testing::internal::MakeIndexSequence;
  EXPECT_TRUE(
      (std::is_same<IndexSequence<>, MakeIndexSequence<0>::type>::value));
  EXPECT_TRUE(
      (std::is_same<IndexSequence<0>, MakeIndexSequence<1>::type>::value));
  EXPECT_TRUE(
      (std::is_same<IndexSequence<0, 1>, MakeIndexSequence<2>::type>::value));
  EXPECT_TRUE((
      std::is_same<IndexSequence<0, 1, 2>, MakeIndexSequence<3>::type>::value));
  EXPECT_TRUE(
      (std::is_base_of<IndexSequence<0, 1, 2>, MakeIndexSequence<3>>::value));
}

TEST() [53/87]

TEST	(	IsContainerTestTest	,
		ConstOnlyContainer
	)

Definition at line 7342 of file gtest_unittest.cc.

                                              {
  EXPECT_EQ(sizeof(IsContainer),
            sizeof(IsContainerTest<ConstOnlyContainerWithPointerIterator>(0)));
  EXPECT_EQ(sizeof(IsContainer),
            sizeof(IsContainerTest<ConstOnlyContainerWithClassIterator>(0)));
}

TEST() [54/87]

TEST	(	IsContainerTestTest	,
		WorksForContainer
	)

Definition at line 7320 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() [55/87]

TEST	(	IsContainerTestTest	,
		WorksForNonContainer
	)

Definition at line 7314 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() [56/87]

TEST	(	IsHashTable	,
		Basic
	)

Definition at line 7357 of file gtest_unittest.cc.

                         {
  EXPECT_TRUE(testing::internal::IsHashTable<AHashTable>::value);
  EXPECT_FALSE(testing::internal::IsHashTable<NotReallyAHashTable>::value);
  EXPECT_FALSE(testing::internal::IsHashTable<std::vector<int>>::value);
  EXPECT_TRUE(testing::internal::IsHashTable<std::unordered_set<int>>::value);
}

TEST() [57/87]

TEST	(	MessageTest	,
		CanStreamUserTypeInGlobalNameSpace
	)

Definition at line 5221 of file gtest_unittest.cc.

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

TEST() [58/87]

TEST	(	MessageTest	,
		CanStreamUserTypeInUnnamedNameSpace
	)

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

TEST() [59/87]

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpace
	)

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

TEST() [60/87]

TEST	(	MessageTest	,
		CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal
	)

Definition at line 5296 of file gtest_unittest.cc.

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

TEST() [61/87]

TEST	(	MessageTest	,
		NullPointers
	)

Definition at line 5305 of file gtest_unittest.cc.

                                {
  Message msg;
  char* const p1 = nullptr;
  unsigned char* const p2 = nullptr;
  int* p3 = nullptr;
  double* p4 = nullptr;
  bool* p5 = nullptr;
  Message* p6 = nullptr;
 
  msg << p1 << p2 << p3 << p4 << p5 << p6;
  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
               msg.GetString().c_str());
}

TEST() [62/87]

TEST	(	MessageTest	,
		WideStrings
	)

Definition at line 5320 of file gtest_unittest.cc.

                               {
  // Streams a NULL of type const wchar_t*.
  const wchar_t* const_wstr = nullptr;
  EXPECT_STREQ("(null)",
               (Message() << const_wstr).GetString().c_str());
 
  // Streams a NULL of type wchar_t*.
  wchar_t* wstr = nullptr;
  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() [63/87]

TEST	(	NativeArrayTest	,
		ConstructorFromArrayWorks
	)

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

TEST() [64/87]

TEST	(	NativeArrayTest	,
		CreatesAndDeletesCopyOfArrayWhenAskedTo
	)

Definition at line 7455 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.
}

TEST() [65/87]

TEST	(	NativeArrayTest	,
		MethodsWork
	)

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

TEST() [66/87]

TEST	(	NativeArrayTest	,
		TypeMembersAreCorrect
	)

Definition at line 7470 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() [67/87]

TEST	(	NativeArrayTest	,
		WorksForTwoDimensionalArray
	)

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

TEST() [68/87]

TEST	(	RegisterTest	,
		WasRegistered
	)

Definition at line 7769 of file gtest_unittest.cc.

                                  {
  auto* unittest = testing::UnitTest::GetInstance();
  for (int i = 0; i < unittest->total_test_suite_count(); ++i) {
    auto* tests = unittest->GetTestSuite(i);
    if (tests->name() != std::string("DynamicUnitTestFixture")) continue;
    for (int j = 0; j < tests->total_test_count(); ++j) {
      if (tests->GetTestInfo(j)->name() != std::string("DynamicTest")) continue;
      // Found it.
      EXPECT_STREQ(tests->GetTestInfo(j)->value_param(), "VALUE");
      EXPECT_STREQ(tests->GetTestInfo(j)->type_param(), "TYPE");
      return;
    }
  }
 
  FAIL() << "Didn't find the test!";
}

TEST() [69/87]

TEST	(	RemoveReferenceToConstTest	,
		Works
	)

Definition at line 7286 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() [70/87]

TEST	(	SkipPrefixTest	,
		DoesNotSkipWhenPrefixDoesNotMatch
	)

Definition at line 7740 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() [71/87]

TEST	(	SkipPrefixTest	,
		SkipsWhenPrefixMatches
	)

Definition at line 7728 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() [72/87]

TEST	(	StaticAssertTypeEqTest	,
		CompilesForEqualTypes
	)

Definition at line 6752 of file gtest_unittest.cc.

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

TEST() [73/87]

TEST	(	StaticAssertTypeEqTest	,
		WorksInClass
	)

Definition at line 6744 of file gtest_unittest.cc.

                                           {
  StaticAssertTypeEqTestHelper<bool>();
}

TEST() [74/87]

TEST	(	StreamingAssertionsTest	,
		FloatingPointEquals
	)

Definition at line 6565 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() [75/87]

TEST	(	StreamingAssertionsTest	,
		IntegerEquals
	)

Definition at line 6511 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() [76/87]

TEST	(	StreamingAssertionsTest	,
		IntegerLessThan
	)

Definition at line 6520 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() [77/87]

TEST	(	StreamingAssertionsTest	,
		StringNotEqualIgnoringCase
	)

Definition at line 6556 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() [78/87]

TEST	(	StreamingAssertionsTest	,
		StringsEqual
	)

Definition at line 6529 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() [79/87]

TEST	(	StreamingAssertionsTest	,
		StringsEqualIgnoringCase
	)

Definition at line 6547 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() [80/87]

TEST	(	StreamingAssertionsTest	,
		StringsNotEqual
	)

Definition at line 6538 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() [81/87]

TEST	(	StreamingAssertionsTest	,
		Truth
	)

Definition at line 6488 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() [82/87]

TEST	(	StreamingAssertionsTest	,
		Truth2
	)

Definition at line 6497 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() [83/87]

TEST	(	StreamingAssertionsTest	,
		Unconditional
	)

Definition at line 6475 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() [84/87]

TEST	(	TestEventListenersTest	,
		Append
	)

Definition at line 6900 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);
}

TEST() [85/87]

TEST	(	TestEventListenersTest	,
		ConstructionWorks
	)

Definition at line 6864 of file gtest_unittest.cc.

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

TEST() [86/87]

TEST	(	TestEventListenersTest	,
		DestructionWorks
	)

Definition at line 6874 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(nullptr, &default_result_printer_is_destroyed);
  TestListener* default_xml_printer =
      new TestListener(nullptr, &default_xml_printer_is_destroyed);
  TestListener* extra_listener =
      new TestListener(nullptr, &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() [87/87]

TEST	(	TestEventListenersTest	,
		Release
	)

Definition at line 6995 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) == nullptr);
  }
  EXPECT_EQ(0, on_start_counter);
  EXPECT_FALSE(is_destroyed);
  delete listener;
}

TestGTestReferenceToConst()

template<typename T1 , typename T2 >

void TestGTestReferenceToConst

(

)

Definition at line 7297 of file gtest_unittest.cc.

                                 {
  static_assert(std::is_same<T1, GTEST_REFERENCE_TO_CONST_(T2)>::value,
                "GTEST_REFERENCE_TO_CONST_ failed.");
}

TestGTestRemoveReferenceAndConst()

template<typename T1 , typename T2 >

void TestGTestRemoveReferenceAndConst

(

)

Definition at line 7281 of file gtest_unittest.cc.

                                        {
  static_assert(std::is_same<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>::value,
                "GTEST_REMOVE_REFERENCE_AND_CONST_ failed.");
}

Variable Documentation

dynamic_test

auto* dynamic_test

Initial value:

= testing::RegisterTest(
    "DynamicUnitTestFixture", "DynamicTest", "TYPE", "VALUE", __FILE__,
    __LINE__, []() -> DynamicUnitTestFixture* { return new DynamicTest; })

Definition at line 7765 of file gtest_unittest.cc.