Namespaces
namespace	gmock_function_mocker_test

namespace	gmock_matchers_test

namespace	gmock_more_actions_test

namespace	gmock_nice_strict_test

namespace	gtest_printers_test

namespace	internal

Classes
class	Action

class	Action< R(Args...)>

class	ActionInterface

class	CodeLocationForTESTF

class	CodeLocationForTESTP

class	CodeLocationForTYPEDTEST

class	CodeLocationForTYPEDTESTP

class	CurrentTestInfoTest

class	DefaultValue

class	DefaultValue< T & >

class	DefaultValue< void >

class	EmptyTestEventListener

class	Environment

struct	Flags

class	Matcher

class	Message

class	NaggyMock

class	NiceMock

class	OnceAction

class	OnceAction< Result(Args...)>

class	ParseFlagsTest

class	PolymorphicAction

struct	PrintToStringParamName

class	ScopedTrace

class	SetUpTestCaseTest

class	SetUpTestSuiteTest

class	StrictMock

class	Test

class	TestEventListener

class	TestEventListeners

class	TestInfo

class	TestInfoTest

struct	TestParamInfo

class	TestProperty

class	TestResult

class	TestSuite

class	TestWithParam

class	UnitTest

class	WithParamInterface

Typedefs
typedef internal::IgnoredValue	Unused

using	TestCase = TestSuite

typedef internal::TimeInMillis	TimeInMillis

template<typename... Ts>
using	Types = internal::ProxyTypeList<Ts...>

Functions
template<typename F >
Action< F >	MakeAction (ActionInterface< F > *impl)

template<typename Impl >
PolymorphicAction< Impl >	MakePolymorphicAction (const Impl &impl)

template<typename... Action>
internal::DoAllAction< typename std::decay< Action >::type... >	DoAll (Action &&... action)

template<size_t k, typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type, k >	WithArg (InnerAction &&action)

template<size_t k, size_t... ks, typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type, k, ks... >	WithArgs (InnerAction &&action)

template<typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type >	WithoutArgs (InnerAction &&action)

template<typename R >
internal::ReturnAction< R >	Return (R value)

PolymorphicAction< internal::ReturnNullAction >	ReturnNull ()

PolymorphicAction< internal::ReturnVoidAction >	Return ()

template<typename R >
internal::ReturnRefAction< R >	ReturnRef (R &x)

template<typename R , R * = nullptr>
internal::ReturnRefAction< R >	ReturnRef (R &&)=delete

template<typename R >
internal::ReturnRefOfCopyAction< R >	ReturnRefOfCopy (const R &x)

template<typename R >
internal::ByMoveWrapper< R >	ByMove (R x)

template<typename T >
internal::ReturnRoundRobinAction< T >	ReturnRoundRobin (std::vector< T > vals)

template<typename T >
internal::ReturnRoundRobinAction< T >	ReturnRoundRobin (std::initializer_list< T > vals)

internal::DoDefaultAction	DoDefault ()

template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgPointee (T value)

template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgumentPointee (T value)

template<typename T1 , typename T2 >
PolymorphicAction< internal::AssignAction< T1, T2 > >	Assign (T1 *ptr, T2 val)

template<typename T >
PolymorphicAction< internal::SetErrnoAndReturnAction< T > >	SetErrnoAndReturn (int errval, T result)

template<typename FunctionImpl >
std::decay< FunctionImpl >::type	Invoke (FunctionImpl &&function_impl)

template<class Class , typename MethodPtr >
internal::InvokeMethodAction< Class, MethodPtr >	Invoke (Class *obj_ptr, MethodPtr method_ptr)

template<typename FunctionImpl >
internal::InvokeWithoutArgsAction< typename std::decay< FunctionImpl >::type >	InvokeWithoutArgs (FunctionImpl function_impl)

template<class Class , typename MethodPtr >
internal::InvokeMethodWithoutArgsAction< Class, MethodPtr >	InvokeWithoutArgs (Class *obj_ptr, MethodPtr method_ptr)

template<typename A >
internal::IgnoreResultAction< A >	IgnoreResult (const A &an_action)

template<typename T >
inline ::std::reference_wrapper< T >	ByRef (T &l_value)

template<typename T , typename... Params>
internal::ReturnNewAction< T, typename std::decay< Params >::type... >	ReturnNew (Params &&... params)

template<size_t k>
internal::ReturnArgAction< k >	ReturnArg ()

template<size_t k, typename Ptr >
internal::SaveArgAction< k, Ptr >	SaveArg (Ptr pointer)

template<size_t k, typename Ptr >
internal::SaveArgPointeeAction< k, Ptr >	SaveArgPointee (Ptr pointer)

template<size_t k, typename T >
internal::SetArgRefereeAction< k, typename std::decay< T >::type >	SetArgReferee (T &&value)

template<size_t k, typename I1 , typename I2 >
internal::SetArrayArgumentAction< k, I1, I2 >	SetArrayArgument (I1 first, I2 last)

template<size_t k>
internal::DeleteArgAction< k >	DeleteArg ()

template<typename Ptr >
internal::ReturnPointeeAction< Ptr >	ReturnPointee (Ptr pointer)

template<std::size_t index, typename... Params>
internal::InvokeArgumentAction< index, typename std::decay< Params >::type... >	InvokeArgument (Params &&...params)

PolymorphicMatcher< internal::IsEmptyMatcher >	IsEmpty ()

	MATCHER (IsTrue, negation ? "is false" :"is true")

	MATCHER (IsFalse, negation ? "is true" :"is false")

GTEST_API_ void	InitGoogleMock (int argc, char *argv)

GTEST_API_ void	InitGoogleMock (int argc, wchar_t *argv)

GTEST_API_ void	InitGoogleMock ()

GTEST_API_ Cardinality	AtLeast (int n)

GTEST_API_ Cardinality	AtMost (int n)

GTEST_API_ Cardinality	AnyNumber ()

GTEST_API_ Cardinality	Between (int min, int max)

GTEST_API_ Cardinality	Exactly (int n)

std::ostream &	operator<< (std::ostream &os, const Message &sb)

template<typename T , typename IncrementT >
internal::ParamGenerator< T >	Range (T start, T end, IncrementT step)

template<typename T >
internal::ParamGenerator< T >	Range (T start, T end)

template<typename ForwardIterator >
internal::ParamGenerator< typename std::iterator_traits< ForwardIterator >::value_type >	ValuesIn (ForwardIterator begin, ForwardIterator end)

template<typename T , size_t N>
internal::ParamGenerator< T >	ValuesIn (const T(&array)[N])

template<class Container >
internal::ParamGenerator< typename Container::value_type >	ValuesIn (const Container &container)

template<typename... T>
internal::ValueArray< T... >	Values (T... v)

internal::ParamGenerator< bool >	Bool ()

template<typename... Generator>
internal::CartesianProductHolder< Generator... >	Combine (const Generator &... g)

template<typename T >
internal::ParamConverterGenerator< T >	ConvertGenerator (internal::ParamGenerator< T > gen)

template<typename T >
::std::string	PrintToString (const T &value)

Environment *	AddGlobalTestEnvironment (Environment *env)

GTEST_API_ void	InitGoogleTest (int argc, char *argv)

GTEST_API_ void	InitGoogleTest (int argc, wchar_t *argv)

GTEST_API_ void	InitGoogleTest ()

GTEST_API_ AssertionResult	IsSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	IsSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

GTEST_API_ AssertionResult	IsNotSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	IsNotSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

GTEST_API_ AssertionResult	IsSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

GTEST_API_ AssertionResult	IsNotSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

GTEST_API_ AssertionResult	FloatLE (const char expr1, const char expr2, float val1, float val2)

GTEST_API_ AssertionResult	DoubleLE (const char expr1, const char expr2, double val1, double val2)

template<typename T1 , typename T2 >
constexpr bool	StaticAssertTypeEq () noexcept

GTEST_API_ std::string	TempDir ()

GTEST_API_ std::string	SrcDir ()

template<int &... ExplicitParameterBarrier, typename Factory >
TestInfo *	RegisterTest (const char test_suite_name, const char test_name, const char type_param, const char value_param, const char *file, int line, Factory factory)

template<typename Pred , typename T1 >
AssertionResult	AssertPred1Helper (const char pred_text, const char e1, Pred pred, const T1 &v1)

template<typename Pred , typename T1 , typename T2 >
AssertionResult	AssertPred2Helper (const char pred_text, const char e1, const char *e2, Pred pred, const T1 &v1, const T2 &v2)

template<typename Pred , typename T1 , typename T2 , typename T3 >
AssertionResult	AssertPred3Helper (const char pred_text, const char e1, const char e2, const char e3, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3)

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 >
AssertionResult	AssertPred4Helper (const char pred_text, const char e1, const char e2, const char e3, const char *e4, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
AssertionResult	AssertPred5Helper (const char pred_text, const char e1, const char e2, const char e3, const char e4, const char e5, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)

AssertionResult	AssertionSuccess ()

AssertionResult	AssertionFailure ()

AssertionResult	AssertionFailure (const Message &message)

std::ostream &	operator<< (std::ostream &os, const TestPartResult &result)

static const char *	GetDefaultFilter ()

static bool	GetDefaultFailFast ()

template<size_t kSize>
std::vector< std::string >	ArrayAsVector (const char *const (&array)[kSize])

static std::vector< std::string >	GetReservedAttributesForElement (const std::string &xml_element)

static std::string	FormatWordList (const std::vector< std::string > &words)

static bool	ValidateTestPropertyName (const std::string &property_name, const std::vector< std::string > &reserved_names)

static bool	TestPartSkipped (const TestPartResult &result)

static bool	TestPartFatallyFailed (const TestPartResult &result)

static bool	TestPartNonfatallyFailed (const TestPartResult &result)

static std::string	FormatCountableNoun (int count, const char singular_form, const char plural_form)

static std::string	FormatTestCount (int test_count)

static std::string	FormatTestSuiteCount (int test_suite_count)

static const char *	TestPartResultTypeToString (TestPartResult::Type type)

static std::string	GetDirFromEnv (std::initializer_list< const char * > environment_variables, const char *fallback, char separator)

	TEST (GTestEnvVarTest, Dummy)

void	PrintFlag (const char *flag)

	TEST (SuccessfulAssertionTest, SUCCEED)

	TEST (SuccessfulAssertionTest, EXPECT)

	TEST (SuccessfulAssertionTest, EXPECT_STR)

	TEST (SuccessfulAssertionTest, ASSERT)

	TEST (SuccessfulAssertionTest, ASSERT_STR)

	TEST_F (TestInfoTest, Names)

	TEST_F (TestInfoTest, result)

	TEST (CodeLocationForTEST, Verify)

	TEST_F (CodeLocationForTESTF, Verify)

	TEST_P (CodeLocationForTESTP, Verify)

	INSTANTIATE_TEST_SUITE_P (, CodeLocationForTESTP, Values(0))

	TYPED_TEST_SUITE (CodeLocationForTYPEDTEST, int)

	TYPED_TEST (CodeLocationForTYPEDTEST, Verify)

	TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP)

	TYPED_TEST_P (CodeLocationForTYPEDTESTP, Verify)

	REGISTER_TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP, Verify)

	INSTANTIATE_TYPED_TEST_SUITE_P (My, CodeLocationForTYPEDTESTP, int)

	TEST_F (SetUpTestCaseTest, Test1)

	TEST_F (SetUpTestCaseTest, Test2)

	TEST_F (SetUpTestSuiteTest, TestSetupTestSuite1)

	TEST_F (SetUpTestSuiteTest, TestSetupTestSuite2)

	TEST_F (ParseFlagsTest, Empty)

	TEST_F (ParseFlagsTest, NoFlag)

	TEST_F (ParseFlagsTest, FailFast)

	TEST_F (ParseFlagsTest, FilterEmpty)

	TEST_F (ParseFlagsTest, FilterNonEmpty)

	TEST_F (ParseFlagsTest, BreakOnFailureWithoutValue)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_0)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_f)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_F)

	TEST_F (ParseFlagsTest, BreakOnFailureTrue)

	TEST_F (ParseFlagsTest, CatchExceptions)

	TEST_F (ParseFlagsTest, DeathTestUseFork)

	TEST_F (ParseFlagsTest, DuplicatedFlags)

	TEST_F (ParseFlagsTest, UnrecognizedFlag)

	TEST_F (ParseFlagsTest, ListTestsFlag)

	TEST_F (ParseFlagsTest, ListTestsTrue)

	TEST_F (ParseFlagsTest, ListTestsFalse)

	TEST_F (ParseFlagsTest, ListTestsFalse_f)

	TEST_F (ParseFlagsTest, ListTestsFalse_F)

	TEST_F (ParseFlagsTest, OutputXml)

	TEST_F (ParseFlagsTest, OutputXmlFile)

	TEST_F (ParseFlagsTest, OutputXmlDirectory)

	TEST_F (ParseFlagsTest, BriefFlag)

	TEST_F (ParseFlagsTest, BriefFlagTrue)

	TEST_F (ParseFlagsTest, BriefFlagFalse)

	TEST_F (ParseFlagsTest, PrintTimeFlag)

	TEST_F (ParseFlagsTest, PrintTimeTrue)

	TEST_F (ParseFlagsTest, PrintTimeFalse)

	TEST_F (ParseFlagsTest, PrintTimeFalse_f)

	TEST_F (ParseFlagsTest, PrintTimeFalse_F)

	TEST_F (ParseFlagsTest, RandomSeed)

	TEST_F (ParseFlagsTest, Repeat)

	TEST_F (ParseFlagsTest, RecreateEnvironmentsWhenRepeating)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFlag)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsTrue)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFalse)

	TEST_F (ParseFlagsTest, ShuffleWithoutValue)

	TEST_F (ParseFlagsTest, ShuffleFalse_0)

	TEST_F (ParseFlagsTest, ShuffleTrue)

	TEST_F (ParseFlagsTest, StackTraceDepth)

	TEST_F (ParseFlagsTest, StreamResultTo)

	TEST_F (ParseFlagsTest, ThrowOnFailureWithoutValue)

	TEST_F (ParseFlagsTest, ThrowOnFailureFalse_0)

	TEST_F (ParseFlagsTest, ThrowOnFailureTrue)

	TEST_F (ParseFlagsTest, FilterBad)

	TEST_F (ParseFlagsTest, OutputEmpty)

	TEST_F (ParseFlagsTest, UnrecognizedFlags)

	TEST_F (CurrentTestInfoTest, WorksForFirstTestInATestSuite)

	TEST_F (CurrentTestInfoTest, WorksForSecondTestInATestSuite)

Variables
const int	kMaxStackTraceDepth = 100

static const char	kDefaultDeathTestStyle [] = GTEST_DEFAULT_DEATH_TEST_STYLE

static const char	kDisableTestFilter [] = "DISABLED_:/DISABLED_*"

static const char	kDeathTestSuiteFilter [] = "DeathTest:DeathTest/*"

static const char	kUniversalFilter [] = "*"

static const char	kDefaultOutputFormat [] = "xml"

static const char	kDefaultOutputFile [] = "test_detail"

static const char	kTestShardIndex [] = "GTEST_SHARD_INDEX"

static const char	kTestTotalShards [] = "GTEST_TOTAL_SHARDS"

static const char	kTestShardStatusFile [] = "GTEST_SHARD_STATUS_FILE"

static const char *const	kReservedTestSuitesAttributes []

static const char *const	kReservedTestSuiteAttributes []

static const char *const	kReservedTestCaseAttributes []

static const char *const	kReservedOutputTestCaseAttributes []

Typedef Documentation

◆ TestCase

using testing::TestCase = TestSuite

◆ TimeInMillis

typedef internal::TimeInMillis testing::TimeInMillis

◆ Types

template<typename... Ts>

using testing::Types = internal::ProxyTypeList<Ts...>

◆ Unused

typedef internal::IgnoredValue testing::Unused

Function Documentation

◆ AddGlobalTestEnvironment()

Environment * testing::AddGlobalTestEnvironment ( Environment * env )

inline

◆ AnyNumber()

GTEST_API_ Cardinality testing::AnyNumber ( )

◆ ArrayAsVector()

template<size_t kSize>

std::vector< std::string > testing::ArrayAsVector ( const char *const (&) array[kSize] )

◆ AssertionFailure() [1/2]

AssertionResult testing::AssertionFailure ( )

◆ AssertionFailure() [2/2]

AssertionResult testing::AssertionFailure ( const Message & message )

◆ AssertionSuccess()

AssertionResult testing::AssertionSuccess ( )

◆ AssertPred1Helper()

template<typename Pred , typename T1 >

AssertionResult testing::AssertPred1Helper	(	const char *	pred_text,
		const char *	e1,
		Pred	pred,
		const T1 &	v1 )

◆ AssertPred2Helper()

template<typename Pred , typename T1 , typename T2 >

AssertionResult testing::AssertPred2Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2 )

◆ AssertPred3Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 >

AssertionResult testing::AssertPred3Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3 )

◆ AssertPred4Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 >

AssertionResult testing::AssertPred4Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		const char *	e4,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3,
		const T4 &	v4 )

◆ AssertPred5Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

AssertionResult testing::AssertPred5Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		const char *	e4,
		const char *	e5,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3,
		const T4 &	v4,
		const T5 &	v5 )

◆ Assign()

template<typename T1 , typename T2 >

PolymorphicAction< internal::AssignAction< T1, T2 > > testing::Assign	(	T1 *	ptr,
		T2	val )

◆ AtLeast()

GTEST_API_ Cardinality testing::AtLeast ( int n )

◆ AtMost()

GTEST_API_ Cardinality testing::AtMost ( int n )

◆ Between()

GTEST_API_ Cardinality testing::Between	(	int	min,
		int	max )

◆ Bool()

internal::ParamGenerator< bool > testing::Bool ( )

inline

◆ ByMove()

template<typename R >

internal::ByMoveWrapper< R > testing::ByMove ( R x )

◆ ByRef()

template<typename T >

inline ::std::reference_wrapper< T > testing::ByRef ( T & l_value )

◆ Combine()

template<typename... Generator>

internal::CartesianProductHolder< Generator... > testing::Combine ( const Generator &... g )

◆ ConvertGenerator()

template<typename T >

internal::ParamConverterGenerator< T > testing::ConvertGenerator ( internal::ParamGenerator< T > gen )

◆ DeleteArg()

template<size_t k>

internal::DeleteArgAction< k > testing::DeleteArg ( )

◆ DoAll()

template<typename... Action>

internal::DoAllAction< typename std::decay< Action >::type... > testing::DoAll ( Action &&... action )

◆ DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

◆ DoubleLE()

AssertionResult testing::DoubleLE	(	const char *	expr1,
		const char *	expr2,
		double	val1,
		double	val2 )

◆ Exactly()

GTEST_API_ Cardinality testing::Exactly ( int n )

◆ FloatLE()

AssertionResult testing::FloatLE	(	const char *	expr1,
		const char *	expr2,
		float	val1,
		float	val2 )

◆ FormatCountableNoun()

static std::string testing::FormatCountableNoun	(	int	count,
		const char *	singular_form,
		const char *	plural_form )

static

◆ FormatTestCount()

static std::string testing::FormatTestCount ( int test_count )

static

◆ FormatTestSuiteCount()

static std::string testing::FormatTestSuiteCount ( int test_suite_count )

static

◆ FormatWordList()

static std::string testing::FormatWordList ( const std::vector< std::string > & words )

static

◆ GetDefaultFailFast()

static bool testing::GetDefaultFailFast ( )

static

◆ GetDefaultFilter()

static const char * testing::GetDefaultFilter ( )

static

◆ GetDirFromEnv()

static std::string testing::GetDirFromEnv	(	std::initializer_list< const char * >	environment_variables,
		const char *	fallback,
		char	separator )

static

◆ GetReservedAttributesForElement()

static std::vector< std::string > testing::GetReservedAttributesForElement ( const std::string & xml_element )

static

◆ IgnoreResult()

template<typename A >

internal::IgnoreResultAction< A > testing::IgnoreResult ( const A & an_action )

inline

◆ InitGoogleMock() [1/3]

GTEST_API_ void testing::InitGoogleMock ( )

◆ InitGoogleMock() [2/3]

GTEST_API_ void testing::InitGoogleMock	(	int *	argc,
		char **	argv )

◆ InitGoogleMock() [3/3]

GTEST_API_ void testing::InitGoogleMock	(	int *	argc,
		wchar_t **	argv )

◆ InitGoogleTest() [1/3]

void testing::InitGoogleTest ( )

◆ InitGoogleTest() [2/3]

void testing::InitGoogleTest	(	int *	argc,
		char **	argv )

◆ InitGoogleTest() [3/3]

void testing::InitGoogleTest	(	int *	argc,
		wchar_t **	argv )

◆ INSTANTIATE_TEST_SUITE_P()

testing::INSTANTIATE_TEST_SUITE_P	(	CodeLocationForTESTP	,
		Values(0)	)

◆ INSTANTIATE_TYPED_TEST_SUITE_P()

testing::INSTANTIATE_TYPED_TEST_SUITE_P	(	My	,
		CodeLocationForTYPEDTESTP	,
		int	)

◆ Invoke() [1/2]

template<class Class , typename MethodPtr >

internal::InvokeMethodAction< Class, MethodPtr > testing::Invoke	(	Class *	obj_ptr,
		MethodPtr	method_ptr )

◆ Invoke() [2/2]

template<typename FunctionImpl >

std::decay< FunctionImpl >::type testing::Invoke ( FunctionImpl && function_impl )

◆ InvokeArgument()

template<std::size_t index, typename... Params>

internal::InvokeArgumentAction< index, typename std::decay< Params >::type... > testing::InvokeArgument ( Params &&... params )

◆ InvokeWithoutArgs() [1/2]

template<class Class , typename MethodPtr >

internal::InvokeMethodWithoutArgsAction< Class, MethodPtr > testing::InvokeWithoutArgs	(	Class *	obj_ptr,
		MethodPtr	method_ptr )

◆ InvokeWithoutArgs() [2/2]

template<typename FunctionImpl >

internal::InvokeWithoutArgsAction< typename std::decay< FunctionImpl >::type > testing::InvokeWithoutArgs ( FunctionImpl function_impl )

◆ IsEmpty()

PolymorphicMatcher< internal::IsEmptyMatcher > testing::IsEmpty ( )

inline

◆ IsNotSubstring() [1/3]

AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const ::std::string &	needle,
		const ::std::string &	haystack )

◆ IsNotSubstring() [2/3]

AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const char *	needle,
		const char *	haystack )

◆ IsNotSubstring() [3/3]

AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const wchar_t *	needle,
		const wchar_t *	haystack )

◆ IsSubstring() [1/3]

AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const ::std::string &	needle,
		const ::std::string &	haystack )

◆ IsSubstring() [2/3]

AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const char *	needle,
		const char *	haystack )

◆ IsSubstring() [3/3]

AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const wchar_t *	needle,
		const wchar_t *	haystack )

◆ MakeAction()

template<typename F >

Action< F > testing::MakeAction ( ActionInterface< F > * impl )

◆ MakePolymorphicAction()

template<typename Impl >

PolymorphicAction< Impl > testing::MakePolymorphicAction ( const Impl & impl )

inline

◆ MATCHER() [1/2]

testing::MATCHER	(	IsFalse	,
		negation ? "is true" :"is false"	)

◆ MATCHER() [2/2]

testing::MATCHER	(	IsTrue	,
		negation ? "is false" :"is true"	)

◆ operator<<() [1/2]

std::ostream & testing::operator<<	(	std::ostream &	os,
		const Message &	sb )

inline

◆ operator<<() [2/2]

std::ostream & testing::operator<<	(	std::ostream &	os,
		const TestPartResult &	result )

◆ PrintFlag()

void testing::PrintFlag ( const char * flag )

◆ PrintToString()

template<typename T >

::std::string testing::PrintToString ( const T & value )

◆ Range() [1/2]

template<typename T >

internal::ParamGenerator< T > testing::Range	(	T	start,
		T	end )

◆ Range() [2/2]

template<typename T , typename IncrementT >

internal::ParamGenerator< T > testing::Range	(	T	start,
		T	end,
		IncrementT	step )

◆ REGISTER_TYPED_TEST_SUITE_P()

testing::REGISTER_TYPED_TEST_SUITE_P	(	CodeLocationForTYPEDTESTP	,
		Verify	)

◆ RegisterTest()

template<int &... ExplicitParameterBarrier, typename Factory >

TestInfo * testing::RegisterTest	(	const char *	test_suite_name,
		const char *	test_name,
		const char *	type_param,
		const char *	value_param,
		const char *	file,
		int	line,
		Factory	factory )

◆ Return() [1/2]

PolymorphicAction< internal::ReturnVoidAction > testing::Return ( )

inline

◆ Return() [2/2]

template<typename R >

internal::ReturnAction< R > testing::Return ( R value )

◆ ReturnArg()

template<size_t k>

internal::ReturnArgAction< k > testing::ReturnArg ( )

◆ ReturnNew()

template<typename T , typename... Params>

internal::ReturnNewAction< T, typename std::decay< Params >::type... > testing::ReturnNew ( Params &&... params )

◆ ReturnNull()

PolymorphicAction< internal::ReturnNullAction > testing::ReturnNull ( )

inline

◆ ReturnPointee()

template<typename Ptr >

internal::ReturnPointeeAction< Ptr > testing::ReturnPointee ( Ptr pointer )

◆ ReturnRef() [1/2]

template<typename R , R * = nullptr>

internal::ReturnRefAction< R > testing::ReturnRef ( R && )

delete

◆ ReturnRef() [2/2]

template<typename R >

internal::ReturnRefAction< R > testing::ReturnRef ( R & x )

inline

◆ ReturnRefOfCopy()

template<typename R >

internal::ReturnRefOfCopyAction< R > testing::ReturnRefOfCopy ( const R & x )

inline

◆ ReturnRoundRobin() [1/2]

template<typename T >

internal::ReturnRoundRobinAction< T > testing::ReturnRoundRobin ( std::initializer_list< T > vals )

◆ ReturnRoundRobin() [2/2]

template<typename T >

internal::ReturnRoundRobinAction< T > testing::ReturnRoundRobin ( std::vector< T > vals )

◆ SaveArg()

template<size_t k, typename Ptr >

internal::SaveArgAction< k, Ptr > testing::SaveArg ( Ptr pointer )

◆ SaveArgPointee()

template<size_t k, typename Ptr >

internal::SaveArgPointeeAction< k, Ptr > testing::SaveArgPointee ( Ptr pointer )

◆ SetArgPointee()

template<size_t N, typename T >

internal::SetArgumentPointeeAction< N, T > testing::SetArgPointee ( T value )

◆ SetArgReferee()

template<size_t k, typename T >

internal::SetArgRefereeAction< k, typename std::decay< T >::type > testing::SetArgReferee ( T && value )

◆ SetArgumentPointee()

template<size_t N, typename T >

internal::SetArgumentPointeeAction< N, T > testing::SetArgumentPointee ( T value )

◆ SetArrayArgument()

template<size_t k, typename I1 , typename I2 >

internal::SetArrayArgumentAction< k, I1, I2 > testing::SetArrayArgument	(	I1	first,
		I2	last )

◆ SetErrnoAndReturn()

template<typename T >

PolymorphicAction< internal::SetErrnoAndReturnAction< T > > testing::SetErrnoAndReturn	(	int	errval,
		T	result )

◆ SrcDir()

GTEST_API_ std::string testing::SrcDir ( )

◆ StaticAssertTypeEq()

template<typename T1 , typename T2 >

bool testing::StaticAssertTypeEq ( )

constexprnoexcept

◆ TempDir()

std::string testing::TempDir ( )

◆ TEST() [1/7]

testing::TEST	(	CodeLocationForTEST	,
		Verify	)

◆ TEST() [2/7]

testing::TEST	(	GTestEnvVarTest	,
		Dummy	)

◆ TEST() [3/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT	)

◆ TEST() [4/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT_STR	)

◆ TEST() [5/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT	)

◆ TEST() [6/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT_STR	)

◆ TEST() [7/7]

testing::TEST	(	SuccessfulAssertionTest	,
		SUCCEED	)

◆ TEST_F() [1/56]

testing::TEST_F	(	CodeLocationForTESTF	,
		Verify	)

◆ TEST_F() [2/56]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForFirstTestInATestSuite	)

◆ TEST_F() [3/56]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForSecondTestInATestSuite	)

◆ TEST_F() [4/56]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFalse	)

◆ TEST_F() [5/56]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFlag	)

◆ TEST_F() [6/56]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsTrue	)

◆ TEST_F() [7/56]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_0	)

◆ TEST_F() [8/56]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_F	)

◆ TEST_F() [9/56]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_f	)

◆ TEST_F() [10/56]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureTrue	)

◆ TEST_F() [11/56]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureWithoutValue	)

◆ TEST_F() [12/56]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlag	)

◆ TEST_F() [13/56]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlagFalse	)

◆ TEST_F() [14/56]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlagTrue	)

◆ TEST_F() [15/56]

testing::TEST_F	(	ParseFlagsTest	,
		CatchExceptions	)

◆ TEST_F() [16/56]

testing::TEST_F	(	ParseFlagsTest	,
		DeathTestUseFork	)

◆ TEST_F() [17/56]

testing::TEST_F	(	ParseFlagsTest	,
		DuplicatedFlags	)

◆ TEST_F() [18/56]

testing::TEST_F	(	ParseFlagsTest	,
		Empty	)

◆ TEST_F() [19/56]

testing::TEST_F	(	ParseFlagsTest	,
		FailFast	)

◆ TEST_F() [20/56]

testing::TEST_F	(	ParseFlagsTest	,
		FilterBad	)

◆ TEST_F() [21/56]

testing::TEST_F	(	ParseFlagsTest	,
		FilterEmpty	)

◆ TEST_F() [22/56]

testing::TEST_F	(	ParseFlagsTest	,
		FilterNonEmpty	)

◆ TEST_F() [23/56]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse	)

◆ TEST_F() [24/56]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_F	)

◆ TEST_F() [25/56]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_f	)

◆ TEST_F() [26/56]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFlag	)

◆ TEST_F() [27/56]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsTrue	)

◆ TEST_F() [28/56]

testing::TEST_F	(	ParseFlagsTest	,
		NoFlag	)

◆ TEST_F() [29/56]

testing::TEST_F	(	ParseFlagsTest	,
		OutputEmpty	)

◆ TEST_F() [30/56]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXml	)

◆ TEST_F() [31/56]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlDirectory	)

◆ TEST_F() [32/56]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlFile	)

◆ TEST_F() [33/56]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse	)

◆ TEST_F() [34/56]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_F	)

◆ TEST_F() [35/56]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_f	)

◆ TEST_F() [36/56]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFlag	)

◆ TEST_F() [37/56]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeTrue	)

◆ TEST_F() [38/56]

testing::TEST_F	(	ParseFlagsTest	,
		RandomSeed	)

◆ TEST_F() [39/56]

testing::TEST_F	(	ParseFlagsTest	,
		RecreateEnvironmentsWhenRepeating	)

◆ TEST_F() [40/56]

testing::TEST_F	(	ParseFlagsTest	,
		Repeat	)

◆ TEST_F() [41/56]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleFalse_0	)

◆ TEST_F() [42/56]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleTrue	)

◆ TEST_F() [43/56]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleWithoutValue	)

◆ TEST_F() [44/56]

testing::TEST_F	(	ParseFlagsTest	,
		StackTraceDepth	)

◆ TEST_F() [45/56]

testing::TEST_F	(	ParseFlagsTest	,
		StreamResultTo	)

◆ TEST_F() [46/56]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureFalse_0	)

◆ TEST_F() [47/56]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureTrue	)

◆ TEST_F() [48/56]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureWithoutValue	)

◆ TEST_F() [49/56]

testing::TEST_F	(	ParseFlagsTest	,
		UnrecognizedFlag	)

◆ TEST_F() [50/56]

testing::TEST_F	(	ParseFlagsTest	,
		UnrecognizedFlags	)

◆ TEST_F() [51/56]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test1	)

◆ TEST_F() [52/56]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test2	)

◆ TEST_F() [53/56]

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite1	)

◆ TEST_F() [54/56]

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite2	)

◆ TEST_F() [55/56]

testing::TEST_F	(	TestInfoTest	,
		Names	)

◆ TEST_F() [56/56]

testing::TEST_F	(	TestInfoTest	,
		result	)

◆ TEST_P()

testing::TEST_P	(	CodeLocationForTESTP	,
		Verify	)

◆ TestPartFatallyFailed()

static bool testing::TestPartFatallyFailed ( const TestPartResult & result )

static

◆ TestPartNonfatallyFailed()

static bool testing::TestPartNonfatallyFailed ( const TestPartResult & result )

static

◆ TestPartResultTypeToString()

static const char * testing::TestPartResultTypeToString ( TestPartResult::Type type )

static

◆ TestPartSkipped()

static bool testing::TestPartSkipped ( const TestPartResult & result )

static

◆ TYPED_TEST()

testing::TYPED_TEST	(	CodeLocationForTYPEDTEST	,
		Verify	)

◆ TYPED_TEST_P()

testing::TYPED_TEST_P	(	CodeLocationForTYPEDTESTP	,
		Verify	)

◆ TYPED_TEST_SUITE()

testing::TYPED_TEST_SUITE	(	CodeLocationForTYPEDTEST	,
		int	)

◆ TYPED_TEST_SUITE_P()

testing::TYPED_TEST_SUITE_P ( CodeLocationForTYPEDTESTP )

◆ ValidateTestPropertyName()

static bool testing::ValidateTestPropertyName	(	const std::string &	property_name,
		const std::vector< std::string > &	reserved_names )

static

◆ Values()

template<typename... T>

internal::ValueArray< T... > testing::Values ( T... v )

◆ ValuesIn() [1/3]

template<class Container >

internal::ParamGenerator< typename Container::value_type > testing::ValuesIn ( const Container & container )

◆ ValuesIn() [2/3]

template<typename T , size_t N>

internal::ParamGenerator< T > testing::ValuesIn ( const T(&) array[N] )

◆ ValuesIn() [3/3]

template<typename ForwardIterator >

internal::ParamGenerator< typename std::iterator_traits< ForwardIterator >::value_type > testing::ValuesIn	(	ForwardIterator	begin,
		ForwardIterator	end )

◆ WithArg()

template<size_t k, typename InnerAction >

internal::WithArgsAction< typename std::decay< InnerAction >::type, k > testing::WithArg ( InnerAction && action )

◆ WithArgs()

template<size_t k, size_t... ks, typename InnerAction >

internal::WithArgsAction< typename std::decay< InnerAction >::type, k, ks... > testing::WithArgs ( InnerAction && action )

◆ WithoutArgs()

template<typename InnerAction >

internal::WithArgsAction< typename std::decay< InnerAction >::type > testing::WithoutArgs ( InnerAction && action )

Variable Documentation

◆ kDeathTestSuiteFilter

const char testing::kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*"

static

◆ kDefaultDeathTestStyle

const char testing::kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE

static

◆ kDefaultOutputFile

const char testing::kDefaultOutputFile[] = "test_detail"

static

◆ kDefaultOutputFormat

const char testing::kDefaultOutputFormat[] = "xml"

static

◆ kDisableTestFilter

const char testing::kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"

static

◆ kMaxStackTraceDepth

const int testing::kMaxStackTraceDepth = 100

◆ kReservedOutputTestCaseAttributes

const char* const testing::kReservedOutputTestCaseAttributes[]

static

Initial value:

= {
    "classname",   "name", "status", "time",   "type_param",
    "value_param", "file", "line",   "result", "timestamp"}

◆ kReservedTestCaseAttributes

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

= {
    "classname",  "name",        "status", "time",
    "type_param", "value_param", "file",   "line"}

◆ kReservedTestSuiteAttributes

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

= {
    "disabled", "errors", "failures",  "name",
    "tests",    "time",   "timestamp", "skipped"}

◆ kReservedTestSuitesAttributes

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

= {
    "disabled",    "errors", "failures", "name",
    "random_seed", "tests",  "time",     "timestamp"}

◆ kTestShardIndex

const char testing::kTestShardIndex[] = "GTEST_SHARD_INDEX"

static

◆ kTestShardStatusFile

const char testing::kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"

static

◆ kTestTotalShards

const char testing::kTestTotalShards[] = "GTEST_TOTAL_SHARDS"

static

◆ kUniversalFilter

const char testing::kUniversalFilter[] = "*"

static

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ TestCase

◆ TimeInMillis

◆ Types

◆ Unused

Function Documentation

◆ AddGlobalTestEnvironment()

◆ AnyNumber()

◆ ArrayAsVector()

◆ AssertionFailure() [1/2]

◆ AssertionFailure() [2/2]

◆ AssertionSuccess()

◆ AssertPred1Helper()

◆ AssertPred2Helper()

◆ AssertPred3Helper()

◆ AssertPred4Helper()

◆ AssertPred5Helper()

◆ Assign()

◆ AtLeast()

◆ AtMost()

◆ Between()

◆ Bool()

◆ ByMove()

◆ ByRef()

◆ Combine()

◆ ConvertGenerator()

◆ DeleteArg()

◆ DoAll()

◆ DoDefault()

◆ DoubleLE()

◆ Exactly()

◆ FloatLE()

◆ FormatCountableNoun()

◆ FormatTestCount()

◆ FormatTestSuiteCount()

◆ FormatWordList()

◆ GetDefaultFailFast()

◆ GetDefaultFilter()

◆ GetDirFromEnv()

◆ GetReservedAttributesForElement()

◆ IgnoreResult()

◆ InitGoogleMock() [1/3]

◆ InitGoogleMock() [2/3]

◆ InitGoogleMock() [3/3]

◆ InitGoogleTest() [1/3]

◆ InitGoogleTest() [2/3]

◆ InitGoogleTest() [3/3]

◆ INSTANTIATE_TEST_SUITE_P()

◆ INSTANTIATE_TYPED_TEST_SUITE_P()

◆ Invoke() [1/2]

◆ Invoke() [2/2]

◆ InvokeArgument()

◆ InvokeWithoutArgs() [1/2]

◆ InvokeWithoutArgs() [2/2]

◆ IsEmpty()

◆ IsNotSubstring() [1/3]

◆ IsNotSubstring() [2/3]

◆ IsNotSubstring() [3/3]

◆ IsSubstring() [1/3]

◆ IsSubstring() [2/3]

◆ IsSubstring() [3/3]

◆ MakeAction()

◆ MakePolymorphicAction()

◆ MATCHER() [1/2]

◆ MATCHER() [2/2]

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ PrintFlag()

◆ PrintToString()

◆ Range() [1/2]

◆ Range() [2/2]

◆ REGISTER_TYPED_TEST_SUITE_P()

◆ RegisterTest()

◆ Return() [1/2]

◆ Return() [2/2]