proxygen: testing Namespace Reference

Namespaces
	gmock_generated_actions_test

	gmock_generated_function_mockers_test

	gmock_matchers_test

	gmock_more_actions_test

	gmock_nice_strict_test

	gtest_printers_test

	internal

	internal2

Classes
class	Action

class	ActionInterface

class	AssertionResult

class	Cardinality

class	CardinalityInterface

class	CodeLocationForTESTF

class	CodeLocationForTESTP

class	CodeLocationForTYPEDTEST

class	CodeLocationForTYPEDTESTP

class	CurrentTestInfoTest

class	DefaultValue

class	DefaultValue< T & >

class	DefaultValue< void >

class	EmptyTestEventListener

class	Environment

class	Expectation

class	ExpectationSet

struct	Flags

class	InitGoogleTestTest

class	InSequence

class	Matcher

class	Matcher< const internal::string & >

class	Matcher< internal::string >

class	MatcherDescriberInterface

class	MatcherInterface

class	MatchResultListener

class	Message

class	Mock

class	MockFunction

class	MockFunction< R(A0)>

class	MockFunction< R(A0, A1)>

class	MockFunction< R(A0, A1, A2)>

class	MockFunction< R(A0, A1, A2, A3)>

class	MockFunction< R(A0, A1, A2, A3, A4)>

class	MockFunction< R(A0, A1, A2, A3, A4, A5)>

class	MockFunction< R(A0, A1, A2, A3, A4, A5, A6)>

class	MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7)>

class	MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8)>

class	MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>

class	NaggyMock

class	NiceMock

class	PolymorphicAction

class	PolymorphicMatcher

class	SafeMatcherCastImpl

class	ScopedFakeTestPartResultReporter

class	Sequence

class	SetUpTestCaseTest

class	StrictMock

class	StringMatchResultListener

class	Test

class	TestCase

class	TestEventListener

class	TestEventListeners

class	TestInfo

class	TestInfoTest

class	TestPartResult

class	TestPartResultArray

class	TestPartResultReporterInterface

class	TestProperty

class	TestResult

class	UnitTest

Typedefs
typedef internal::IgnoredValue	Unused

typedef internal::TimeInMillis	TimeInMillis

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

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

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 >
internal::ReturnRefOfCopyAction< R >	ReturnRefOfCopy (const R &x)

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

internal::DoDefaultAction	DoDefault ()

template<size_t N, typename T >
PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > >	SetArgPointee (const T &x)

template<size_t N>
PolymorphicAction< internal::SetArgumentPointeeAction< N, const char *, false > >	SetArgPointee (const char *p)

template<size_t N>
PolymorphicAction< internal::SetArgumentPointeeAction< N, const wchar_t *, false > >	SetArgPointee (const wchar_t *p)

template<size_t N, typename T >
PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > >	SetArgumentPointee (const T &x)

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 >
PolymorphicAction< internal::InvokeWithoutArgsAction< FunctionImpl > >	InvokeWithoutArgs (FunctionImpl function_impl)

template<class Class , typename MethodPtr >
PolymorphicAction< 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 >
internal::ReferenceWrapper< T >	ByRef (T &l_value)

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)

Cardinality	MakeCardinality (const CardinalityInterface *c)

template<int k1, typename InnerAction >
internal::WithArgsAction< InnerAction, k1 >	WithArgs (const InnerAction &action)

template<int k1, int k2, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9 >	WithArgs (const InnerAction &action)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, int k10, typename InnerAction >
internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 >	WithArgs (const InnerAction &action)

template<typename Action1 , typename Action2 >
internal::DoBothAction< Action1, Action2 >	DoAll (Action1 a1, Action2 a2)

template<typename Action1 , typename Action2 , typename Action3 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, Action3 > >	DoAll (Action1 a1, Action2 a2, Action3 a3)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, Action4 > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, Action5 > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, Action6 > > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, Action7 > > > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, Action7 a7)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, Action8 > > > > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, Action7 a7, Action8 a8)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 , typename Action9 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, internal::DoBothAction< Action8, Action9 > > > > > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, Action7 a7, Action8 a8, Action9 a9)

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 , typename Action9 , typename Action10 >
internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, internal::DoBothAction< Action8, internal::DoBothAction< Action9, Action10 > > > > > > > > >	DoAll (Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, Action7 a7, Action8 a8, Action9 a9, Action10 a10)

template<int k>
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction,)

template<int k>
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction,)< k > InvokeArgument()

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction,)< k >

template<int k, typename p0_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P)< k

p0_type	InvokeArgument (p0_type p0)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P)< k

template<int k, typename p0_type , typename p1_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P2)

template<int k, typename p0_type , typename p1_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P2)< k

p1_type	InvokeArgument (p0_type p0, p1_type p1)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P2)< k

template<int k, typename p0_type , typename p1_type , typename p2_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P3)

template<int k, typename p0_type , typename p1_type , typename p2_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P3)< k

p2_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P3)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P4)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P4)< k

p3_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P4)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P5)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P5)< k

p4_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P5)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P6)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P6)< k

p5_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P6)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P7)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P7)< k

p6_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P7)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P8)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P8)< k

p7_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P8)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P9)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P9)< k

p8_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7, p8_type p8)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P9)< k

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >
class	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P10)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >
	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P10)< k

p9_type	InvokeArgument (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7, p8_type p8, p9_type p9)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (InvokeArgumentAction, P10)< k

template<typename T >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction,)

template<typename T >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction,)< T > ReturnNew()

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction,)< T >

template<typename T , typename p0_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P)< T

p0_type	ReturnNew (p0_type p0)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P)< T

template<typename T , typename p0_type , typename p1_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P2)

template<typename T , typename p0_type , typename p1_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P2)< T

p1_type	ReturnNew (p0_type p0, p1_type p1)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P2)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P3)

template<typename T , typename p0_type , typename p1_type , typename p2_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P3)< T

p2_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P3)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P4)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P4)< T

p3_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P4)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P5)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P5)< T

p4_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P5)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P6)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P6)< T

p5_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P6)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P7)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P7)< T

p6_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P7)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P8)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P8)< T

p7_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P8)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P9)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P9)< T

p8_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7, p8_type p8)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P9)< T

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >
class	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P10)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >
	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P10)< T

p9_type	ReturnNew (p0_type p0, p1_type p1, p2_type p2, p3_type p3, p4_type p4, p5_type p5, p6_type p6, p7_type p7, p8_type p8, p9_type p9)

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >
::testing::internal::Function< F >::Result	GTEST_CONCAT_TOKEN_ (ReturnNewAction, P10)< T

template<typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher >	Args (const InnerMatcher &matcher)

template<int k1, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9 >	Args (const InnerMatcher &matcher)

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, int k10, typename InnerMatcher >
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 >	Args (const InnerMatcher &matcher)

internal::ElementsAreMatcher< ::testing::tuple<> >	ElementsAre ()

template<typename T1 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type > >	ElementsAre (const T1 &e1)

template<typename T1 , typename T2 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type > >	ElementsAre (const T1 &e1, const T2 &e2)

template<typename T1 , typename T2 , typename T3 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3)

template<typename T1 , typename T2 , typename T3 , typename T4 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type, typename internal::DecayArray< T10 >::type > >	ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9, const T10 &e10)

internal::UnorderedElementsAreMatcher< ::testing::tuple<> >	UnorderedElementsAre ()

template<typename T1 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type > >	UnorderedElementsAre (const T1 &e1)

template<typename T1 , typename T2 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2)

template<typename T1 , typename T2 , typename T3 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3)

template<typename T1 , typename T2 , typename T3 , typename T4 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray< T1 >::type, typename internal::DecayArray< T2 >::type, typename internal::DecayArray< T3 >::type, typename internal::DecayArray< T4 >::type, typename internal::DecayArray< T5 >::type, typename internal::DecayArray< T6 >::type, typename internal::DecayArray< T7 >::type, typename internal::DecayArray< T8 >::type, typename internal::DecayArray< T9 >::type, typename internal::DecayArray< T10 >::type > >	UnorderedElementsAre (const T1 &e1, const T2 &e2, const T3 &e3, const T4 &e4, const T5 &e5, const T6 &e6, const T7 &e7, const T8 &e8, const T9 &e9, const T10 &e10)

template<typename M1 , typename M2 >
internal::AllOfResult2< M1, M2 >::type	AllOf (M1 m1, M2 m2)

template<typename M1 , typename M2 , typename M3 >
internal::AllOfResult3< M1, M2, M3 >::type	AllOf (M1 m1, M2 m2, M3 m3)

template<typename M1 , typename M2 , typename M3 , typename M4 >
internal::AllOfResult4< M1, M2, M3, M4 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 >
internal::AllOfResult5< M1, M2, M3, M4, M5 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 >
internal::AllOfResult6< M1, M2, M3, M4, M5, M6 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 >
internal::AllOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 >
internal::AllOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 >
internal::AllOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 , typename M10 >
internal::AllOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type	AllOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10)

template<typename M1 , typename M2 >
internal::AnyOfResult2< M1, M2 >::type	AnyOf (M1 m1, M2 m2)

template<typename M1 , typename M2 , typename M3 >
internal::AnyOfResult3< M1, M2, M3 >::type	AnyOf (M1 m1, M2 m2, M3 m3)

template<typename M1 , typename M2 , typename M3 , typename M4 >
internal::AnyOfResult4< M1, M2, M3, M4 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 >
internal::AnyOfResult5< M1, M2, M3, M4, M5 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 >
internal::AnyOfResult6< M1, M2, M3, M4, M5, M6 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 >
internal::AnyOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 >
internal::AnyOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 >
internal::AnyOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9)

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 , typename M10 >
internal::AnyOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type	AnyOf (M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10)

template<typename T >
Matcher< T >	MakeMatcher (const MatcherInterface< T > *impl)

template<class Impl >
PolymorphicMatcher< Impl >	MakePolymorphicMatcher (const Impl &impl)

template<typename T , typename M >
Matcher< T >	MatcherCast (const M &matcher)

template<typename T , typename M >
Matcher< T >	SafeMatcherCast (const M &polymorphic_matcher)

template<typename T >
Matcher< T >	A ()

template<typename Iter >
internal::ElementsAreArrayMatcher< typename::std::iterator_traits< Iter >::value_type >	ElementsAreArray (Iter first, Iter last)

template<typename T >
internal::ElementsAreArrayMatcher< T >	ElementsAreArray (const T *pointer, size_t count)

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

template<typename Container >
internal::ElementsAreArrayMatcher< typename Container::value_type >	ElementsAreArray (const Container &container)

template<typename Iter >
internal::UnorderedElementsAreArrayMatcher< typename::std::iterator_traits< Iter >::value_type >	UnorderedElementsAreArray (Iter first, Iter last)

template<typename T >
internal::UnorderedElementsAreArrayMatcher< T >	UnorderedElementsAreArray (const T *pointer, size_t count)

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

template<typename Container >
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type >	UnorderedElementsAreArray (const Container &container)

template<typename T >
Matcher< T >	An ()

template<typename T >
internal::EqMatcher< T >	Eq (T x)

template<typename Lhs , typename Rhs >
Matcher< Lhs >	TypedEq (const Rhs &rhs)

template<typename Rhs >
internal::GeMatcher< Rhs >	Ge (Rhs x)

template<typename Rhs >
internal::GtMatcher< Rhs >	Gt (Rhs x)

template<typename Rhs >
internal::LeMatcher< Rhs >	Le (Rhs x)

template<typename Rhs >
internal::LtMatcher< Rhs >	Lt (Rhs x)

template<typename Rhs >
internal::NeMatcher< Rhs >	Ne (Rhs x)

PolymorphicMatcher< internal::IsNullMatcher >	IsNull ()

PolymorphicMatcher< internal::NotNullMatcher >	NotNull ()

template<typename T >
internal::RefMatcher< T & >	Ref (T &x)

internal::FloatingEqMatcher< double >	DoubleEq (double rhs)

internal::FloatingEqMatcher< double >	NanSensitiveDoubleEq (double rhs)

internal::FloatingEqMatcher< double >	DoubleNear (double rhs, double max_abs_error)

internal::FloatingEqMatcher< double >	NanSensitiveDoubleNear (double rhs, double max_abs_error)

internal::FloatingEqMatcher< float >	FloatEq (float rhs)

internal::FloatingEqMatcher< float >	NanSensitiveFloatEq (float rhs)

internal::FloatingEqMatcher< float >	FloatNear (float rhs, float max_abs_error)

internal::FloatingEqMatcher< float >	NanSensitiveFloatNear (float rhs, float max_abs_error)

template<typename InnerMatcher >
internal::PointeeMatcher< InnerMatcher >	Pointee (const InnerMatcher &inner_matcher)

template<typename To >
PolymorphicMatcher< internal::WhenDynamicCastToMatcher< To > >	WhenDynamicCastTo (const Matcher< To > &inner_matcher)

template<typename Class , typename FieldType , typename FieldMatcher >
PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > >	Field (FieldType Class::*field, const FieldMatcher &matcher)

template<typename Class , typename PropertyType , typename PropertyMatcher >
PolymorphicMatcher< internal::PropertyMatcher< Class, PropertyType > >	Property (PropertyType(Class::*property)() const, const PropertyMatcher &matcher)

template<typename Callable , typename ResultOfMatcher >
internal::ResultOfMatcher< Callable >	ResultOf (Callable callable, const ResultOfMatcher &matcher)

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrEq (const internal::string &str)

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrNe (const internal::string &str)

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrCaseEq (const internal::string &str)

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrCaseNe (const internal::string &str)

PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > >	HasSubstr (const internal::string &substring)

PolymorphicMatcher< internal::StartsWithMatcher< internal::string > >	StartsWith (const internal::string &prefix)

PolymorphicMatcher< internal::EndsWithMatcher< internal::string > >	EndsWith (const internal::string &suffix)

PolymorphicMatcher< internal::MatchesRegexMatcher >	MatchesRegex (const internal::RE *regex)

PolymorphicMatcher< internal::MatchesRegexMatcher >	MatchesRegex (const internal::string &regex)

PolymorphicMatcher< internal::MatchesRegexMatcher >	ContainsRegex (const internal::RE *regex)

PolymorphicMatcher< internal::MatchesRegexMatcher >	ContainsRegex (const internal::string &regex)

internal::Eq2Matcher	Eq ()

internal::Ge2Matcher	Ge ()

internal::Gt2Matcher	Gt ()

internal::Le2Matcher	Le ()

internal::Lt2Matcher	Lt ()

internal::Ne2Matcher	Ne ()

template<typename InnerMatcher >
internal::NotMatcher< InnerMatcher >	Not (InnerMatcher m)

template<typename Predicate >
PolymorphicMatcher< internal::TrulyMatcher< Predicate > >	Truly (Predicate pred)

template<typename SizeMatcher >
internal::SizeIsMatcher< SizeMatcher >	SizeIs (const SizeMatcher &size_matcher)

template<typename DistanceMatcher >
internal::BeginEndDistanceIsMatcher< DistanceMatcher >	BeginEndDistanceIs (const DistanceMatcher &distance_matcher)

template<typename Container >
PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> >	ContainerEq (const Container &rhs)

template<typename Comparator , typename ContainerMatcher >
internal::WhenSortedByMatcher< Comparator, ContainerMatcher >	WhenSortedBy (const Comparator &comparator, const ContainerMatcher &container_matcher)

template<typename ContainerMatcher >
internal::WhenSortedByMatcher< internal::LessComparator, ContainerMatcher >	WhenSorted (const ContainerMatcher &container_matcher)

template<typename TupleMatcher , typename Container >
internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)>	Pointwise (const TupleMatcher &tuple_matcher, const Container &rhs)

template<typename Tuple2Matcher , typename RhsContainer >
internal::UnorderedElementsAreArrayMatcher< typename internal::BoundSecondMatcher< Tuple2Matcher, typename internal::StlContainerView< GTEST_REMOVE_CONST_(RhsContainer)>::type::value_type > >	UnorderedPointwise (const Tuple2Matcher &tuple2_matcher, const RhsContainer &rhs_container)

template<typename M >
internal::ContainsMatcher< M >	Contains (M matcher)

template<typename M >
internal::EachMatcher< M >	Each (M matcher)

template<typename M >
internal::KeyMatcher< M >	Key (M inner_matcher)

template<typename FirstMatcher , typename SecondMatcher >
internal::PairMatcher< FirstMatcher, SecondMatcher >	Pair (FirstMatcher first_matcher, SecondMatcher second_matcher)

template<typename M >
internal::MatcherAsPredicate< M >	Matches (M matcher)

template<typename T , typename M >
bool	Value (const T &value, M matcher)

template<typename T , typename M >
bool	ExplainMatchResult (M matcher, const T &value, MatchResultListener *listener)

template<typename InnerMatcher >
InnerMatcher	AllArgs (const InnerMatcher &matcher)

template<typename FunctionImpl >
PolymorphicAction< internal::InvokeAction< FunctionImpl > >	Invoke (FunctionImpl function_impl)

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

template<typename InnerAction >
internal::WithArgsAction< InnerAction >	WithoutArgs (const InnerAction &action)

template<int k, typename InnerAction >
internal::WithArgsAction< InnerAction, k >	WithArg (const InnerAction &action)

	ACTION_TEMPLATE (ReturnArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())

	ACTION_TEMPLATE (SaveArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(pointer))

	ACTION_TEMPLATE (SaveArgPointee, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(pointer))

	ACTION_TEMPLATE (SetArgReferee, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(value))

	ACTION_TEMPLATE (SetArrayArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_2_VALUE_PARAMS(first, last))

	ACTION_TEMPLATE (DeleteArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())

	ACTION_P (ReturnPointee, pointer)

	MATCHER (IsEmpty, negation?"isn't empty":"is empty")

template<typename T >
const T &	Const (const T &x)

	GMOCK_DECLARE_bool_ (catch_leaked_mocks)

	GMOCK_DECLARE_string_ (verbose)

GTEST_API_ void	InitGoogleMock (int argc, char *argv)

GTEST_API_ void	InitGoogleMock (int argc, wchar_t *argv)

	GMOCK_DEFINE_bool_ (catch_leaked_mocks, true,"true iff Google Mock should report leaked mock objects ""as failures.")

	GMOCK_DEFINE_string_ (verbose, internal::kWarningVerbosity,"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only.")

	GTEST_DECLARE_string_ (death_test_style)

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

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

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

	GTEST_DECLARE_bool_ (also_run_disabled_tests)

	GTEST_DECLARE_bool_ (break_on_failure)

	GTEST_DECLARE_bool_ (catch_exceptions)

	GTEST_DECLARE_string_ (color)

	GTEST_DECLARE_string_ (filter)

	GTEST_DECLARE_bool_ (list_tests)

	GTEST_DECLARE_string_ (output)

	GTEST_DECLARE_bool_ (print_time)

	GTEST_DECLARE_int32_ (random_seed)

	GTEST_DECLARE_int32_ (repeat)

	GTEST_DECLARE_bool_ (show_internal_stack_frames)

	GTEST_DECLARE_bool_ (shuffle)

	GTEST_DECLARE_int32_ (stack_trace_depth)

	GTEST_DECLARE_bool_ (throw_on_failure)

	GTEST_DECLARE_string_ (stream_result_to)

GTEST_API_ AssertionResult	AssertionSuccess ()

GTEST_API_ AssertionResult	AssertionFailure ()

GTEST_API_ AssertionResult	AssertionFailure (const Message &msg)

Environment *	AddGlobalTestEnvironment (Environment *env)

GTEST_API_ void	InitGoogleTest (int argc, char *argv)

GTEST_API_ void	InitGoogleTest (int argc, wchar_t *argv)

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 >
bool	StaticAssertTypeEq ()

	GTEST_DEFINE_string_ (death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking).")

	GTEST_DEFINE_bool_ (death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false),"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is fixed, this flag will ""most likely be removed.")

	GTEST_DECLARE_bool_ (death_test_use_fork)

static const char *	GetDefaultFilter ()

	GTEST_DEFINE_bool_ (also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false),"Run disabled tests too, in addition to the tests normally being run.")

	GTEST_DEFINE_bool_ (break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),"True iff a failed assertion should be a debugger break-point.")

	GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true),"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures.")

	GTEST_DEFINE_string_ (color, internal::StringFromGTestEnv("color","auto"),"Whether to use colors in the output. Valid values: yes, no, ""and auto. 'auto' means to use colors if the output is ""being sent to a terminal and the TERM environment variable ""is set to a terminal type that supports colors.")

	GTEST_DEFINE_string_ (filter, internal::StringFromGTestEnv("filter", GetDefaultFilter()),"A colon-separated list of glob (not regex) patterns ""for filtering the tests to run, optionally followed by a ""'-' and a : separated list of negative patterns (tests to ""exclude). A test is run if it matches one of the positive ""patterns and does not match any of the negative patterns.")

	GTEST_DEFINE_bool_ (list_tests, false,"List all tests without running them.")

	GTEST_DEFINE_string_ (output, internal::StringFromGTestEnv("output",""),"A format (currently must be \"xml\"), optionally followed ""by a colon and an output file name or directory. A directory ""is indicated by a trailing pathname separator. ""Examples: \"xml:filename.xml\", \"xml::directoryname/\". ""If a directory is specified, output files will be created ""within that directory, with file-names based on the test ""executable's name and, if necessary, made unique by adding ""digits.")

	GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true),"True iff "GTEST_NAME_" should display elapsed time in text output.")

	GTEST_DEFINE_int32_ (random_seed, internal::Int32FromGTestEnv("random_seed", 0),"Random number seed to use when shuffling test orders. Must be in range ""[1, 99999], or 0 to use a seed based on the current time.")

	GTEST_DEFINE_int32_ (repeat, internal::Int32FromGTestEnv("repeat", 1),"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests.")

	GTEST_DEFINE_bool_ (show_internal_stack_frames, false,"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces.")

	GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false),"True iff "GTEST_NAME_" should randomize tests' order on every run.")

	GTEST_DEFINE_int32_ (stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through 100, inclusive.")

	GTEST_DEFINE_string_ (stream_result_to, internal::StringFromGTestEnv("stream_result_to",""),"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux.")

	GTEST_DEFINE_bool_ (throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false),"When this flag is specified, a failed assertion will throw an exception ""if exceptions are enabled or exit the program with a non-zero code ""otherwise.")

template<int 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)

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

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	FormatTestCaseCount (int test_case_count)

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

	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_CASE_P (, CodeLocationForTESTP, Values(0))

	TYPED_TEST_CASE (CodeLocationForTYPEDTEST, int)

	TYPED_TEST (CodeLocationForTYPEDTEST, Verify)

	TYPED_TEST_CASE_P (CodeLocationForTYPEDTESTP)

	TYPED_TEST_P (CodeLocationForTYPEDTESTP, Verify)

	REGISTER_TYPED_TEST_CASE_P (CodeLocationForTYPEDTESTP, Verify)

	INSTANTIATE_TYPED_TEST_CASE_P (My, CodeLocationForTYPEDTESTP, int)

	TEST_F (SetUpTestCaseTest, Test1)

	TEST_F (SetUpTestCaseTest, Test2)

	TEST_F (InitGoogleTestTest, Empty)

	TEST_F (InitGoogleTestTest, NoFlag)

	TEST_F (InitGoogleTestTest, FilterBad)

	TEST_F (InitGoogleTestTest, FilterEmpty)

	TEST_F (InitGoogleTestTest, FilterNonEmpty)

	TEST_F (InitGoogleTestTest, BreakOnFailureWithoutValue)

	TEST_F (InitGoogleTestTest, BreakOnFailureFalse_0)

	TEST_F (InitGoogleTestTest, BreakOnFailureFalse_f)

	TEST_F (InitGoogleTestTest, BreakOnFailureFalse_F)

	TEST_F (InitGoogleTestTest, BreakOnFailureTrue)

	TEST_F (InitGoogleTestTest, CatchExceptions)

	TEST_F (InitGoogleTestTest, DeathTestUseFork)

	TEST_F (InitGoogleTestTest, DuplicatedFlags)

	TEST_F (InitGoogleTestTest, UnrecognizedFlag)

	TEST_F (InitGoogleTestTest, ListTestsFlag)

	TEST_F (InitGoogleTestTest, ListTestsTrue)

	TEST_F (InitGoogleTestTest, ListTestsFalse)

	TEST_F (InitGoogleTestTest, ListTestsFalse_f)

	TEST_F (InitGoogleTestTest, ListTestsFalse_F)

	TEST_F (InitGoogleTestTest, OutputEmpty)

	TEST_F (InitGoogleTestTest, OutputXml)

	TEST_F (InitGoogleTestTest, OutputXmlFile)

	TEST_F (InitGoogleTestTest, OutputXmlDirectory)

	TEST_F (InitGoogleTestTest, PrintTimeFlag)

	TEST_F (InitGoogleTestTest, PrintTimeTrue)

	TEST_F (InitGoogleTestTest, PrintTimeFalse)

	TEST_F (InitGoogleTestTest, PrintTimeFalse_f)

	TEST_F (InitGoogleTestTest, PrintTimeFalse_F)

	TEST_F (InitGoogleTestTest, RandomSeed)

	TEST_F (InitGoogleTestTest, Repeat)

	TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsFlag)

	TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsTrue)

	TEST_F (InitGoogleTestTest, AlsoRunDisabledTestsFalse)

	TEST_F (InitGoogleTestTest, ShuffleWithoutValue)

	TEST_F (InitGoogleTestTest, ShuffleFalse_0)

	TEST_F (InitGoogleTestTest, ShuffleTrue)

	TEST_F (InitGoogleTestTest, StackTraceDepth)

	TEST_F (InitGoogleTestTest, StreamResultTo)

	TEST_F (InitGoogleTestTest, ThrowOnFailureWithoutValue)

	TEST_F (InitGoogleTestTest, ThrowOnFailureFalse_0)

	TEST_F (InitGoogleTestTest, ThrowOnFailureTrue)

	TEST_F (CurrentTestInfoTest, WorksForFirstTestInATestCase)

	TEST_F (CurrentTestInfoTest, WorksForSecondTestInATestCase)

static const char *	GetDefaultFilter ()

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

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

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	FormatTestCaseCount (int test_case_count)

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

static const char *	GetDefaultFilter ()

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

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

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	FormatTestCaseCount (int test_case_count)

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

Variables
	p0_type

	p1_type

	p2_type

	p3_type

	p4_type

	p5_type

	p6_type

	p7_type

	p8_type

const internal::AnythingMatcher	_ = {}

class GTEST_API_ testing::InSequence	GTEST_ATTRIBUTE_UNUSED_

const int	kMaxStackTraceDepth = 100

static const char	kDefaultDeathTestStyle [] = "fast"

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

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

static const char	kUniversalFilter [] = "*"

static const char	kDefaultOutputFile [] = "test_detail.xml"

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	kDefaultDeathTestStyle [] = "fast"

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

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

static const char	kUniversalFilter [] = "*"

static const char	kDefaultOutputFile [] = "test_detail.xml"

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	kDefaultDeathTestStyle [] = "fast"

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

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

static const char	kUniversalFilter [] = "*"

static const char	kDefaultOutputFile [] = "test_detail.xml"

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 []

Typedef Documentation

typedef internal::TimeInMillis testing::TimeInMillis

Definition at line 480 of file gtest.h.

typedef internal::IgnoredValue testing::Unused

Definition at line 1046 of file gmock-actions.h.

Function Documentation

template<typename T >

Matcher< T > testing::A ( )

inline

Definition at line 3732 of file gmock-matchers.h.

References MakeMatcher().

Referenced by testing::SafeMatcherCastImpl< T >::Cast(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::internal::SetArgumentPointeeAction< N, A, kIsProto >::Perform(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), and SafeMatcherCast().

3732 { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }

testing::MakeMatcher

Matcher< T > MakeMatcher(const MatcherInterface< T > *impl)

Definition: gmock-matchers.h:484

testing::ACTION_P	(	ReturnPointee	,
		pointer
	)

Definition at line 222 of file gmock-more-actions.h.

Referenced by testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform().

222 { return *pointer; }

testing::ACTION_TEMPLATE	(	ReturnArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

Definition at line 161 of file gmock-more-actions.h.

Referenced by GTEST_CONCAT_TOKEN_(), InvokeArgument(), testing::internal::invoke_argument::InvokeArgumentAdl(), testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform(), and ReturnNew().

                                       {
   return ::testing::get<k>(args);
 }

testing::ACTION_TEMPLATE	(	SaveArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(pointer)
	)

Definition at line 169 of file gmock-more-actions.h.

                                              {
   *pointer = ::testing::get<k>(args);
 }

testing::ACTION_TEMPLATE	(	SaveArgPointee	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(pointer)
	)

Definition at line 177 of file gmock-more-actions.h.

                                              {
   *pointer = *::testing::get<k>(args);
 }

testing::ACTION_TEMPLATE	(	SetArgReferee	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(value)
	)

Definition at line 185 of file gmock-more-actions.h.

References GTEST_COMPILE_ASSERT_, type, and value.

                                            {
   typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
   // Ensures that argument #k is a reference.  If you get a compiler
   // error on the next line, you are using SetArgReferee<k>(value) in
   // a mock function whose k-th (0-based) argument is not a reference.
   GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
                         SetArgReferee_must_be_used_with_a_reference_argument);
   ::testing::get<k>(args) = value;
 }

testing::ACTION_TEMPLATE	(	SetArrayArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_2_VALUE_PARAMS(first, last)
	)

Definition at line 202 of file gmock-more-actions.h.

References folly::copy(), testing::internal::CopyElements(), and folly::gen::first.

                                                  {
   // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
 #ifdef _MSC_VER
   internal::CopyElements(first, last, ::testing::get<k>(args));
 #else
   ::std::copy(first, last, ::testing::get<k>(args));
 #endif
 }

testing::ACTION_TEMPLATE	(	DeleteArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

Definition at line 215 of file gmock-more-actions.h.

                                       {
   delete ::testing::get<k>(args);
 }

Environment * testing::AddGlobalTestEnvironment ( Environment * env )

inline

Definition at line 1350 of file gtest.h.

References testing::UnitTest::AddEnvironment(), argv, testing::UnitTest::GetInstance(), GTEST_API_, and InitGoogleTest().

Referenced by testing::UnitTest::impl(), and main().

                                                                {
   return UnitTest::GetInstance()->AddEnvironment(env);
 }

template<typename InnerMatcher >

InnerMatcher testing::AllArgs ( const InnerMatcher & matcher )

inline

Definition at line 4382 of file gmock-matchers.h.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), and testing::gmock_matchers_test::TEST().

4382 { return matcher; }

template<typename M1 , typename M2 >

internal::AllOfResult2< M1, M2 >::type testing::AllOf	(	M1	m1,
		M2	m2
	)

inline

Definition at line 1002 of file gmock-generated-matchers.h.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), AllOf(), testing::gmock_matchers_test::DivisibleByImpl::divider(), ExplainMatchResult(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), and testing::gmock_matchers_test::TEST().

                     {
   return typename internal::AllOfResult2<M1, M2>::type(
       m1,
       m2);
 }

template<typename M1 , typename M2 , typename M3 >

internal::AllOfResult3< M1, M2, M3 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3
	)

inline

Definition at line 1010 of file gmock-generated-matchers.h.

References AllOf().

                            {
   return typename internal::AllOfResult3<M1, M2, M3>::type(
       m1,
       ::testing::AllOf(m2, m3));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 >

internal::AllOfResult4< M1, M2, M3, M4 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4
	)

inline

Definition at line 1018 of file gmock-generated-matchers.h.

References AllOf().

                                   {
   return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
       ::testing::AllOf(m1, m2),
       ::testing::AllOf(m3, m4));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 >

internal::AllOfResult5< M1, M2, M3, M4, M5 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5
	)

inline

Definition at line 1026 of file gmock-generated-matchers.h.

References AllOf().

                                          {
   return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
       ::testing::AllOf(m1, m2),
       ::testing::AllOf(m3, m4, m5));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 >

internal::AllOfResult6< M1, M2, M3, M4, M5, M6 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6
	)

inline

Definition at line 1035 of file gmock-generated-matchers.h.

References AllOf().

                                                 {
   return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
       ::testing::AllOf(m1, m2, m3),
       ::testing::AllOf(m4, m5, m6));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 >

internal::AllOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7
	)

inline

Definition at line 1044 of file gmock-generated-matchers.h.

References AllOf().

                                                        {
   return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
       ::testing::AllOf(m1, m2, m3),
       ::testing::AllOf(m4, m5, m6, m7));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 >

internal::AllOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8
	)

inline

Definition at line 1053 of file gmock-generated-matchers.h.

References AllOf().

                                                               {
   return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
       ::testing::AllOf(m1, m2, m3, m4),
       ::testing::AllOf(m5, m6, m7, m8));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 >

internal::AllOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8,
		M9	m9
	)

inline

Definition at line 1062 of file gmock-generated-matchers.h.

References AllOf().

                                                                      {
   return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
       M9>::type(
       ::testing::AllOf(m1, m2, m3, m4),
       ::testing::AllOf(m5, m6, m7, m8, m9));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 , typename M10 >

internal::AllOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type testing::AllOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8,
		M9	m9,
		M10	m10
	)

inline

Definition at line 1073 of file gmock-generated-matchers.h.

References AllOf().

                                                                               {
   return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
       M10>::type(
       ::testing::AllOf(m1, m2, m3, m4, m5),
       ::testing::AllOf(m6, m7, m8, m9, m10));
 }

template<typename T >

Matcher< T > testing::An ( )

inline

Definition at line 3736 of file gmock-matchers.h.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain().

3736 { return A<T>(); }

GTEST_API_ Cardinality testing::AnyNumber ( )

Definition at line 146 of file gmock-cardinalities.cc.

References AtLeast().

Referenced by testing::Cardinality::DescribeTo(), testing::gmock_generated_function_mockers_test::MockStack< T >::MockStack(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_generated_function_mockers_test::TEST(), and TEST_F().

146 { return AtLeast(0); }

testing::AtLeast

GTEST_API_ Cardinality AtLeast(int n)

Definition: gmock-cardinalities.cc:140

template<typename M1 , typename M2 >

internal::AnyOfResult2< M1, M2 >::type testing::AnyOf	(	M1	m1,
		M2	m2
	)

inline

Definition at line 1085 of file gmock-generated-matchers.h.

Referenced by AnyOf(), testing::gmock_matchers_test::EMString(), ExplainMatchResult(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::NotCopyable::operator>=(), TEST(), testing::gmock_matchers_test::TEST(), proxygen::TEST_F(), and testing::gmock_matchers_test::TEST_F().

                     {
   return typename internal::AnyOfResult2<M1, M2>::type(
       m1,
       m2);
 }

template<typename M1 , typename M2 , typename M3 >

internal::AnyOfResult3< M1, M2, M3 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3
	)

inline

Definition at line 1093 of file gmock-generated-matchers.h.

References AnyOf().

                            {
   return typename internal::AnyOfResult3<M1, M2, M3>::type(
       m1,
       ::testing::AnyOf(m2, m3));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 >

internal::AnyOfResult4< M1, M2, M3, M4 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4
	)

inline

Definition at line 1101 of file gmock-generated-matchers.h.

References AnyOf().

                                   {
   return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
       ::testing::AnyOf(m1, m2),
       ::testing::AnyOf(m3, m4));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 >

internal::AnyOfResult5< M1, M2, M3, M4, M5 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5
	)

inline

Definition at line 1109 of file gmock-generated-matchers.h.

References AnyOf().

                                          {
   return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
       ::testing::AnyOf(m1, m2),
       ::testing::AnyOf(m3, m4, m5));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 >

internal::AnyOfResult6< M1, M2, M3, M4, M5, M6 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6
	)

inline

Definition at line 1118 of file gmock-generated-matchers.h.

References AnyOf().

                                                 {
   return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
       ::testing::AnyOf(m1, m2, m3),
       ::testing::AnyOf(m4, m5, m6));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 >

internal::AnyOfResult7< M1, M2, M3, M4, M5, M6, M7 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7
	)

inline

Definition at line 1127 of file gmock-generated-matchers.h.

References AnyOf().

                                                        {
   return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
       ::testing::AnyOf(m1, m2, m3),
       ::testing::AnyOf(m4, m5, m6, m7));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 >

internal::AnyOfResult8< M1, M2, M3, M4, M5, M6, M7, M8 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8
	)

inline

Definition at line 1136 of file gmock-generated-matchers.h.

References AnyOf().

                                                               {
   return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
       ::testing::AnyOf(m1, m2, m3, m4),
       ::testing::AnyOf(m5, m6, m7, m8));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 >

internal::AnyOfResult9< M1, M2, M3, M4, M5, M6, M7, M8, M9 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8,
		M9	m9
	)

inline

Definition at line 1145 of file gmock-generated-matchers.h.

References AnyOf().

                                                                      {
   return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
       M9>::type(
       ::testing::AnyOf(m1, m2, m3, m4),
       ::testing::AnyOf(m5, m6, m7, m8, m9));
 }

template<typename M1 , typename M2 , typename M3 , typename M4 , typename M5 , typename M6 , typename M7 , typename M8 , typename M9 , typename M10 >

internal::AnyOfResult10< M1, M2, M3, M4, M5, M6, M7, M8, M9, M10 >::type testing::AnyOf	(	M1	m1,
		M2	m2,
		M3	m3,
		M4	m4,
		M5	m5,
		M6	m6,
		M7	m7,
		M8	m8,
		M9	m9,
		M10	m10
	)

inline

Definition at line 1156 of file gmock-generated-matchers.h.

References AnyOf().

                                                                               {
   return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
       M10>::type(
       ::testing::AnyOf(m1, m2, m3, m4, m5),
       ::testing::AnyOf(m6, m7, m8, m9, m10));
 }

template<typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher > testing::Args ( const InnerMatcher & matcher )

inline

Examples:: /facebook/proxygen/proxygen/folly/folly/container/Iterator.h, and /facebook/proxygen/proxygen/folly/folly/lang/RValueReferenceWrapper.h.

Definition at line 481 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher>(matcher);
 }

template<int k1, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 487 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
 }

template<int k1, int k2, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 493 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
 }

template<int k1, int k2, int k3, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 499 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
 }

template<int k1, int k2, int k3, int k4, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 505 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 511 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 517 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 524 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
       k7>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 532 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
       k8>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 540 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
       k9>(matcher);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, int k10, typename InnerMatcher >

internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > testing::Args ( const InnerMatcher & matcher )

inline

Definition at line 549 of file gmock-generated-matchers.h.

                                   {
   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
       k9, k10>(matcher);
 }

template<int kSize>

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

Definition at line 2108 of file gtest.cc.

Referenced by GetReservedAttributesForElement().

                                                                       {
   return std::vector<std::string>(array, array + kSize);
 }

AssertionResult testing::AssertionFailure ( )

Definition at line 1015 of file gtest.cc.

References testing::AssertionResult::AssertionResult().

                                    {
   return AssertionResult(false);
 }

AssertionResult testing::AssertionFailure ( const Message & msg )

Definition at line 1021 of file gtest.cc.

References AssertionFailure(), and testing::AssertionResult::message().

                                                          {
   return AssertionFailure() << message;
 }

AssertionResult testing::AssertionSuccess ( )

Definition at line 1010 of file gtest.cc.

References testing::AssertionResult::AssertionResult().

                                    {
   return AssertionResult(true);
 }

template<typename T1 , typename T2 >

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

Definition at line 1147 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by HTTPUpstreamTest< SPDY3CodecPair >::commonSetUp(), HTTP2UpstreamSessionWithVirtualNodesTest::commonSetUp(), MockCodecDownstreamTest::MockCodecDownstreamTest(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), TEST(), TEST_F(), and MockCodecDownstreamTest::testGoaway().

                                                                          {
   return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
 }

GTEST_API_ Cardinality testing::AtLeast ( int n )

Definition at line 140 of file gmock-cardinalities.cc.

References Between().

Referenced by AnyNumber(), testing::Cardinality::DescribeTo(), TestAbortPost< stage >::doAbortTest(), testing::internal::ExpectationTester::SetCallCount(), TEST(), fizz::server::test::TEST_F(), fizz::client::test::TEST_F(), TEST_F(), MockCodecDownstreamTest::testGoaway(), TYPED_TEST(), and testing::internal::TypedExpectation< F >::WillRepeatedly().

140 { return Between(n, INT_MAX); }

testing::Between

GTEST_API_ Cardinality Between(int min, int max)

Definition: gmock-cardinalities.cc:149

GTEST_API_ Cardinality testing::AtMost ( int n )

Definition at line 143 of file gmock-cardinalities.cc.

References Between().

Referenced by testing::Cardinality::DescribeTo(), testing::internal::ExpectationTester::SetCallCount(), folly::TEST(), and TEST_F().

143 { return Between(0, n); }

testing::Between

GTEST_API_ Cardinality Between(int min, int max)

Definition: gmock-cardinalities.cc:149

template<typename DistanceMatcher >

internal::BeginEndDistanceIsMatcher< DistanceMatcher > testing::BeginEndDistanceIs ( const DistanceMatcher & distance_matcher )

inline

Definition at line 4139 of file gmock-matchers.h.

References GTEST_REMOVE_CONST_.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::gmock_matchers_test::TEST().

                                                             {
   return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
 }

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

Definition at line 149 of file gmock-cardinalities.cc.

Referenced by AtLeast(), AtMost(), testing::Cardinality::DescribeTo(), Exactly(), and testing::internal::ExpectationTester::SetCallCount().

                                                  {
   return Cardinality(new BetweenCardinalityImpl(min, max));
 }

template<typename R >

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

Definition at line 1094 of file gmock-actions.h.

References testing::internal::move().

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform().

                                      {
   return internal::ByMoveWrapper<R>(internal::move(x));
 }

template<typename T >

internal::ReferenceWrapper< T > testing::ByRef ( T & l_value )

inline

Definition at line 1199 of file gmock-actions.h.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_matchers_test::NotCopyable::operator>=(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), testing::gmock_generated_actions_test::TEST(), and testing::gmock_matchers_test::TEST().

                                                      {  // NOLINT
   return internal::ReferenceWrapper<T>(l_value);
 }

template<typename T >

const T & testing::Const ( const T & x )

inline

Definition at line 1826 of file gmock-spec-builders.h.

References x.

Referenced by testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), testing::internal::FunctionMockerBase< R(A1, A2)>::PrintTriedExpectationsLocked(), testing::internal::ExpectationTester::SetCallCount(), and testing::gmock_generated_function_mockers_test::TEST_F().

1826 { return x; }

const int x

Definition: OptionalTest.cpp:770

template<typename Container >

PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> > testing::ContainerEq ( const Container & rhs )

inline

Definition at line 4150 of file gmock-matchers.h.

References GTEST_REMOVE_CONST_, and MakePolymorphicMatcher().

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::NotCopyable::operator>=(), TEST(), and testing::gmock_matchers_test::TEST().

                                       {
   // This following line is for working around a bug in MSVC 8.0,
   // which causes Container to be a const type sometimes.
   typedef GTEST_REMOVE_CONST_(Container) RawContainer;
   return MakePolymorphicMatcher(
       internal::ContainerEqMatcher<RawContainer>(rhs));
 }

template<typename M >

internal::ContainsMatcher< M > testing::Contains ( M matcher )

inline

Definition at line 4282 of file gmock-matchers.h.

Referenced by folly::gen::appendTo(), folly::gen::contains(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::gmock_matchers_test::TEST().

                                                       {
   return internal::ContainsMatcher<M>(matcher);
 }

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::ContainsRegex ( const internal::RE * regex )

inline

Definition at line 4016 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by ContainsRegex(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::internal::ExpectationTester::SetCallCount(), TEST(), and testing::gmock_matchers_test::TEST().

                              {
   return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
 }

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::ContainsRegex ( const internal::string & regex )

inline

Definition at line 4020 of file gmock-matchers.h.

References ContainsRegex(), EndsWith(), HasSubstr(), MakePolymorphicMatcher(), prefix(), StartsWith(), StrCaseEq(), StrCaseNe(), StrEq(), StrNe(), and suffix.

                                  {
   return ContainsRegex(new internal::RE(regex));
 }

template<typename Action1 , typename Action2 >

internal::DoBothAction< Action1, Action2 > testing::DoAll	(	Action1	a1,
		Action2	a2
	)

inline

Definition at line 696 of file gmock-generated-actions.h.

Referenced by DoAll(), ZlibServerFilterTest::exercise_compression(), fizz::test::AsyncFizzBaseTest::expectReadBufRequest(), testing::gmock_generated_actions_test::SubstractAction::Perform(), testing::internal::ActionHelper< Result, Impl >::Perform(), testing::internal::ExpectationTester::SetCallCount(), TEST(), testing::gmock_generated_actions_test::TEST(), TEST_F(), fizz::test::TEST_F(), and MockCodecDownstreamTest::testGoaway().

                               {
   return internal::DoBothAction<Action1, Action2>(a1, a2);
 }

template<typename Action1 , typename Action2 , typename Action3 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, Action3 > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3
	)

inline

Definition at line 703 of file gmock-generated-actions.h.

References DoAll().

                                           {
   return DoAll(a1, DoAll(a2, a3));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, Action4 > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4
	)

inline

Definition at line 711 of file gmock-generated-actions.h.

References DoAll().

                                                       {
   return DoAll(a1, DoAll(a2, a3, a4));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, Action5 > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5
	)

inline

Definition at line 720 of file gmock-generated-actions.h.

References DoAll().

                                                                   {
   return DoAll(a1, DoAll(a2, a3, a4, a5));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, Action6 > > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5,
		Action6	a6
	)

inline

Definition at line 729 of file gmock-generated-actions.h.

References DoAll().

                                                                               {
   return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, Action7 > > > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5,
		Action6	a6,
		Action7	a7
	)

inline

Definition at line 739 of file gmock-generated-actions.h.

References DoAll().

                 {
   return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, Action8 > > > > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5,
		Action6	a6,
		Action7	a7,
		Action8	a8
	)

inline

Definition at line 751 of file gmock-generated-actions.h.

References DoAll().

                             {
   return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 , typename Action9 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, internal::DoBothAction< Action8, Action9 > > > > > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5,
		Action6	a6,
		Action7	a7,
		Action8	a8,
		Action9	a9
	)

inline

Definition at line 764 of file gmock-generated-actions.h.

References DoAll().

                                         {
   return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
 }

template<typename Action1 , typename Action2 , typename Action3 , typename Action4 , typename Action5 , typename Action6 , typename Action7 , typename Action8 , typename Action9 , typename Action10 >

internal::DoBothAction< Action1, internal::DoBothAction< Action2, internal::DoBothAction< Action3, internal::DoBothAction< Action4, internal::DoBothAction< Action5, internal::DoBothAction< Action6, internal::DoBothAction< Action7, internal::DoBothAction< Action8, internal::DoBothAction< Action9, Action10 > > > > > > > > > testing::DoAll	(	Action1	a1,
		Action2	a2,
		Action3	a3,
		Action4	a4,
		Action5	a5,
		Action6	a6,
		Action7	a7,
		Action8	a8,
		Action9	a9,
		Action10	a10
	)

inline

Definition at line 777 of file gmock-generated-actions.h.

References DoAll().

                                                       {
   return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
 }

internal::DoDefaultAction testing::DoDefault ( )

inline

Definition at line 1099 of file gmock-actions.h.

References T.

Referenced by testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), testing::internal::ExpectationTester::SetCallCount(), DownstreamTransactionTest::setupRequestResponseFlow(), TEST(), and testing::gmock_generated_function_mockers_test::TEST_F().

                                            {
   return internal::DoDefaultAction();
 }

internal::FloatingEqMatcher< double > testing::DoubleEq ( double rhs )

inline

Definition at line 3815 of file gmock-matchers.h.

References folly::detail::rhs.

Referenced by testing::gmock_matchers_test::Derived::Derived(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), testing::gmock_matchers_test::TEST(), testing::gmock_matchers_test::TEST_F(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                                               {
   return internal::FloatingEqMatcher<double>(rhs, false);
 }

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

Definition at line 1428 of file gtest.cc.

Referenced by testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                    {
   return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
 }

internal::FloatingEqMatcher< double > testing::DoubleNear	(	double	rhs,
		double	max_abs_error
	)

inline

Definition at line 3828 of file gmock-matchers.h.

References folly::detail::rhs.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::TEST_F(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                       {
   return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
 }

template<typename M >

internal::EachMatcher< M > testing::Each ( M matcher )

inline

Definition at line 4314 of file gmock-matchers.h.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::gmock_matchers_test::TEST().

                                               {
   return internal::EachMatcher<M>(matcher);
 }

internal::ElementsAreMatcher<::testing::tuple<> > testing::ElementsAre ( )

inline

Definition at line 570 of file gmock-generated-matchers.h.

References Args().

Referenced by testing::gmock_matchers_test::NotCopyable::operator>=(), folly::TEST(), TEST(), testing::gmock_matchers_test::TEST(), TEST_F(), fizz::server::test::TEST_F(), and testing::gmock_matchers_test::TEST_F().

               {
   typedef ::testing::tuple<> Args;
   return internal::ElementsAreMatcher<Args>(Args());
 }

template<typename T1 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type> > testing::ElementsAre ( const T1 & e1 )

inline

Definition at line 579 of file gmock-generated-matchers.h.

References Args().

                           {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1));
 }

template<typename T1 , typename T2 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2
	)

inline

Definition at line 590 of file gmock-generated-matchers.h.

References Args().

                                         {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2));
 }

template<typename T1 , typename T2 , typename T3 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3
	)

inline

Definition at line 603 of file gmock-generated-matchers.h.

References Args().

                                                       {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
 }

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

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4
	)

inline

Definition at line 618 of file gmock-generated-matchers.h.

References Args().

                                                                     {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
 }

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

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5
	)

inline

Definition at line 635 of file gmock-generated-matchers.h.

References Args().

                   {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
 }

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

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6
	)

inline

Definition at line 656 of file gmock-generated-matchers.h.

References Args().

                                 {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7
	)

inline

Definition at line 679 of file gmock-generated-matchers.h.

References Args().

                                               {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8
	)

inline

Definition at line 704 of file gmock-generated-matchers.h.

References Args().

                                                             {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
       e8));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type, typename internal::DecayArray<T9>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8,
		const T9 &	e9
	)

inline

Definition at line 732 of file gmock-generated-matchers.h.

References Args().

                                                                           {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type,
       typename internal::DecayArray<T9>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
       e8, e9));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >

internal::ElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type, typename internal::DecayArray<T9>::type, typename internal::DecayArray<T10>::type> > testing::ElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8,
		const T9 &	e9,
		const T10 &	e10
	)

inline

Definition at line 762 of file gmock-generated-matchers.h.

References Args().

                     {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type,
       typename internal::DecayArray<T9>::type,
       typename internal::DecayArray<T10>::type> Args;
   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
       e8, e9, e10));
 }

template<typename Iter >

internal::ElementsAreArrayMatcher< typename::std::iterator_traits< Iter >::value_type > testing::ElementsAreArray	(	Iter	first,
		Iter	last
	)

inline

Definition at line 3646 of file gmock-matchers.h.

References folly::gen::first, and T.

Referenced by ElementsAreArray(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::NotCopyable::operator>=(), TEST(), testing::gmock_matchers_test::TEST(), and TEST_F().

                                         {
   typedef typename ::std::iterator_traits<Iter>::value_type T;
   return internal::ElementsAreArrayMatcher<T>(first, last);
 }

template<typename T >

internal::ElementsAreArrayMatcher< T > testing::ElementsAreArray	(	const T *	pointer,
		size_t	count
	)

inline

Definition at line 3652 of file gmock-matchers.h.

References ElementsAreArray().

                                     {
   return ElementsAreArray(pointer, pointer + count);
 }

template<typename T , size_t N>

internal::ElementsAreArrayMatcher< T > testing::ElementsAreArray ( const T(&) array[N] )

inline

Definition at line 3658 of file gmock-matchers.h.

References ElementsAreArray().

                          {
   return ElementsAreArray(array, N);
 }

template<typename Container >

internal::ElementsAreArrayMatcher< typename Container::value_type > testing::ElementsAreArray ( const Container & container )

inline

Definition at line 3665 of file gmock-matchers.h.

References ElementsAreArray().

                                              {
   return ElementsAreArray(container.begin(), container.end());
 }

PolymorphicMatcher< internal::EndsWithMatcher< internal::string > > testing::EndsWith ( const internal::string & suffix )

inline

Definition at line 3998 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), ContainsRegex(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), and testing::gmock_matchers_test::TEST().

                                            {
   return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
       suffix));
 }

template<typename T >

internal::EqMatcher< T > testing::Eq ( T x )

inline

Definition at line 3742 of file gmock-matchers.h.

References x.

3742 { return internal::EqMatcher<T>(x); }

const int x

Definition: OptionalTest.cpp:770

internal::Eq2Matcher testing::Eq ( )

inline

Definition at line 4082 of file gmock-matchers.h.

4082 { return internal::Eq2Matcher(); }

GTEST_API_ Cardinality testing::Exactly ( int n )

Definition at line 154 of file gmock-cardinalities.cc.

References Between().

Referenced by testing::Cardinality::DescribeTo(), testing::internal::TypedExpectation< F >::Times(), and testing::internal::TypedExpectation< F >::WillOnce().

154 { return Between(n, n); }

testing::Between

GTEST_API_ Cardinality Between(int min, int max)

Definition: gmock-cardinalities.cc:149

template<typename T , typename M >

bool testing::ExplainMatchResult	(	M	matcher,
		const T &	value,
		MatchResultListener *	listener
	)

inline

Definition at line 4354 of file gmock-matchers.h.

References AllOf(), AnyOf(), and Args().

                                                               {
   return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
 }

template<typename Class , typename FieldType , typename FieldMatcher >

PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > > testing::Field	(	FieldType Class::*	field,
		const FieldMatcher &	matcher
	)

inline

Definition at line 3896 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::AStruct::AStruct(), std::tr1::gtest_internal::Get< 9 >::ConstField(), folly::gen::field(), std::tr1::get(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), and testing::gmock_matchers_test::TEST().

                                                         {
   return MakePolymorphicMatcher(
       internal::FieldMatcher<Class, FieldType>(
           field, MatcherCast<const FieldType&>(matcher)));
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   Field(&Foo::bar, m)
   // to compile where bar is an int32 and m is a matcher for int64.
 }

internal::FloatingEqMatcher< float > testing::FloatEq ( float rhs )

inline

Definition at line 3843 of file gmock-matchers.h.

References folly::detail::rhs.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), testing::gmock_matchers_test::TEST_F(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                                            {
   return internal::FloatingEqMatcher<float>(rhs, false);
 }

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

Definition at line 1421 of file gtest.cc.

Referenced by testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                 {
   return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
 }

internal::FloatingEqMatcher< float > testing::FloatNear	(	float	rhs,
		float	max_abs_error
	)

inline

Definition at line 3856 of file gmock-matchers.h.

References folly::detail::rhs.

                                     {
   return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
 }

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

static

Definition at line 2809 of file gtest.cc.

References testing::internal::StreamableToString().

Referenced by FormatTestCaseCount(), FormatTestCount(), testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(), and testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd().

                                                                  {
   return internal::StreamableToString(count) + " " +
       (count == 1 ? singular_form : plural_form);
 }

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

static

Definition at line 2809 of file gtest.cc.

References testing::internal::StreamableToString().

                                                                  {
   return internal::StreamableToString(count) + " " +
       (count == 1 ? singular_form : plural_form);
 }

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

static

Definition at line 2809 of file gtest.cc.

References testing::internal::StreamableToString().

                                                                  {
   return internal::StreamableToString(count) + " " +
       (count == 1 ? singular_form : plural_form);
 }

static std::string testing::FormatTestCaseCount ( int test_case_count )

static

Definition at line 2822 of file gtest.cc.

References FormatCountableNoun().

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(), and testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd().

                                                           {
   return FormatCountableNoun(test_case_count, "test case", "test cases");
 }

static std::string testing::FormatTestCaseCount ( int test_case_count )

static

Definition at line 2822 of file gtest.cc.

References FormatCountableNoun().

                                                           {
   return FormatCountableNoun(test_case_count, "test case", "test cases");
 }

static std::string testing::FormatTestCaseCount ( int test_case_count )

static

Definition at line 2822 of file gtest.cc.

References FormatCountableNoun().

                                                           {
   return FormatCountableNoun(test_case_count, "test case", "test cases");
 }

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

static

Definition at line 2817 of file gtest.cc.

References FormatCountableNoun().

                                                  {
   return FormatCountableNoun(test_count, "test", "tests");
 }

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

static

Definition at line 2817 of file gtest.cc.

References FormatCountableNoun().

                                                  {
   return FormatCountableNoun(test_count, "test", "tests");
 }

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

static

Definition at line 2817 of file gtest.cc.

References FormatCountableNoun().

                                                  {
   return FormatCountableNoun(test_count, "test", "tests");
 }

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

static

Definition at line 2127 of file gtest.cc.

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

Referenced by FormatWordList(), and ValidateTestPropertyName().

                                                                    {
   Message word_list;
   for (size_t i = 0; i < words.size(); ++i) {
     if (i > 0 && words.size() > 2) {
       word_list << ", ";
     }
     if (i == words.size() - 1) {
       word_list << "and ";
     }
     word_list << "'" << words[i] << "'";
   }
   return word_list.GetString();
 }

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

static

Definition at line 2127 of file gtest.cc.

References ADD_FAILURE, testing::TestResult::Clear(), testing::TestResult::Failed(), FormatWordList(), GetReservedAttributesForElement(), testing::Message::GetString(), GTEST_NAME_, i, testing::TestProperty::key(), string, testing::TestResult::ValidateTestProperty(), and ValidateTestPropertyName().

                                                                    {
   Message word_list;
   for (size_t i = 0; i < words.size(); ++i) {
     if (i > 0 && words.size() > 2) {
       word_list << ", ";
     }
     if (i == words.size() - 1) {
       word_list << "and ";
     }
     word_list << "'" << words[i] << "'";
   }
   return word_list.GetString();
 }

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

static

Definition at line 2127 of file gtest.cc.

                                                                    {
   Message word_list;
   for (size_t i = 0; i < words.size(); ++i) {
     if (i > 0 && words.size() > 2) {
       word_list << ", ";
     }
     if (i == words.size() - 1) {
       word_list << "and ";
     }
     word_list << "'" << words[i] << "'";
   }
   return word_list.GetString();
 }

template<typename Rhs >

internal::GeMatcher< Rhs > testing::Ge ( Rhs x )

inline

Definition at line 3766 of file gmock-matchers.h.

References x.

                                         {
   return internal::GeMatcher<Rhs>(x);
 }

internal::Ge2Matcher testing::Ge ( )

inline

Definition at line 4086 of file gmock-matchers.h.

4086 { return internal::Ge2Matcher(); }

static const char* testing::GetDefaultFilter ( )

static

Definition at line 192 of file gtest.cc.

References testing::internal::BoolFromGTestEnv(), folly::pushmi::operators::filter, GTEST_DEFINE_bool_(), GTEST_DEFINE_int32_(), testing::internal::GTEST_DEFINE_string_(), GTEST_NAME_, testing::internal::Int32FromGTestEnv(), kMaxStackTraceDepth, kUniversalFilter, gmock_output_test::output, repeat(), and testing::internal::StringFromGTestEnv().

Referenced by GetDefaultFilter().

                                       {
 #ifdef GTEST_TEST_FILTER_ENV_VAR_
   const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
   if (testbridge_test_only != NULL) {
     return testbridge_test_only;
   }
 #endif  // GTEST_TEST_FILTER_ENV_VAR_
   return kUniversalFilter;
 }

static const char* testing::GetDefaultFilter ( )

static

Definition at line 192 of file gtest.cc.

References testing::internal::BoolFromGTestEnv(), folly::pushmi::operators::filter, testing::internal::Random::Generate(), GetDefaultFilter(), GTEST_CHECK_, GTEST_DEFINE_bool_(), GTEST_DEFINE_int32_(), testing::internal::GTEST_DEFINE_string_(), GTEST_NAME_, testing::internal::Int32FromGTestEnv(), kMaxStackTraceDepth, kUniversalFilter, gmock_output_test::output, folly::gen::range(), repeat(), and testing::internal::StringFromGTestEnv().

                                       {
 #ifdef GTEST_TEST_FILTER_ENV_VAR_
   const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
   if (testbridge_test_only != NULL) {
     return testbridge_test_only;
   }
 #endif  // GTEST_TEST_FILTER_ENV_VAR_
   return kUniversalFilter;
 }

static const char* testing::GetDefaultFilter ( )

static

Definition at line 192 of file gtest.cc.

                                       {
 #ifdef GTEST_TEST_FILTER_ENV_VAR_
   const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
   if (testbridge_test_only != NULL) {
     return testbridge_test_only;
   }
 #endif  // GTEST_TEST_FILTER_ENV_VAR_
   return kUniversalFilter;
 }

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

static

Definition at line 2112 of file gtest.cc.

References ArrayAsVector(), and GTEST_CHECK_.

                                   {
   if (xml_element == "testsuites") {
     return ArrayAsVector(kReservedTestSuitesAttributes);
   } else if (xml_element == "testsuite") {
     return ArrayAsVector(kReservedTestSuiteAttributes);
   } else if (xml_element == "testcase") {
     return ArrayAsVector(kReservedTestCaseAttributes);
   } else {
     GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
   }
   // This code is unreachable but some compilers may not realizes that.
   return std::vector<std::string>();
 }

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

static

Definition at line 2112 of file gtest.cc.

References ArrayAsVector(), and GTEST_CHECK_.

Referenced by FormatWordList(), testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(), testing::internal::PortableLocaltime(), and testing::TestResult::ValidateTestProperty().

                                   {
   if (xml_element == "testsuites") {
     return ArrayAsVector(kReservedTestSuitesAttributes);
   } else if (xml_element == "testsuite") {
     return ArrayAsVector(kReservedTestSuiteAttributes);
   } else if (xml_element == "testcase") {
     return ArrayAsVector(kReservedTestCaseAttributes);
   } else {
     GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
   }
   // This code is unreachable but some compilers may not realizes that.
   return std::vector<std::string>();
 }

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

static

Definition at line 2112 of file gtest.cc.

References ArrayAsVector(), and GTEST_CHECK_.

                                   {
   if (xml_element == "testsuites") {
     return ArrayAsVector(kReservedTestSuitesAttributes);
   } else if (xml_element == "testsuite") {
     return ArrayAsVector(kReservedTestSuiteAttributes);
   } else if (xml_element == "testcase") {
     return ArrayAsVector(kReservedTestCaseAttributes);
   } else {
     GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
   }
   // This code is unreachable but some compilers may not realizes that.
   return std::vector<std::string>();
 }

testing::GMOCK_DECLARE_bool_ ( catch_leaked_mocks )

testing::GMOCK_DECLARE_string_ ( verbose )

testing::GMOCK_DEFINE_bool_	(	catch_leaked_mocks	,
		true	,
		"true iff Google Mock should report leaked mock objects ""as failures."
	)

testing::GMOCK_DEFINE_string_	(	verbose	,
		internal::kWarningVerbosity	,
		"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only."
	)

template<typename Rhs >

internal::GtMatcher< Rhs > testing::Gt ( Rhs x )

inline

Definition at line 3772 of file gmock-matchers.h.

References x.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), testing::internal::ExpectationTester::SetCallCount(), EventHandlerTest::SetUp(), TEST(), and testing::gmock_matchers_test::TEST().

                                         {
   return internal::GtMatcher<Rhs>(x);
 }

internal::Gt2Matcher testing::Gt ( )

inline

Definition at line 4090 of file gmock-matchers.h.

4090 { return internal::Gt2Matcher(); }

template<int k>

class testing::GTEST_CONCAT_TOKEN_ ( InvokeArgumentAction )

Definition at line 2198 of file gmock-generated-actions.h.

2198 {

template<int k>

testing::GTEST_CONCAT_TOKEN_ ( InvokeArgumentAction )

inline

Definition at line 2198 of file gmock-generated-actions.h.

2198 {

template<typename arg0_type , typename arg1_type , typename arg2_type , typename arg3_type , typename arg4_type , typename arg5_type , typename arg6_type , typename arg7_type , typename arg8_type , typename arg9_type >

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_ ( InvokeArgumentAction )

Definition at line 2198 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), InvokeArgument(), testing::internal::invoke_argument::InvokeArgumentAdl(), and k.

                                       {
   using internal::invoke_argument::InvokeArgumentAdl;
   return InvokeArgumentAdl<return_type>(
       internal::invoke_argument::AdlTag(),
       ::testing::get<k>(args));
 }
 
 ACTION_TEMPLATE(InvokeArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p0)) {

template<int k, typename p0_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P
	)

inline

template<int k, typename p0_type , typename p1_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P2
	)

Definition at line 2216 of file gmock-generated-actions.h.

2216 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P
	)

template<int k, typename p0_type , typename p1_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P2
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P2
	)

template<int k, typename p0_type , typename p1_type , typename p2_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P3
	)

Definition at line 2225 of file gmock-generated-actions.h.

2225 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P3
	)

template<int k, typename p0_type , typename p1_type , typename p2_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P3
	)

inline

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P4
	)

Definition at line 2234 of file gmock-generated-actions.h.

2234 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P4
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P4
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P5
	)

Definition at line 2243 of file gmock-generated-actions.h.

2243 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P5
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P5
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P6
	)

Definition at line 2252 of file gmock-generated-actions.h.

2252 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P6
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P6
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P7
	)

Definition at line 2261 of file gmock-generated-actions.h.

2261 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P7
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P7
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P8
	)

Definition at line 2270 of file gmock-generated-actions.h.

2270 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P8
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P8
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P9
	)

Definition at line 2279 of file gmock-generated-actions.h.

2279 {

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P9
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P9
	)

template<int k, typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >

class testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P10
	)

Definition at line 2288 of file gmock-generated-actions.h.

2288 {

testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P10
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	InvokeArgumentAction	,
		P10
	)

template<typename T >

class testing::GTEST_CONCAT_TOKEN_ ( ReturnNewAction )

Definition at line 2302 of file gmock-generated-actions.h.

2302 {

template<typename T >

testing::GTEST_CONCAT_TOKEN_ ( ReturnNewAction )

inline

Definition at line 2302 of file gmock-generated-actions.h.

2302 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_ ( ReturnNewAction )

Definition at line 2302 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

                                       {
   return new T();
 }
 
 ACTION_TEMPLATE(ReturnNew,
                 HAS_1_TEMPLATE_PARAMS(typename, T),
                 AND_1_VALUE_PARAMS(p0)) {

template<typename T , typename p0_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P
	)

template<typename T , typename p0_type , typename p1_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P2
	)

Definition at line 2314 of file gmock-generated-actions.h.

2314 {

template<typename T , typename p0_type , typename p1_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P2
	)

inline

template<typename T , typename p0_type , typename p1_type , typename p2_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P3
	)

Definition at line 2320 of file gmock-generated-actions.h.

2320 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P2
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P3
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P3
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P4
	)

Definition at line 2326 of file gmock-generated-actions.h.

2326 {

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P4
	)

inline

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P5
	)

Definition at line 2332 of file gmock-generated-actions.h.

2332 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P4
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P5
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P5
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P6
	)

Definition at line 2338 of file gmock-generated-actions.h.

2338 {

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P6
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P6
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P7
	)

Definition at line 2344 of file gmock-generated-actions.h.

2344 {

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P7
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P7
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P8
	)

Definition at line 2350 of file gmock-generated-actions.h.

2350 {

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P8
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P8
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P9
	)

Definition at line 2356 of file gmock-generated-actions.h.

2356 {

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type >

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P9
	)

inline

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P9
	)

template<typename T , typename p0_type , typename p1_type , typename p2_type , typename p3_type , typename p4_type , typename p5_type , typename p6_type , typename p7_type , typename p8_type , typename p9_type >

class testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P10
	)

Definition at line 2362 of file gmock-generated-actions.h.

2362 {

::testing::internal::Function<F>::Result testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P10
	)

testing::GTEST_CONCAT_TOKEN_	(	ReturnNewAction	,
		P10
	)

inline

testing::GTEST_DECLARE_bool_ ( death_test_use_fork )

testing::GTEST_DECLARE_bool_ ( also_run_disabled_tests )

testing::GTEST_DECLARE_bool_ ( break_on_failure )

testing::GTEST_DECLARE_bool_ ( catch_exceptions )

testing::GTEST_DECLARE_bool_ ( list_tests )

testing::GTEST_DECLARE_bool_ ( print_time )

testing::GTEST_DECLARE_bool_ ( show_internal_stack_frames )

testing::GTEST_DECLARE_bool_ ( shuffle )

testing::GTEST_DECLARE_bool_ ( throw_on_failure )

testing::GTEST_DECLARE_int32_ ( random_seed )

testing::GTEST_DECLARE_int32_ ( repeat )

testing::GTEST_DECLARE_int32_ ( stack_trace_depth )

testing::GTEST_DECLARE_string_ ( death_test_style )

testing::GTEST_DECLARE_string_ ( color )

testing::GTEST_DECLARE_string_ ( filter )

testing::GTEST_DECLARE_string_ ( output )

testing::GTEST_DECLARE_string_ ( stream_result_to )

testing::GTEST_DEFINE_bool_	(	death_test_use_fork	,
		internal::BoolFromGTestEnv("death_test_use_fork", false)	,
		"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is	fixed,
		this flag will""most likely be removed."
	)

Referenced by GetDefaultFilter().

testing::GTEST_DEFINE_bool_	(	also_run_disabled_tests	,
		internal::BoolFromGTestEnv("also_run_disabled_tests", false)	,
		"Run disabled tests	too,
		in addition to the tests normally being run."
	)

testing::GTEST_DEFINE_bool_	(	break_on_failure	,
		internal::BoolFromGTestEnv("break_on_failure", false)	,
		"True iff a failed assertion should be a debugger break-point."
	)

testing::GTEST_DEFINE_bool_	(	catch_exceptions	,
		internal::BoolFromGTestEnv("catch_exceptions", true)	,
		"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures."
	)

testing::GTEST_DEFINE_bool_	(	list_tests	,
		false	,
		"List all tests without running them."
	)

testing::GTEST_DEFINE_bool_	(	print_time	,
		internal::BoolFromGTestEnv("print_time", true)	,
		"True iff "GTEST_NAME_" should display elapsed time in text output."
	)

testing::GTEST_DEFINE_bool_	(	show_internal_stack_frames	,
		false	,
		"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces."
	)

testing::GTEST_DEFINE_bool_	(	shuffle	,
		internal::BoolFromGTestEnv("shuffle", false)	,
		"True iff "GTEST_NAME_" should randomize tests' order on every run."
	)

testing::GTEST_DEFINE_bool_	(	throw_on_failure	,
		internal::BoolFromGTestEnv("throw_on_failure", false)	,
		"When this flag is	specified,
		a failed assertion will throw an exception""if exceptions are enabled or exit the program with a non-zero code""otherwise."
	)

testing::GTEST_DEFINE_int32_	(	random_seed	,
		internal::Int32FromGTestEnv("random_seed", 0)	,
		"Random number seed to use when shuffling test orders. Must be in range ""	[1, 99999],
		or 0 to use a seed based on the current time."
	)

Referenced by GetDefaultFilter().

testing::GTEST_DEFINE_int32_	(	repeat	,
		internal::Int32FromGTestEnv("repeat", 1)	,
		"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests."
	)

testing::GTEST_DEFINE_int32_	(	stack_trace_depth	,
		internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth)	,
		"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through	100,
		inclusive."
	)

testing::GTEST_DEFINE_string_	(	death_test_style	,
		internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle)	,
		"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking)."
	)

testing::GTEST_DEFINE_string_	(	color	,
		internal::StringFromGTestEnv("color","auto")	,
		"Whether to use colors in the output. Valid values:	yes,
		no	,
		""and auto. 'auto'means to use colors if the output is""being sent to a terminal and the TERM environment variable""is set to a terminal type that supports colors."
	)

testing::GTEST_DEFINE_string_	(	filter	,
		internal::StringFromGTestEnv("filter", GetDefaultFilter())	,
		"A colon-separated list of glob (not regex) patterns ""for filtering the tests to	run,
		optionally followed by a""'-'and a:separated list of negative patterns(tests to""exclude).A test is run if it matches one of the positive""patterns and does not match any of the negative patterns."
	)

testing::GTEST_DEFINE_string_	(	output	,
		internal::StringFromGTestEnv("output","")	,
		"A format	currently must be \"xml\",
		optionally followed""by a colon and an output file name or directory.A directory""is indicated by a trailing pathname separator.""Examples:\"xml:filename.xml\"	,
		\"xml::directoryname/\". ""If a directory is	specified,
		output files will be created""within that	directory,
		with file-names based on the test""executable's name	and,
		if	necessary,
		made unique by adding""digits."
	)

testing::GTEST_DEFINE_string_	(	stream_result_to	,
		internal::StringFromGTestEnv("stream_result_to","")	,
		"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux."
	)

PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > > testing::HasSubstr ( const internal::string & substring )

inline

Definition at line 3984 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by ContainsRegex(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectError(), fizz::test::HandshakeTest::expectError(), fizz::test::HandshakeTest::expectServerError(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::MATCHER_P(), Mock::Mock(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_nice_strict_test::MockBar::str(), testing::gmock_nice_strict_test::TEST(), TEST(), testing::gmock_matchers_test::TEST(), folly::TEST(), fizz::test::TEST_F(), fizz::client::test::TEST_F(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                                {
   return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
       substring));
 }

template<typename A >

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

inline

Definition at line 1187 of file gmock-actions.h.

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), and TEST().

                                                                       {
   return internal::IgnoreResultAction<A>(an_action);
 }

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

Definition at line 173 of file gmock.cc.

References testing::internal::InitGoogleMockImpl().

Referenced by main(), testing::internal::ParseGoogleMockStringFlag(), and TestInitGoogleMock().

                                                        {
   internal::InitGoogleMockImpl(argc, argv);
 }

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

Definition at line 179 of file gmock.cc.

References testing::internal::InitGoogleMockImpl().

                                                           {
   internal::InitGoogleMockImpl(argc, argv);
 }

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

Definition at line 5370 of file gtest.cc.

References testing::internal::InitGoogleTestImpl().

Referenced by AddGlobalTestEnvironment(), testing::UnitTest::impl(), testing::internal::InitGoogleMockImpl(), main(), and testing::internal::ParseGoogleMockStringFlag().

                                             {
 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
 #else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   internal::InitGoogleTestImpl(argc, argv);
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }

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

Definition at line 5380 of file gtest.cc.

References testing::internal::InitGoogleTestImpl().

                                                {
 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
 #else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   internal::InitGoogleTestImpl(argc, argv);
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }

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

Referenced by OpenSSLCertUtilsTest::SetUp(), fizz::test::TEST_P(), proxygen::TEST_P(), testing::gmock_matchers_test::TEST_P(), and TEST_P().

testing::INSTANTIATE_TYPED_TEST_CASE_P	(	My	,
		CodeLocationForTYPEDTESTP	,
		int
	)

Referenced by TYPED_TEST_P().

template<typename FunctionImpl >

PolymorphicAction< internal::InvokeAction< FunctionImpl > > testing::Invoke ( FunctionImpl function_impl )

Definition at line 114 of file gmock-more-actions.h.

References MakePolymorphicAction().

                                 {
   return MakePolymorphicAction(
       internal::InvokeAction<FunctionImpl>(function_impl));
 }

template<class Class , typename MethodPtr >

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

Definition at line 123 of file gmock-more-actions.h.

References MakePolymorphicAction().

Referenced by testing::internal::InvokeAction< FunctionImpl >::Perform().

                                           {
   return MakePolymorphicAction(
       internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
 }

p0_type testing::InvokeArgument ( p0_type p0 )

Definition at line 2207 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), testing::internal::invoke_argument::InvokeArgumentAdl(), and k.

Referenced by GTEST_CONCAT_TOKEN_(), and testing::internal::invoke_argument::InvokeArgumentAdl().

2207 {

p1_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1
	)

Definition at line 2216 of file gmock-generated-actions.h.

2216 {

p2_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2
	)

Definition at line 2225 of file gmock-generated-actions.h.

2225 {

p3_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3
	)

Definition at line 2234 of file gmock-generated-actions.h.

2234 {

p4_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4
	)

Definition at line 2243 of file gmock-generated-actions.h.

2243 {

p5_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5
	)

Definition at line 2252 of file gmock-generated-actions.h.

2252 {

p6_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6
	)

Definition at line 2261 of file gmock-generated-actions.h.

2261 {

p7_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7
	)

Definition at line 2270 of file gmock-generated-actions.h.

2270 {

p8_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7,
		p8_type	p8
	)

Definition at line 2279 of file gmock-generated-actions.h.

2279 {

p9_type testing::InvokeArgument	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7,
		p8_type	p8,
		p9_type	p9
	)

Definition at line 2288 of file gmock-generated-actions.h.

2288 {

template<typename FunctionImpl >

PolymorphicAction< internal::InvokeWithoutArgsAction< FunctionImpl > > testing::InvokeWithoutArgs ( FunctionImpl function_impl )

Definition at line 1168 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by fizz::server::test::FizzServerTest::accept(), fizz::server::test::AsyncFizzServerTest::accept(), fizz::server::test::ServerProtocolTest::acceptEarlyData(), fizz::client::test::AsyncFizzClientTest::completeEarlyHandshake(), fizz::client::test::AsyncFizzClientTest::connect(), fizz::client::test::ClientProtocolTest::doFinishedFlow(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectAeadCreation(), fizz::server::test::AsyncFizzServerTest::expectAppClose(), fizz::client::test::AsyncFizzClientTest::expectAppClose(), proxygen::MockHTTPHandler::expectBody(), proxygen::MockHTTPHandler::expectChunkComplete(), proxygen::MockHTTPHandler::expectChunkHeader(), proxygen::MockHTTPHandler::expectHeaders(), fizz::server::test::AsyncFizzServerTest::fullHandshakeSuccess(), fizz::client::test::AsyncFizzClientTest::fullHandshakeSuccess(), MockCodecDownstreamTest::MockCodecDownstreamTest(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), testing::internal::ExpectationTester::SetCallCount(), fizz::MockKeyExchange::setDefaults(), fizz::test::MockKeyScheduler::setDefaults(), fizz::test::MockAead::setDefaults(), fizz::MockPlaintextWriteRecordLayer::setDefaults(), fizz::test::MockHandshakeContext::setDefaults(), fizz::server::test::MockTicketCipher::setDefaults(), fizz::test::MockFactory::setDefaults(), fizz::test::MockCertificateDecompressor::setDefaults(), fizz::test::MockCertificateCompressor::setDefaults(), fizz::test::KeySchedulerTest::SetUp(), FlowControlFilterTest< initSize >::SetUp(), DownstreamTransactionTest::setupRequestResponseFlow(), fizz::server::test::TEST(), TEST(), fizz::test::TEST_F(), fizz::server::test::TEST_F(), fizz::client::test::TEST_F(), and TEST_F().

                                               {
   return MakePolymorphicAction(
       internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
 }

template<class Class , typename MethodPtr >

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

Definition at line 1177 of file gmock-actions.h.

References MakePolymorphicAction().

                                                         {
   return MakePolymorphicAction(
       internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
           obj_ptr, method_ptr));
 }

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

Definition at line 1618 of file gtest.cc.

Referenced by IsNotSubstring(), testing::internal::ExpectationTester::SetCallCount(), testing::InitGoogleTestTest::TestParsingFlags(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                               {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }

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

Definition at line 1624 of file gtest.cc.

                                                     {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }

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

Definition at line 1636 of file gtest.cc.

References AssertionFailure(), AssertionSuccess(), IsNotSubstring(), testing::internal::IsSpace(), IsSubstring(), needle, and string.

                                                         {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }

PolymorphicMatcher< internal::IsNullMatcher > testing::IsNull ( )

inline

Definition at line 3795 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and TEST().

                                                            {
   return MakePolymorphicMatcher(internal::IsNullMatcher());
 }

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

Definition at line 1606 of file gtest.cc.

Referenced by IsNotSubstring(), testing::internal::ExpectationTester::SetCallCount(), testing::internal::TEST(), testing::InitGoogleTestTest::TestParsingFlags(), testing::internal::To::To(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                               {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }

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

Definition at line 1612 of file gtest.cc.

                                                     {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }

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

Definition at line 1630 of file gtest.cc.

                                                         {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }

template<typename M >

internal::KeyMatcher< M > testing::Key ( M inner_matcher )

inline

Definition at line 4322 of file gmock-matchers.h.

Referenced by contendedRW(), folly::AtomicUnorderedInsertMap< Key, Value, Hash, KeyEqual, SkipKeyValueDeletion, Atom, IndexType, Allocator >::findOrConstruct(), folly::get_default(), proxygen::PerfectIndexMap< typename T::TKey, T::TOtherKey, T::TNoneKey, T::Hash, T::TAllowDuplicates, T::TCaseInsensitive >::getSingleKey(), folly::gen::detail::GroupBy< Selector >::GroupBy(), folly::gen::detail::GroupByAdjacent< Selector >::GroupByAdjacent(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::insert(), non_atomic< T >::is_lock_free(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), folly::gen::detail::Min< Selector, Comparer >::Min(), folly::F14ValueMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), folly::F14NodeMap< std::string, Mapped, Hash, Eq, Alloc >::operator=(), folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), folly::ParkingLot< Data >::park(), folly::ParkingLot< Data >::park_for(), proxygen::PerfectIndexMap< typename T::TKey, T::TOtherKey, T::TNoneKey, T::Hash, T::TAllowDuplicates, T::TCaseInsensitive >::removeKey(), proxygen::PerfectIndexMap< typename T::TKey, T::TOtherKey, T::TNoneKey, T::Hash, T::TAllowDuplicates, T::TCaseInsensitive >::searchForKey(), proxygen::PerfectIndexMap< typename T::TKey, T::TOtherKey, T::TNoneKey, T::Hash, T::TAllowDuplicates, T::TCaseInsensitive >::setKey(), folly::swap(), testing::gmock_matchers_test::TEST(), TYPED_TEST(), folly::f14::detail::F14BasicMap< Key, Mapped, Hasher, KeyEqual, Alloc >::visitContiguousRanges(), and folly::AtomicUnorderedInsertMap< Key, Value, Hash, KeyEqual, SkipKeyValueDeletion, Atom, IndexType, Allocator >::zeroFillSlots().

                                                   {
   return internal::KeyMatcher<M>(inner_matcher);
 }

template<typename Rhs >

internal::LeMatcher< Rhs > testing::Le ( Rhs x )

inline

Definition at line 3778 of file gmock-matchers.h.

References x.

                                         {
   return internal::LeMatcher<Rhs>(x);
 }

internal::Le2Matcher testing::Le ( )

inline

Definition at line 4094 of file gmock-matchers.h.

4094 { return internal::Le2Matcher(); }

template<typename Rhs >

internal::LtMatcher< Rhs > testing::Lt ( Rhs x )

inline

Definition at line 3784 of file gmock-matchers.h.

References x.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), testing::gmock_matchers_test::NotCopyable::operator>=(), testing::internal::ExpectationTester::SetCallCount(), TEST(), testing::gmock_matchers_test::TEST(), testing::gmock_generated_function_mockers_test::TEST_F(), and TEST_F().

                                         {
   return internal::LtMatcher<Rhs>(x);
 }

internal::Lt2Matcher testing::Lt ( )

inline

Definition at line 4098 of file gmock-matchers.h.

4098 { return internal::Lt2Matcher(); }

template<typename F >

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

Definition at line 463 of file gmock-actions.h.

Referenced by testing::internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 >::operator Action< F >(), testing::gmock_generated_actions_test::SubstractAction::Perform(), testing::PolymorphicAction< Impl >::MonomorphicImpl< F >::Perform(), and testing::gmock_generated_actions_test::TEST().

                                                {
   return Action<F>(impl);
 }

Cardinality testing::MakeCardinality ( const CardinalityInterface * c )

inline

Definition at line 141 of file gmock-cardinalities.h.

Referenced by testing::Cardinality::DescribeTo().

                                                                   {
   return Cardinality(c);
 }

template<typename T >

Matcher< T > testing::MakeMatcher ( const MatcherInterface< T > * impl )

inline

Definition at line 484 of file gmock-matchers.h.

                                                                {
   return Matcher<T>(impl);
 }

template<typename Impl >

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

inline

Definition at line 475 of file gmock-actions.h.

Referenced by Assign(), Invoke(), InvokeWithoutArgs(), testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform(), testing::PolymorphicAction< Impl >::MonomorphicImpl< F >::Perform(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), Return(), ReturnNull(), SetArgPointee(), SetArgumentPointee(), and SetErrnoAndReturn().

                                                                        {
   return PolymorphicAction<Impl>(impl);
 }

template<class Impl >

PolymorphicMatcher< Impl > testing::MakePolymorphicMatcher ( const Impl & impl )

inline

Definition at line 496 of file gmock-matchers.h.

                                                                          {
   return PolymorphicMatcher<Impl>(impl);
 }

testing::MATCHER	(	IsEmpty	,
		negation?"isn't empty":"is empty"
	)

Definition at line 48 of file gmock-more-matchers.h.

                                           : "is empty") {
   if (arg.empty()) {
     return true;
   }
   *result_listener << "whose size is " << arg.size();
   return false;
 }

template<typename T , typename M >

Matcher< T > testing::MatcherCast ( const M & matcher )

inline

Definition at line 610 of file gmock-matchers.h.

References testing::internal::MatcherCastImpl< T, M >::Cast().

Referenced by testing::internal::MatcherCastImpl< T, Matcher< T > >::Cast(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and Property().

                                                 {
   return internal::MatcherCastImpl<T, M>::Cast(matcher);
 }

template<typename M >

internal::MatcherAsPredicate< M > testing::Matches ( M matcher )

inline

Definition at line 4341 of file gmock-matchers.h.

Referenced by testing::internal::UnorderedElementsAreMatcherImpl< Container >::AnalyzeElements(), testing::internal::TuplePrefix< 0 >::ExplainMatchFailuresTo(), testing::internal::TypedExpectation< F >::ExplainMatchResultTo(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::internal::TuplePrefix< N >::Matches(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::internal::MatcherAsPredicate< M >::operator()(), testing::internal::TypedExpectation< F >::ShouldHandleArguments(), testing::gmock_matchers_test::TEST(), testing::internal::TupleMatches(), and Value().

                                                         {
   return internal::MatcherAsPredicate<M>(matcher);
 }

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::MatchesRegex ( const internal::RE * regex )

inline

Definition at line 4005 of file gmock-matchers.h.

References MakePolymorphicMatcher().

                              {
   return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
 }

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::MatchesRegex ( const internal::string & regex )

inline

Definition at line 4009 of file gmock-matchers.h.

References MatchesRegex().

                                  {
   return MatchesRegex(new internal::RE(regex));
 }

internal::FloatingEqMatcher< double > testing::NanSensitiveDoubleEq ( double rhs )

inline

Definition at line 3821 of file gmock-matchers.h.

References folly::detail::rhs.

                                                                           {
   return internal::FloatingEqMatcher<double>(rhs, true);
 }

internal::FloatingEqMatcher< double > testing::NanSensitiveDoubleNear	(	double	rhs,
		double	max_abs_error
	)

inline

Definition at line 3836 of file gmock-matchers.h.

References folly::detail::rhs.

                                       {
   return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
 }

internal::FloatingEqMatcher< float > testing::NanSensitiveFloatEq ( float rhs )

inline

Definition at line 3849 of file gmock-matchers.h.

References folly::detail::rhs.

                                                                        {
   return internal::FloatingEqMatcher<float>(rhs, true);
 }

internal::FloatingEqMatcher< float > testing::NanSensitiveFloatNear	(	float	rhs,
		float	max_abs_error
	)

inline

Definition at line 3864 of file gmock-matchers.h.

References folly::detail::rhs.

                                     {
   return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
 }

template<typename Rhs >

internal::NeMatcher< Rhs > testing::Ne ( Rhs x )

inline

Definition at line 3790 of file gmock-matchers.h.

References x.

                                         {
   return internal::NeMatcher<Rhs>(x);
 }

internal::Ne2Matcher testing::Ne ( )

inline

Definition at line 4102 of file gmock-matchers.h.

4102 { return internal::Ne2Matcher(); }

template<typename InnerMatcher >

internal::NotMatcher< InnerMatcher > testing::Not ( InnerMatcher m )

inline

Definition at line 4107 of file gmock-matchers.h.

References m.

                                                             {
   return internal::NotMatcher<InnerMatcher>(m);
 }

PolymorphicMatcher< internal::NotNullMatcher > testing::NotNull ( )

inline

Definition at line 3802 of file gmock-matchers.h.

References MakePolymorphicMatcher().

                                                              {
   return MakePolymorphicMatcher(internal::NotNullMatcher());
 }

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

Definition at line 58 of file gtest-test-part.cc.

References testing::TestPartResult::file_name(), testing::TestPartResult::kFatalFailure, testing::TestPartResult::kSuccess, testing::TestPartResult::line_number(), testing::TestPartResult::message(), and testing::TestPartResult::type().

                                                                      {
   return os
       << result.file_name() << ":" << result.line_number() << ": "
       << (result.type() == TestPartResult::kSuccess ? "Success" :
           result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
           "Non-fatal failure") << ":\n"
       << result.message() << std::endl;
 }

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

inline

Definition at line 232 of file gtest-message.h.

References testing::Message::GetString().

Referenced by testing::gmock_matchers_test::ConvertibleFromAny::ConvertibleFromAny(), testing::TestPartResult::fatally_failed(), testing::Message::Message(), namespace1::MyTypeInNameSpace1::MyTypeInNameSpace1(), testing::Message::operator<<(), and TEST().

                                                                   {
   return os << sb.GetString();
 }

template<typename FirstMatcher , typename SecondMatcher >

internal::PairMatcher< FirstMatcher, SecondMatcher > testing::Pair	(	FirstMatcher	first_matcher,
		SecondMatcher	second_matcher
	)

inline

Definition at line 4333 of file gmock-matchers.h.

Referenced by testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gtest_printers_test::AllowsGenericStreamingAndImplicitConversionTemplate< T >::operator bool(), testing::gmock_matchers_test::NotCopyable::operator>=(), TEST(), testing::gmock_matchers_test::TEST(), and testing::gmock_matchers_test::TEST_F().

                                                                {
   return internal::PairMatcher<FirstMatcher, SecondMatcher>(
       first_matcher, second_matcher);
 }

template<typename InnerMatcher >

internal::PointeeMatcher< InnerMatcher > testing::Pointee ( const InnerMatcher & inner_matcher )

inline

Definition at line 3872 of file gmock-matchers.h.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::MATCHER_P(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), TEST(), testing::gmock_matchers_test::TEST(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                        {
   return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
 }

template<typename TupleMatcher , typename Container >

internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)> testing::Pointwise	(	const TupleMatcher &	tuple_matcher,
		const Container &	rhs
	)

inline

Definition at line 4187 of file gmock-matchers.h.

References GTEST_REMOVE_CONST_, and folly::detail::rhs.

Referenced by testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::gmock_matchers_test::TEST().

                                                                    {
   // This following line is for working around a bug in MSVC 8.0,
   // which causes Container to be a const type sometimes (e.g. when
   // rhs is a const int[])..
   typedef GTEST_REMOVE_CONST_(Container) RawContainer;
   return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
       tuple_matcher, rhs);
 }

void testing::PrintFlag ( const char * flag )

Definition at line 53 of file gtest_env_var_test_.cc.

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

Referenced by main().

                                  {
   if (strcmp(flag, "break_on_failure") == 0) {
     cout << GTEST_FLAG(break_on_failure);
     return;
   }
 
   if (strcmp(flag, "catch_exceptions") == 0) {
     cout << GTEST_FLAG(catch_exceptions);
     return;
   }
 
   if (strcmp(flag, "color") == 0) {
     cout << GTEST_FLAG(color);
     return;
   }
 
   if (strcmp(flag, "death_test_style") == 0) {
     cout << GTEST_FLAG(death_test_style);
     return;
   }
 
   if (strcmp(flag, "death_test_use_fork") == 0) {
     cout << GTEST_FLAG(death_test_use_fork);
     return;
   }
 
   if (strcmp(flag, "filter") == 0) {
     cout << GTEST_FLAG(filter);
     return;
   }
 
   if (strcmp(flag, "output") == 0) {
     cout << GTEST_FLAG(output);
     return;
   }
 
   if (strcmp(flag, "print_time") == 0) {
     cout << GTEST_FLAG(print_time);
     return;
   }
 
   if (strcmp(flag, "repeat") == 0) {
     cout << GTEST_FLAG(repeat);
     return;
   }
 
   if (strcmp(flag, "stack_trace_depth") == 0) {
     cout << GTEST_FLAG(stack_trace_depth);
     return;
   }
 
   if (strcmp(flag, "throw_on_failure") == 0) {
     cout << GTEST_FLAG(throw_on_failure);
     return;
   }
 
   cout << "Invalid flag name " << flag
        << ".  Valid names are break_on_failure, color, filter, etc.\n";
   exit(1);
 }

template<typename T >

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

Definition at line 980 of file gtest-printers.h.

References testing::internal::UniversalTersePrinter< T >::Print().

Referenced by testing::internal::UnorderedElementsAreMatcherImpl< Container >::AnalyzeElements(), testing::internal::CmpHelperSTRCASEEQ(), testing::internal::CmpHelperSTREQ(), testing::internal::CmpHelperSTRNE(), testing::internal::FormatForComparison< ToPrint, OtherOperand >::Format(), testing::internal::ArgsMatcherImpl< ArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >::MatchAndExplain(), testing::internal::UniversalTersePrinter< wchar_t * >::Print(), folly::PrintTo(), testing::gmock_matchers_test::TEST_P(), and foo::StreamableTemplateInFoo< T >::value().

                                         {
   ::std::stringstream ss;
   internal::UniversalTersePrinter<T>::Print(value, &ss);
   return ss.str();
 }

template<typename Class , typename PropertyType , typename PropertyMatcher >

PolymorphicMatcher< internal::PropertyMatcher< Class, PropertyType > > testing::Property	(	PropertyType(Class::*)() const	property,
		const PropertyMatcher &	matcher
	)

inline

Definition at line 3913 of file gmock-matchers.h.

References GTEST_REFERENCE_TO_CONST_, MakePolymorphicMatcher(), and MatcherCast().

Referenced by testing::gmock_matchers_test::DerivedClass::k(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), and testing::gmock_matchers_test::TEST().

                                                                            {
   return MakePolymorphicMatcher(
       internal::PropertyMatcher<Class, PropertyType>(
           property,
           MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   Property(&Foo::bar, m)
   // to compile where bar() returns an int32 and m is a matcher for int64.
 }

template<typename T >

internal::RefMatcher< T & > testing::Ref ( T & x )

inline

Definition at line 3809 of file gmock-matchers.h.

References x.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::Derived::Derived(), testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::DerivedClass::k(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), TEST(), testing::gmock_matchers_test::TEST(), TEST_F(), and testing::gmock_generated_function_mockers_test::TEST_F().

                                         {  // NOLINT
   return internal::RefMatcher<T&>(x);
 }

testing::REGISTER_TYPED_TEST_CASE_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

Referenced by TYPED_TEST_P().

template<typename Callable , typename ResultOfMatcher >

internal::ResultOfMatcher< Callable > testing::ResultOf	(	Callable	callable,
		const ResultOfMatcher &	matcher
	)

Definition at line 3939 of file gmock-matchers.h.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::Functor::operator()(), testing::gmock_matchers_test::PolymorphicFunctor::operator()(), testing::gmock_matchers_test::ReferencingFunctor::operator()(), and testing::gmock_matchers_test::TEST().

                                                        {
   return internal::ResultOfMatcher<Callable>(
           callable,
           MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
               matcher));
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   ResultOf(Function, m)
   // to compile where Function() returns an int32 and m is a matcher for int64.
 }

template<typename R >

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

Definition at line 1061 of file gmock-actions.h.

References testing::internal::move().

Referenced by fizz::server::test::AsyncFizzServerTest::accept(), HTTPDownstreamTest< SPDY3_1CodecPair >::addSimpleNiceHandler(), HTTPDownstreamTest< SPDY3_1CodecPair >::addSimpleStrictHandler(), testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), fizz::test::AsyncFizzBaseTest::AsyncFizzBaseTest(), HTTPUpstreamTest< SPDY3CodecPair >::commonSetUp(), HTTP2UpstreamSessionWithVirtualNodesTest::commonSetUp(), proxygen::MockHTTPTransaction::enablePush(), ZlibServerFilterTest::exercise_compression(), testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), folly::Future< folly::folly::Unit >::Future(), fizz::server::test::CertManagerTest::getCert(), HTTPDownstreamTest< SPDY3_1CodecPair >::HTTPDownstreamTest(), fizz::test::CertDecompressionManagerTest::makeMockDecompressor(), proxygen::makeMockParallelCodec(), folly::gen::member(), MockCodecDownstreamTest::MockCodecDownstreamTest(), proxygen::MockHTTPTransaction::MockHTTPTransaction(), testing::gmock_generated_function_mockers_test::MockOverloadedOnArgNumber::MockOverloadedOnArgNumber(), testing::gmock_generated_function_mockers_test::MockOverloadedOnConstness::MockOverloadedOnConstness(), testing::gmock_generated_function_mockers_test::MockStack< T >::MockStack(), proxygen::newMockTransport(), testing::gmock_generated_actions_test::SubstractAction::Perform(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), fizz::test::HandshakeTest::resetTransportsAndStartCookieHandshake(), testing::internal::ExpectationTester::SetCallCount(), TimeoutTest::setClock(), HTTPUpstreamTest< SPDY3CodecPair >::setMockByteEventTracker(), HTTPDownstreamTest< SPDY3_1CodecPair >::setMockByteEventTracker(), fizz::test::KeySchedulerTest::SetUp(), fizz::server::test::ServerProtocolTest::SetUp(), DownstreamTransactionTest::SetUp(), fizz::server::test::AsyncFizzServerTest::SetUp(), fizz::client::test::AsyncFizzClientTest::SetUp(), fizz::test::HandshakeTest::SetUp(), FlowControlFilterTest< initSize >::SetUp(), TimeoutTest::SetUp(), HTTP2UpstreamSessionWithVirtualNodesTest::SetUp(), MockHTTPUpstreamTest::SetUp(), MockHTTP2UpstreamTest::SetUp(), folly::TEST(), fizz::server::test::TEST(), TEST(), testing::gmock_generated_function_mockers_test::TEST(), testing::gmock_generated_actions_test::TEST(), testing::gmock_matchers_test::TEST(), TEST_F(), fizz::test::TEST_F(), fizz::server::test::TEST_F(), testing::gmock_generated_function_mockers_test::TEST_F(), fizz::client::test::TEST_F(), folly::TEST_F(), MockCodecDownstreamTest::testConnFlowControlBlocked(), testExpectHandling(), MockCodecDownstreamTest::testGoaway(), proxygen::RFC1867Base::testSimple(), HTTPDownstreamTest< C >::testSimpleUpgrade(), HTTPUpstreamTest< C >::testSimpleUpgrade(), folly::Future< folly::folly::Unit >::then(), and TYPED_TEST().

                                         {
   return internal::ReturnAction<R>(internal::move(value));
 }

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

inline

Definition at line 1071 of file gmock-actions.h.

References MakePolymorphicAction().

                                                             {
   return MakePolymorphicAction(internal::ReturnVoidAction());
 }

p0_type testing::ReturnNew ( p0_type p0 )

Definition at line 2308 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), and T.

Referenced by GTEST_CONCAT_TOKEN_(), and ReturnNew().

2308 {

p1_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1
	)

Definition at line 2314 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2314 {

p2_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2
	)

Definition at line 2320 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2320 {

p3_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3
	)

Definition at line 2326 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2326 {

p4_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4
	)

Definition at line 2332 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2332 {

p5_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5
	)

Definition at line 2338 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2338 {

p6_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6
	)

Definition at line 2344 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2344 {

p7_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7
	)

Definition at line 2350 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2350 {

p8_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7,
		p8_type	p8
	)

Definition at line 2356 of file gmock-generated-actions.h.

References ACTION_TEMPLATE(), ReturnNew(), and T.

2356 {

p9_type testing::ReturnNew	(	p0_type	p0,
		p1_type	p1,
		p2_type	p2,
		p3_type	p3,
		p4_type	p4,
		p5_type	p5,
		p6_type	p6,
		p7_type	p7,
		p8_type	p8,
		p9_type	p9
	)

Definition at line 2362 of file gmock-generated-actions.h.

References T.

2362 {

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

inline

Definition at line 1066 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform().

                                                                 {
   return MakePolymorphicAction(internal::ReturnNullAction());
 }

template<typename R >

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

inline

Definition at line 1077 of file gmock-actions.h.

References x.

Referenced by MockCodecDownstreamTest::MockCodecDownstreamTest(), proxygen::MockHTTPTransaction::MockHTTPTransaction(), proxygen::MockHTTPTransactionTransport::MockHTTPTransactionTransport(), testing::gmock_generated_function_mockers_test::MockOverloadedOnConstness::MockOverloadedOnConstness(), testing::gmock_generated_function_mockers_test::MockStack< T >::MockStack(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), TEST(), and testing::gmock_generated_function_mockers_test::TEST().

                                                   {  // NOLINT
   return internal::ReturnRefAction<R>(x);
 }

template<typename R >

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

inline

Definition at line 1085 of file gmock-actions.h.

References x.

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform().

                                                                     {
   return internal::ReturnRefOfCopyAction<R>(x);
 }

template<typename T , typename M >

Matcher< T > testing::SafeMatcherCast ( const M & polymorphic_matcher )

inline

Definition at line 665 of file gmock-matchers.h.

References A(), and testing::SafeMatcherCastImpl< T >::Cast().

Referenced by testing::SafeMatcherCastImpl< T >::Cast().

                                                                 {
   return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
 }

template<size_t N, typename T >

PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > > testing::SetArgPointee ( const T & x )

Definition at line 1109 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), and testing::internal::ExpectationTester::SetCallCount().

                           {
   return MakePolymorphicAction(internal::SetArgumentPointeeAction<
       N, T, internal::IsAProtocolMessage<T>::value>(x));
 }

template<size_t N>

PolymorphicAction< internal::SetArgumentPointeeAction< N, const char *, false > > testing::SetArgPointee ( const char * p )

Definition at line 1121 of file gmock-actions.h.

References MakePolymorphicAction().

                              {
   return MakePolymorphicAction(internal::SetArgumentPointeeAction<
       N, const char*, false>(p));
 }

template<size_t N>

PolymorphicAction< internal::SetArgumentPointeeAction< N, const wchar_t *, false > > testing::SetArgPointee ( const wchar_t * p )

Definition at line 1129 of file gmock-actions.h.

References MakePolymorphicAction(), and T.

                                 {
   return MakePolymorphicAction(internal::SetArgumentPointeeAction<
       N, const wchar_t*, false>(p));
 }

template<size_t N, typename T >

PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > > testing::SetArgumentPointee ( const T & x )

Definition at line 1140 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform().

                                {
   return MakePolymorphicAction(internal::SetArgumentPointeeAction<
       N, T, internal::IsAProtocolMessage<T>::value>(x));
 }

template<typename T >

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

Definition at line 1156 of file gmock-actions.h.

References MakePolymorphicAction().

Referenced by testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), and TEST().

                                         {
   return MakePolymorphicAction(
       internal::SetErrnoAndReturnAction<T>(errval, result));
 }

template<typename SizeMatcher >

internal::SizeIsMatcher< SizeMatcher > testing::SizeIs ( const SizeMatcher & size_matcher )

inline

Definition at line 4128 of file gmock-matchers.h.

                                         {
   return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
 }

PolymorphicMatcher< internal::StartsWithMatcher< internal::string > > testing::StartsWith ( const internal::string & prefix )

inline

Definition at line 3991 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::AStruct::AStruct(), ContainsRegex(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::DerivedClass::k(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), TEST(), and testing::gmock_matchers_test::TEST().

                                              {
   return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
       prefix));
 }

template<typename T1 , typename T2 >

bool testing::StaticAssertTypeEq ( )

Definition at line 2150 of file gtest.h.

Referenced by testing::internal::StlContainerView< RawContainer >::ConstReference(), testing::internal::ContainerEqMatcher< Container >::ContainerEqMatcher(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::PointwiseMatcher(), testing::internal::TEST(), testing::internal::To::To(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                           {
   (void)internal::StaticAssertTypeEqHelper<T1, T2>();
   return true;
 }

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrCaseEq ( const internal::string & str )

inline

Definition at line 3969 of file gmock-matchers.h.

References MakePolymorphicMatcher().

                                          {
   return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
       str, true, false));
 }

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrCaseNe ( const internal::string & str )

inline

Definition at line 3976 of file gmock-matchers.h.

References MakePolymorphicMatcher().

                                          {
   return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
       str, false, false));
 }

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrEq ( const internal::string & str )

inline

Definition at line 3955 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by ContainsRegex(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::DerivedClass::k(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), TEST(), and testing::gmock_matchers_test::TEST().

                                      {
   return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
       str, true, true));
 }

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrNe ( const internal::string & str )

inline

Definition at line 3962 of file gmock-matchers.h.

References MakePolymorphicMatcher().

                                      {
   return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
       str, false, true));
 }

testing::TEST	(	GTestEnvVarTest	,
		Dummy
	)

Definition at line 50 of file gtest_env_var_test_.cc.

Referenced by folly::TEST().

50 {

51 }

testing::TEST	(	SuccessfulAssertionTest	,
		SUCCEED
	)

Definition at line 4194 of file gtest_unittest.cc.

References EXPECT_EQ, testing::internal::GetUnitTestImpl(), and SUCCEED.

                                        {
   SUCCEED();
   SUCCEED() << "OK";
   EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT
	)

Definition at line 4201 of file gtest_unittest.cc.

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

                                       {
   EXPECT_TRUE(true);
   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT_STR
	)

Definition at line 4207 of file gtest_unittest.cc.

References EXPECT_EQ, EXPECT_STREQ, and testing::internal::GetUnitTestImpl().

                                           {
   EXPECT_STREQ("", "");
   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT
	)

Definition at line 4213 of file gtest_unittest.cc.

References ASSERT_TRUE, EXPECT_EQ, and testing::internal::GetUnitTestImpl().

                                       {
   ASSERT_TRUE(true);
   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT_STR
	)

Definition at line 4219 of file gtest_unittest.cc.

References ADD_FAILURE, ADD_FAILURE_AT, ASSERT_DOUBLE_EQ, ASSERT_EQ, ASSERT_FALSE, ASSERT_FLOAT_EQ, ASSERT_GE, ASSERT_GT, ASSERT_LE, ASSERT_LT, ASSERT_NE, ASSERT_NEAR, ASSERT_STRCASEEQ, ASSERT_STRCASENE, ASSERT_STREQ, ASSERT_STRNE, ASSERT_TRUE, ch, testing::gmock_generated_actions_test::Char(), count, EXPECT_ANY_THROW, EXPECT_DOUBLE_EQ, EXPECT_EQ, EXPECT_FALSE, EXPECT_FATAL_FAILURE, EXPECT_FLOAT_EQ, EXPECT_GE, EXPECT_GT, EXPECT_LE, EXPECT_LT, EXPECT_NE, EXPECT_NEAR, EXPECT_NO_THROW, EXPECT_NONFATAL_FAILURE, EXPECT_STRCASEEQ, EXPECT_STRCASENE, EXPECT_STREQ, EXPECT_STRNE, EXPECT_THROW, EXPECT_TRUE, FAIL, testing::gmock_matchers_test::foo, FRIEND_TEST, testing::internal::GetUnitTestImpl(), testing::internal::operator!=(), folly::operator<(), folly::operator<=(), testing::internal::operator==(), folly::operator>(), folly::operator>=(), folly::detail::rhs, testing::internal::StreamableToString(), string, SUCCEED, testing::internal::TEST(), testing::internal::TEST_F(), and x.

                                           {
   ASSERT_STREQ("", "");
   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

testing::TEST	(	CodeLocationForTEST	,
		Verify
	)

Definition at line 5344 of file gtest_unittest.cc.

References VERIFY_CODE_LOCATION.

                                   {
   VERIFY_CODE_LOCATION;
 }

testing::TEST_F	(	TestInfoTest	,
		Names
	)

Definition at line 5319 of file gtest_unittest.cc.

References ASSERT_STREQ, testing::TestInfo::name(), and testing::TestInfo::test_case_name().

Referenced by folly::TEST().

                             {
   const TestInfo* const test_info = GetTestInfo("Names");
 
   ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
   ASSERT_STREQ("Names", test_info->name());
 }

testing::TEST_F	(	TestInfoTest	,
		result
	)

Definition at line 5327 of file gtest_unittest.cc.

References ASSERT_EQ.

                              {
   const TestInfo* const test_info = GetTestInfo("result");
 
   // Initially, there is no TestPartResult for this test.
   ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
 
   // After the previous assertion, there is still none.
   ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
 }

testing::TEST_F	(	CodeLocationForTESTF	,
		Verify
	)

Definition at line 5351 of file gtest_unittest.cc.

References VERIFY_CODE_LOCATION.

                                      {
   VERIFY_CODE_LOCATION;
 }

testing::TEST_F	(	SetUpTestCaseTest	,
		Test1
	)

Definition at line 5444 of file gtest_unittest.cc.

References EXPECT_STRNE.

                                  {
   EXPECT_STRNE(NULL, shared_resource_);
 }

testing::TEST_F	(	SetUpTestCaseTest	,
		Test2
	)

Definition at line 5449 of file gtest_unittest.cc.

References EXPECT_STREQ.

                                  {
   EXPECT_STREQ("123", shared_resource_);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		Empty
	)

Definition at line 5712 of file gtest_unittest.cc.

References argv, and GTEST_TEST_PARSING_FLAGS_.

                                   {
   const char* argv[] = {
     NULL
   };
 
   const char* argv2[] = {
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		NoFlag
	)

Definition at line 5725 of file gtest_unittest.cc.

References argv, and GTEST_TEST_PARSING_FLAGS_.

                                    {
   const char* argv[] = {
     "foo.exe",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		FilterBad
	)

Definition at line 5740 of file gtest_unittest.cc.

References argv, testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

                                       {
   const char* argv[] = {
     "foo.exe",
     "--gtest_filter",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     "--gtest_filter",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		FilterEmpty
	)

Definition at line 5757 of file gtest_unittest.cc.

References argv, testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

                                         {
   const char* argv[] = {
     "foo.exe",
     "--gtest_filter=",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		FilterNonEmpty
	)

Definition at line 5773 of file gtest_unittest.cc.

References argv, testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

                                            {
   const char* argv[] = {
     "foo.exe",
     "--gtest_filter=abc",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureWithoutValue
	)

Definition at line 5789 of file gtest_unittest.cc.

References argv, testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

                                                        {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure",
     NULL
 };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_0
	)

Definition at line 5805 of file gtest_unittest.cc.

References argv, testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

                                                   {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure=0",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_f
	)

Definition at line 5821 of file gtest_unittest.cc.

References argv, testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

                                                   {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure=f",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_F
	)

Definition at line 5837 of file gtest_unittest.cc.

References argv, testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

                                                   {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure=F",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureTrue
	)

Definition at line 5854 of file gtest_unittest.cc.

References argv, testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

                                                {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure=1",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		CatchExceptions
	)

Definition at line 5870 of file gtest_unittest.cc.

References argv, testing::Flags::CatchExceptions(), and GTEST_TEST_PARSING_FLAGS_.

                                             {
   const char* argv[] = {
     "foo.exe",
     "--gtest_catch_exceptions",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		DeathTestUseFork
	)

Definition at line 5886 of file gtest_unittest.cc.

References argv, testing::Flags::DeathTestUseFork(), and GTEST_TEST_PARSING_FLAGS_.

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_death_test_use_fork",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		DuplicatedFlags
	)

Definition at line 5903 of file gtest_unittest.cc.

References argv, testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

                                             {
   const char* argv[] = {
     "foo.exe",
     "--gtest_filter=a",
     "--gtest_filter=b",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		UnrecognizedFlag
	)

Definition at line 5920 of file gtest_unittest.cc.

References argv, testing::Flags::break_on_failure, testing::Flags::filter, and GTEST_TEST_PARSING_FLAGS_.

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_break_on_failure",
     "bar",  // Unrecognized by Google Test.
     "--gtest_filter=b",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     "bar",
     NULL
   };
 
   Flags flags;
   flags.break_on_failure = true;
   flags.filter = "b";
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFlag
	)

Definition at line 5942 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

                                           {
     const char* argv[] = {
       "foo.exe",
       "--gtest_list_tests",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsTrue
	)

Definition at line 5958 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

                                           {
     const char* argv[] = {
       "foo.exe",
       "--gtest_list_tests=1",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse
	)

Definition at line 5974 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

                                            {
     const char* argv[] = {
       "foo.exe",
       "--gtest_list_tests=0",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse_f
	)

Definition at line 5990 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_list_tests=f",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse_F
	)

Definition at line 6006 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_list_tests=F",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		OutputEmpty
	)

Definition at line 6022 of file gtest_unittest.cc.

References argv, and GTEST_TEST_PARSING_FLAGS_.

                                         {
   const char* argv[] = {
     "foo.exe",
     "--gtest_output",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     "--gtest_output",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXml
	)

Definition at line 6039 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

                                       {
   const char* argv[] = {
     "foo.exe",
     "--gtest_output=xml",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXmlFile
	)

Definition at line 6055 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

                                           {
   const char* argv[] = {
     "foo.exe",
     "--gtest_output=xml:file",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXmlDirectory
	)

Definition at line 6071 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

                                                {
   const char* argv[] = {
     "foo.exe",
     "--gtest_output=xml:directory/path/",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2,
                             Flags::Output("xml:directory/path/"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFlag
	)

Definition at line 6088 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

                                           {
     const char* argv[] = {
       "foo.exe",
       "--gtest_print_time",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeTrue
	)

Definition at line 6104 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

                                           {
     const char* argv[] = {
       "foo.exe",
       "--gtest_print_time=1",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse
	)

Definition at line 6120 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

                                            {
     const char* argv[] = {
       "foo.exe",
       "--gtest_print_time=0",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse_f
	)

Definition at line 6136 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_print_time=f",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse_F
	)

Definition at line 6152 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

                                              {
   const char* argv[] = {
     "foo.exe",
     "--gtest_print_time=F",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		RandomSeed
	)

Definition at line 6168 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::RandomSeed().

                                        {
   const char* argv[] = {
     "foo.exe",
     "--gtest_random_seed=1000",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		Repeat
	)

Definition at line 6184 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Repeat().

                                    {
   const char* argv[] = {
     "foo.exe",
     "--gtest_repeat=1000",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsFlag
	)

Definition at line 6200 of file gtest_unittest.cc.

References testing::Flags::AlsoRunDisabledTests(), argv, and GTEST_TEST_PARSING_FLAGS_.

                                                      {
     const char* argv[] = {
       "foo.exe",
       "--gtest_also_run_disabled_tests",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
                               Flags::AlsoRunDisabledTests(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsTrue
	)

Definition at line 6217 of file gtest_unittest.cc.

References testing::Flags::AlsoRunDisabledTests(), argv, and GTEST_TEST_PARSING_FLAGS_.

                                                      {
     const char* argv[] = {
       "foo.exe",
       "--gtest_also_run_disabled_tests=1",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
                               Flags::AlsoRunDisabledTests(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsFalse
	)

Definition at line 6234 of file gtest_unittest.cc.

References testing::Flags::AlsoRunDisabledTests(), argv, and GTEST_TEST_PARSING_FLAGS_.

                                                       {
     const char* argv[] = {
       "foo.exe",
       "--gtest_also_run_disabled_tests=0",
       NULL
     };
 
     const char* argv2[] = {
       "foo.exe",
       NULL
     };
 
     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
                               Flags::AlsoRunDisabledTests(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleWithoutValue
	)

Definition at line 6251 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

                                                 {
   const char* argv[] = {
     "foo.exe",
     "--gtest_shuffle",
     NULL
 };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleFalse_0
	)

Definition at line 6267 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

                                            {
   const char* argv[] = {
     "foo.exe",
     "--gtest_shuffle=0",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleTrue
	)

Definition at line 6284 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

                                         {
   const char* argv[] = {
     "foo.exe",
     "--gtest_shuffle=1",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		StackTraceDepth
	)

Definition at line 6300 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::StackTraceDepth().

                                             {
   const char* argv[] = {
     "foo.exe",
     "--gtest_stack_trace_depth=5",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		StreamResultTo
	)

Definition at line 6315 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::StreamResultTo().

                                            {
   const char* argv[] = {
     "foo.exe",
     "--gtest_stream_result_to=localhost:1234",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(
       argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureWithoutValue
	)

Definition at line 6332 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ThrowOnFailure().

                                                        {
   const char* argv[] = {
     "foo.exe",
     "--gtest_throw_on_failure",
     NULL
 };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureFalse_0
	)

Definition at line 6348 of file gtest_unittest.cc.

References argv, GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ThrowOnFailure().

                                                   {
   const char* argv[] = {
     "foo.exe",
     "--gtest_throw_on_failure=0",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
 }

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureTrue
	)

Definition at line 6365 of file gtest_unittest.cc.

References argv, testing::Flags::break_on_failure, testing::internal::FilePath::c_str(), EXPECT_TRUE, f, FILE, testing::Flags::Filter(), testing::Flags::filter, testing::internal::posix::FOpen(), testing::internal::FilePath::GenerateUniqueFileName(), testing::internal::GetCurrentExecutableName(), GTEST_FLAG_PREFIX_, GTEST_TEST_PARSING_FLAGS_, testing::Flags::list_tests, testing::internal::posix::RmDir(), testing::InitGoogleTestTest::SetUp(), string, testing::Test::TearDown(), testing::internal::TempDir(), testing::internal::TEST_F(), testdata_path_, and testing::Flags::ThrowOnFailure().

                                                {
   const char* argv[] = {
     "foo.exe",
     "--gtest_throw_on_failure=1",
     NULL
   };
 
   const char* argv2[] = {
     "foo.exe",
     NULL
   };
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
 }

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForFirstTestInATestCase
	)

Definition at line 6533 of file gtest_unittest.cc.

References ASSERT_TRUE, testing::UnitTest::current_test_info(), EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::TestInfo::name(), and testing::TestInfo::test_case_name().

                                                           {
   const TestInfo* test_info =
     UnitTest::GetInstance()->current_test_info();
   ASSERT_TRUE(NULL != test_info)
       << "There is a test running so we should have a valid TestInfo.";
   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
       << "Expected the name of the currently running test case.";
   EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
       << "Expected the name of the currently running test.";
 }

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForSecondTestInATestCase
	)

Definition at line 6548 of file gtest_unittest.cc.

References ASSERT_TRUE, testing::UnitTest::current_test_info(), EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::TestInfo::name(), and testing::TestInfo::test_case_name().

                                                            {
   const TestInfo* test_info =
     UnitTest::GetInstance()->current_test_info();
   ASSERT_TRUE(NULL != test_info)
       << "There is a test running so we should have a valid TestInfo.";
   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
       << "Expected the name of the currently running test case.";
   EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
       << "Expected the name of the currently running test.";
 }

testing::TEST_P	(	CodeLocationForTESTP	,
		Verify
	)

Definition at line 5358 of file gtest_unittest.cc.

References INSTANTIATE_TEST_CASE_P(), and VERIFY_CODE_LOCATION.

                                      {
   VERIFY_CODE_LOCATION;
 }

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

static

Definition at line 2179 of file gtest.cc.

References testing::internal::CountIf(), testing::TestPartResult::fatally_failed(), testing::TestResult::HasFatalFailure(), and TestPartFatallyFailed().

                                                                 {
   return result.fatally_failed();
 }

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

static

Definition at line 2179 of file gtest.cc.

References testing::internal::CountIf(), testing::TestPartResult::fatally_failed(), testing::TestResult::HasFatalFailure(), and TestPartFatallyFailed().

                                                                 {
   return result.fatally_failed();
 }

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

static

Definition at line 2179 of file gtest.cc.

References testing::TestPartResult::fatally_failed().

Referenced by testing::TestResult::HasFatalFailure(), and TestPartFatallyFailed().

                                                                 {
   return result.fatally_failed();
 }

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

static

Definition at line 2189 of file gtest.cc.

                                                                    {
   return result.nonfatally_failed();
 }

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

static

Definition at line 2189 of file gtest.cc.

References testing::TestPartResult::nonfatally_failed().

Referenced by testing::TestResult::HasNonfatalFailure(), and TestPartNonfatallyFailed().

                                                                    {
   return result.nonfatally_failed();
 }

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

static

Definition at line 2189 of file gtest.cc.

                                                                    {
   return result.nonfatally_failed();
 }

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

static

Definition at line 2830 of file gtest.cc.

References testing::TestPartResult::kFatalFailure, testing::TestPartResult::kNonFatalFailure, and testing::TestPartResult::kSuccess.

Referenced by testing::internal::PrintTestPartResultToString().

                                                                         {
   switch (type) {
     case TestPartResult::kSuccess:
       return "Success";
 
     case TestPartResult::kNonFatalFailure:
     case TestPartResult::kFatalFailure:
 #ifdef _MSC_VER
       return "error: ";
 #else
       return "Failure\n";
 #endif
     default:
       return "Unknown result type";
   }
 }

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

static

Definition at line 2830 of file gtest.cc.

References testing::TestPartResult::kFatalFailure, testing::TestPartResult::kNonFatalFailure, and testing::TestPartResult::kSuccess.

                                                                         {
   switch (type) {
     case TestPartResult::kSuccess:
       return "Success";
 
     case TestPartResult::kNonFatalFailure:
     case TestPartResult::kFatalFailure:
 #ifdef _MSC_VER
       return "error: ";
 #else
       return "Failure\n";
 #endif
     default:
       return "Unknown result type";
   }
 }

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

static

Definition at line 2830 of file gtest.cc.

References testing::TestPartResult::kFatalFailure, testing::TestPartResult::kNonFatalFailure, and testing::TestPartResult::kSuccess.

                                                                         {
   switch (type) {
     case TestPartResult::kSuccess:
       return "Success";
 
     case TestPartResult::kNonFatalFailure:
     case TestPartResult::kFatalFailure:
 #ifdef _MSC_VER
       return "error: ";
 #else
       return "Failure\n";
 #endif
     default:
       return "Unknown result type";
   }
 }

template<typename Predicate >

PolymorphicMatcher< internal::TrulyMatcher< Predicate > > testing::Truly ( Predicate pred )

inline

Definition at line 4116 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::AStruct::AStruct(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::IsGreaterThan::operator()(), testing::gmock_matchers_test::TEST(), TEST(), testing::gmock_matchers_test::TEST_F(), and testing::gmock_matchers_test::IntValue::value().

                       {
   return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
 }

testing::TYPED_TEST	(	CodeLocationForTYPEDTEST	,
		Verify
	)

Definition at line 5370 of file gtest_unittest.cc.

References VERIFY_CODE_LOCATION.

Referenced by testing::internal::UnitTestHelper::GetSortedTests(), testing::gmock_matchers_test::NotCopyable::operator>=(), testing::internal::TEST(), testing::gmock_matchers_test::TEST(), and testing::internal::To::To().

                                              {
   VERIFY_CODE_LOCATION;
 }

testing::TYPED_TEST_CASE	(	CodeLocationForTYPEDTEST	,
		int
	)

testing::TYPED_TEST_CASE_P ( CodeLocationForTYPEDTESTP )

testing::TYPED_TEST_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

Definition at line 5380 of file gtest_unittest.cc.

References INSTANTIATE_TYPED_TEST_CASE_P(), REGISTER_TYPED_TEST_CASE_P(), and VERIFY_CODE_LOCATION.

                                                 {
   VERIFY_CODE_LOCATION;
 }

template<typename Lhs , typename Rhs >

Matcher< Lhs > testing::TypedEq ( const Rhs & rhs )

inline

Definition at line 3762 of file gmock-matchers.h.

References Eq().

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain().

3762 { return Eq(rhs); }

folly::detail::rhs

FOLLY_PUSH_WARNING RHS rhs

Definition: Traits.h:649

testing::Eq

internal::Eq2Matcher Eq()

Definition: gmock-matchers.h:4082

internal::UnorderedElementsAreMatcher<::testing::tuple<> > testing::UnorderedElementsAre ( )

inline

Definition at line 785 of file gmock-generated-matchers.h.

References Args().

Referenced by testing::gmock_matchers_test::EMString(), TEST(), and testing::gmock_matchers_test::TEST_F().

                        {
   typedef ::testing::tuple<> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args());
 }

template<typename T1 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type> > testing::UnorderedElementsAre ( const T1 & e1 )

inline

Definition at line 794 of file gmock-generated-matchers.h.

References Args().

                                    {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
 }

template<typename T1 , typename T2 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2
	)

inline

Definition at line 805 of file gmock-generated-matchers.h.

References Args().

                                                  {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
 }

template<typename T1 , typename T2 , typename T3 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3
	)

inline

Definition at line 818 of file gmock-generated-matchers.h.

References Args().

                                                                {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
 }

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

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4
	)

inline

Definition at line 833 of file gmock-generated-matchers.h.

References Args().

                                                                              {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
 }

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

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5
	)

inline

Definition at line 850 of file gmock-generated-matchers.h.

References Args().

                   {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
 }

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

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6
	)

inline

Definition at line 871 of file gmock-generated-matchers.h.

References Args().

                                 {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
       e6));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7
	)

inline

Definition at line 895 of file gmock-generated-matchers.h.

References Args().

                                               {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
       e6, e7));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8
	)

inline

Definition at line 921 of file gmock-generated-matchers.h.

References Args().

                                                             {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
       e6, e7, e8));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type, typename internal::DecayArray<T9>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8,
		const T9 &	e9
	)

inline

Definition at line 949 of file gmock-generated-matchers.h.

References Args().

                                                                           {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type,
       typename internal::DecayArray<T9>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
       e6, e7, e8, e9));
 }

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >

internal::UnorderedElementsAreMatcher< ::testing::tuple< typename internal::DecayArray<T1>::type, typename internal::DecayArray<T2>::type, typename internal::DecayArray<T3>::type, typename internal::DecayArray<T4>::type, typename internal::DecayArray<T5>::type, typename internal::DecayArray<T6>::type, typename internal::DecayArray<T7>::type, typename internal::DecayArray<T8>::type, typename internal::DecayArray<T9>::type, typename internal::DecayArray<T10>::type> > testing::UnorderedElementsAre	(	const T1 &	e1,
		const T2 &	e2,
		const T3 &	e3,
		const T4 &	e4,
		const T5 &	e5,
		const T6 &	e6,
		const T7 &	e7,
		const T8 &	e8,
		const T9 &	e9,
		const T10 &	e10
	)

inline

Definition at line 979 of file gmock-generated-matchers.h.

References Args().

                     {
   typedef ::testing::tuple<
       typename internal::DecayArray<T1>::type,
       typename internal::DecayArray<T2>::type,
       typename internal::DecayArray<T3>::type,
       typename internal::DecayArray<T4>::type,
       typename internal::DecayArray<T5>::type,
       typename internal::DecayArray<T6>::type,
       typename internal::DecayArray<T7>::type,
       typename internal::DecayArray<T8>::type,
       typename internal::DecayArray<T9>::type,
       typename internal::DecayArray<T10>::type> Args;
   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
       e6, e7, e8, e9, e10));
 }

template<typename Iter >

internal::UnorderedElementsAreArrayMatcher< typename::std::iterator_traits< Iter >::value_type > testing::UnorderedElementsAreArray	(	Iter	first,
		Iter	last
	)

inline

Definition at line 3688 of file gmock-matchers.h.

References folly::gen::first, and T.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), testing::gmock_matchers_test::TEST(), testing::gmock_matchers_test::TEST_F(), UnorderedElementsAreArray(), and UnorderedPointwise().

                                                  {
   typedef typename ::std::iterator_traits<Iter>::value_type T;
   return internal::UnorderedElementsAreArrayMatcher<T>(first, last);
 }

template<typename T >

internal::UnorderedElementsAreArrayMatcher< T > testing::UnorderedElementsAreArray	(	const T *	pointer,
		size_t	count
	)

inline

Definition at line 3695 of file gmock-matchers.h.

References UnorderedElementsAreArray().

                                                           {
   return UnorderedElementsAreArray(pointer, pointer + count);
 }

template<typename T , size_t N>

internal::UnorderedElementsAreArrayMatcher< T > testing::UnorderedElementsAreArray ( const T(&) array[N] )

inline

Definition at line 3701 of file gmock-matchers.h.

References UnorderedElementsAreArray().

                                                {
   return UnorderedElementsAreArray(array, N);
 }

template<typename Container >

internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > testing::UnorderedElementsAreArray ( const Container & container )

inline

Definition at line 3708 of file gmock-matchers.h.

References UnorderedElementsAreArray().

                                                       {
   return UnorderedElementsAreArray(container.begin(), container.end());
 }

template<typename Tuple2Matcher , typename RhsContainer >

internal::UnorderedElementsAreArrayMatcher< typename internal::BoundSecondMatcher< Tuple2Matcher, typename internal::StlContainerView< GTEST_REMOVE_CONST_(RhsContainer)>::type::value_type > > testing::UnorderedPointwise	(	const Tuple2Matcher &	tuple2_matcher,
		const RhsContainer &	rhs_container
	)

inline

Definition at line 4223 of file gmock-matchers.h.

References GTEST_REMOVE_CONST_, testing::internal::MatcherBindSecond(), type, and UnorderedElementsAreArray().

                                                       {
   // This following line is for working around a bug in MSVC 8.0,
   // which causes RhsContainer to be a const type sometimes (e.g. when
   // rhs_container is a const int[]).
   typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
 
   // RhsView allows the same code to handle RhsContainer being a
   // STL-style container and it being a native C-style array.
   typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
   typedef typename RhsView::type RhsStlContainer;
   typedef typename RhsStlContainer::value_type Second;
   const RhsStlContainer& rhs_stl_container =
       RhsView::ConstReference(rhs_container);
 
   // Create a matcher for each element in rhs_container.
   ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
   for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
        it != rhs_stl_container.end(); ++it) {
     matchers.push_back(
         internal::MatcherBindSecond(tuple2_matcher, *it));
   }
 
   // Delegate the work to UnorderedElementsAreArray().
   return UnorderedElementsAreArray(matchers);
 }

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

Definition at line 2141 of file gtest.cc.

References ADD_FAILURE, FormatWordList(), and GTEST_NAME_.

Referenced by FormatWordList(), and testing::TestResult::ValidateTestProperty().

                                                                           {
   if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
           reserved_names.end()) {
     ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
                   << " (" << FormatWordList(reserved_names)
                   << " are reserved by " << GTEST_NAME_ << ")";
     return false;
   }
   return true;
 }

template<typename T , typename M >

bool testing::Value	(	const T &	value,
		M	matcher
	)

inline

Definition at line 4347 of file gmock-matchers.h.

References Matches(), and value.

                                              {
   return testing::Matches(matcher)(value);
 }

template<typename To >

PolymorphicMatcher< internal::WhenDynamicCastToMatcher< To > > testing::WhenDynamicCastTo ( const Matcher< To > & inner_matcher )

inline

Definition at line 3885 of file gmock-matchers.h.

References MakePolymorphicMatcher().

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain().

                                                     {
   return MakePolymorphicMatcher(
       internal::WhenDynamicCastToMatcher<To>(inner_matcher));
 }

template<typename ContainerMatcher >

internal::WhenSortedByMatcher< internal::LessComparator, ContainerMatcher > testing::WhenSorted ( const ContainerMatcher & container_matcher )

inline

Definition at line 4172 of file gmock-matchers.h.

References GTEST_REMOVE_CONST_.

                                                       {
   return
       internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
           internal::LessComparator(), container_matcher);
 }

template<typename Comparator , typename ContainerMatcher >

internal::WhenSortedByMatcher< Comparator, ContainerMatcher > testing::WhenSortedBy	(	const Comparator &	comparator,
		const ContainerMatcher &	container_matcher
	)

inline

Definition at line 4162 of file gmock-matchers.h.

References folly::symbolizer::test::comparator().

                                                         {
   return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
       comparator, container_matcher);
 }

template<int k, typename InnerAction >

internal::WithArgsAction< InnerAction, k > testing::WithArg ( const InnerAction & action )

inline

Definition at line 146 of file gmock-more-actions.h.

References upload::action.

Referenced by testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform().

                                    {
   return internal::WithArgsAction<InnerAction, k>(action);
 }

template<int k1, typename InnerAction >

internal::WithArgsAction< InnerAction, k1 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 625 of file gmock-generated-actions.h.

References upload::action.

Referenced by testing::internal::ActionHelper< Result, Impl >::Perform().

                                     {
   return internal::WithArgsAction<InnerAction, k1>(action);
 }

template<int k1, int k2, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 631 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2>(action);
 }

template<int k1, int k2, int k3, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 637 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
 }

template<int k1, int k2, int k3, int k4, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 643 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 649 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 655 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 662 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
       k7>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 670 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
       k8>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 678 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
       k9>(action);
 }

template<int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, int k9, int k10, typename InnerAction >

internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > testing::WithArgs ( const InnerAction & action )

inline

Definition at line 687 of file gmock-generated-actions.h.

References upload::action.

                                     {
   return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
       k9, k10>(action);
 }

template<typename InnerAction >

internal::WithArgsAction< InnerAction > testing::WithoutArgs ( const InnerAction & action )

inline

Definition at line 135 of file gmock-more-actions.h.

References upload::action.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform(), TEST(), and testing::gmock_more_actions_test::TEST().

                                        {
   return internal::WithArgsAction<InnerAction>(action);
 }

Variable Documentation

const internal::AnythingMatcher testing::_ = {}

Definition at line 3729 of file gmock-matchers.h.

class GTEST_API_ testing::InSequence testing::GTEST_ATTRIBUTE_UNUSED_

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

static

Definition at line 165 of file gtest.cc.

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

static

Definition at line 165 of file gtest.cc.

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

static

Definition at line 165 of file gtest.cc.

const char testing::kDefaultDeathTestStyle[] = "fast"

static

Definition at line 84 of file gtest-death-test.cc.

const char testing::kDefaultDeathTestStyle[] = "fast"

static

Definition at line 84 of file gtest-death-test.cc.

const char testing::kDefaultDeathTestStyle[] = "fast"

static

Definition at line 84 of file gtest-death-test.cc.

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

static

Definition at line 171 of file gtest.cc.

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

static

Definition at line 171 of file gtest.cc.

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

static

Definition at line 171 of file gtest.cc.

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

static

Definition at line 160 of file gtest.cc.

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

static

Definition at line 160 of file gtest.cc.

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

static

Definition at line 160 of file gtest.cc.

const int testing::kMaxStackTraceDepth = 100

Definition at line 147 of file gtest.h.

Referenced by GetDefaultFilter(), folly::SingletonVault::scheduleDestroyInstances(), testing::InitGoogleTestTest::SetUp(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

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

Definition at line 2098 of file gtest.cc.

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

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

Definition at line 2098 of file gtest.cc.

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

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

Definition at line 2098 of file gtest.cc.

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

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

Definition at line 2088 of file gtest.cc.

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

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

Definition at line 2088 of file gtest.cc.

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

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

Definition at line 2088 of file gtest.cc.

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

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

Definition at line 2075 of file gtest.cc.

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

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

Definition at line 2075 of file gtest.cc.

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

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

Definition at line 2075 of file gtest.cc.

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

static

Definition at line 174 of file gtest.cc.

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

static

Definition at line 174 of file gtest.cc.

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

static

Definition at line 174 of file gtest.cc.

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

static

Definition at line 178 of file gtest.cc.

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

static

Definition at line 178 of file gtest.cc.

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

static

Definition at line 178 of file gtest.cc.

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

static

Definition at line 176 of file gtest.cc.

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

static

Definition at line 176 of file gtest.cc.

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

static

Definition at line 176 of file gtest.cc.

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

static

Definition at line 168 of file gtest.cc.

Referenced by testing::internal::UnitTestOptions::FilterMatchesTest(), GetDefaultFilter(), and testing::internal::ShouldRunTestCase().

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

static

Definition at line 168 of file gtest.cc.

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

static

Definition at line 168 of file gtest.cc.

testing::internal::Function< F >::Result testing::p0_type

Definition at line 2216 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p1_type

Definition at line 2225 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p2_type

Definition at line 2234 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p3_type

Definition at line 2243 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p4_type

Definition at line 2252 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p5_type

Definition at line 2261 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p6_type

Definition at line 2270 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p7_type

Definition at line 2279 of file gmock-generated-actions.h.

testing::internal::Function< F >::Result testing::p8_type

Definition at line 2288 of file gmock-generated-actions.h.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation