testing Namespace Reference

Namespaces
namespace	internal
namespace	gmock_generated_actions_test
namespace	gmock_generated_function_mockers_test
namespace	gmock_matchers_test
namespace	gmock_more_actions_test
namespace	gmock_nice_strict_test
namespace	internal2
namespace	gtest_printers_test

Classes
class	DefaultValue
class	DefaultValue< T & >
class	DefaultValue< void >
class	ActionInterface
class	Action
class	PolymorphicAction
class	CardinalityInterface
class	Cardinality
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	NiceMock
class	NaggyMock
class	StrictMock
class	MatchResultListener
class	MatcherDescriberInterface
class	MatcherInterface
class	StringMatchResultListener
class	Matcher
class	Matcher< const internal::string & >
class	Matcher< internal::string >
class	PolymorphicMatcher
class	SafeMatcherCastImpl
class	Mock
class	Expectation
class	ExpectationSet
class	Sequence
class	InSequence
class	Message
class	ScopedFakeTestPartResultReporter
class	TestPartResult
class	TestPartResultArray
class	TestPartResultReporterInterface
class	AssertionResult
class	Test
class	TestProperty
class	TestResult
class	TestInfo
class	TestCase
class	Environment
class	TestEventListener
class	EmptyTestEventListener
class	TestEventListeners
class	UnitTest
class	TestInfoTest
class	CodeLocationForTESTF
class	CodeLocationForTESTP
class	CodeLocationForTYPEDTEST
class	CodeLocationForTYPEDTESTP
class	SetUpTestCaseTest
struct	Flags
class	InitGoogleTestTest
class	CurrentTestInfoTest
class	FunctionMocker
class	MockSpec
class	linked_ptr

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)
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(p0))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_2_VALUE_PARAMS(p0, p1))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_3_VALUE_PARAMS(p0, p1, p2))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_4_VALUE_PARAMS(p0, p1, p2, p3))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8))
	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_0_VALUE_PARAMS())
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_1_VALUE_PARAMS(p0))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_2_VALUE_PARAMS(p0, p1))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_3_VALUE_PARAMS(p0, p1, p2))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_4_VALUE_PARAMS(p0, p1, p2, p3))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8))
	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
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)
class UnitTestImpl *	GetUnitTestImpl ()
template<class Container, typename Predicate>
int	CountIf (const Container &c, Predicate predicate)
template<class Container, typename Functor>
void	ForEach (const Container &c, Functor functor)
template<typename E>
E	GetElementOr (const std::vector< E > &v, int i, E default_value)
template<typename E>
void	Shuffle (internal::Random *random, std::vector< E > *v)
class UnitTestImpl *	GetUnitTestImpl ()
template<class Container, typename Predicate>
int	CountIf (const Container &c, Predicate predicate)
template<class Container, typename Functor>
void	ForEach (const Container &c, Functor functor)
template<typename E>
E	GetElementOr (const std::vector< E > &v, int i, E default_value)
template<typename E>
void	Shuffle (internal::Random *random, std::vector< E > *v)

Variables
template<typename T>
DefaultValue< T >::ValueProducer *	DefaultValue< T >::producer_ = NULL
template<typename T>
T *	DefaultValue< T & >::address_ = NULL
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 []

Typedef Documentation

TimeInMillis

typedef internal::TimeInMillis testing::TimeInMillis

Unused

typedef internal::IgnoredValue testing::Unused

Function Documentation

A()

template<typename T>

Matcher< T > testing::A ( )

inline

ACTION_P()

testing::ACTION_P	(	ReturnPointee	,
		pointer	)

ACTION_TEMPLATE() [1/28]

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

ACTION_TEMPLATE() [2/28]

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

ACTION_TEMPLATE() [3/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)	)

ACTION_TEMPLATE() [4/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(p0)	)

ACTION_TEMPLATE() [5/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_2_VALUE_PARAMS(p0, p1)	)

ACTION_TEMPLATE() [6/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_3_VALUE_PARAMS(p0, p1, p2)	)

ACTION_TEMPLATE() [7/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_4_VALUE_PARAMS(p0, p1, p2, p3)	)

ACTION_TEMPLATE() [8/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)	)

ACTION_TEMPLATE() [9/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)	)

ACTION_TEMPLATE() [10/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)	)

ACTION_TEMPLATE() [11/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)	)

ACTION_TEMPLATE() [12/28]

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)	)

ACTION_TEMPLATE() [13/28]

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

ACTION_TEMPLATE() [14/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_0_VALUE_PARAMS()	)

ACTION_TEMPLATE() [15/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)	)

ACTION_TEMPLATE() [16/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_1_VALUE_PARAMS(p0)	)

ACTION_TEMPLATE() [17/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_2_VALUE_PARAMS(p0, p1)	)

ACTION_TEMPLATE() [18/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_3_VALUE_PARAMS(p0, p1, p2)	)

ACTION_TEMPLATE() [19/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_4_VALUE_PARAMS(p0, p1, p2, p3)	)

ACTION_TEMPLATE() [20/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)	)

ACTION_TEMPLATE() [21/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)	)

ACTION_TEMPLATE() [22/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)	)

ACTION_TEMPLATE() [23/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)	)

ACTION_TEMPLATE() [24/28]

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)	)

ACTION_TEMPLATE() [25/28]

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

ACTION_TEMPLATE() [26/28]

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

ACTION_TEMPLATE() [27/28]

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

ACTION_TEMPLATE() [28/28]

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

AddGlobalTestEnvironment()

Environment * testing::AddGlobalTestEnvironment ( Environment * env )

inline

AllArgs()

template<typename InnerMatcher>

InnerMatcher testing::AllArgs ( const InnerMatcher & matcher )

inline

AllOf() [1/9]

template<typename M1, typename M2>

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

inline

AllOf() [2/9]

template<typename M1, typename M2, typename M3>

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

inline

AllOf() [3/9]

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

AllOf() [4/9]

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

AllOf() [5/9]

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

AllOf() [6/9]

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

AllOf() [7/9]

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

AllOf() [8/9]

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

AllOf() [9/9]

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

An()

template<typename T>

Matcher< T > testing::An ( )

inline

AnyNumber()

GTEST_API_ Cardinality testing::AnyNumber

(

)

AnyOf() [1/9]

template<typename M1, typename M2>

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

inline

AnyOf() [2/9]

template<typename M1, typename M2, typename M3>

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

inline

AnyOf() [3/9]

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

AnyOf() [4/9]

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

AnyOf() [5/9]

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

AnyOf() [6/9]

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

AnyOf() [7/9]

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

AnyOf() [8/9]

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

AnyOf() [9/9]

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

Args() [1/11]

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

Args() [2/11]

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

Args() [3/11]

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

Args() [4/11]

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

Args() [5/11]

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

Args() [6/11]

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

Args() [7/11]

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

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

inline

Args() [8/11]

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

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

inline

Args() [9/11]

template<int k1, int k2, typename InnerMatcher>

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

inline

Args() [10/11]

template<int k1, typename InnerMatcher>

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

inline

Args() [11/11]

template<typename InnerMatcher>

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

inline

ArrayAsVector()

template<int kSize>

std::vector< std::string > testing::ArrayAsVector

(

const char *const (&)

array[kSize]

)

AssertionFailure() [1/2]

AssertionResult testing::AssertionFailure

(

)

AssertionFailure() [2/2]

AssertionResult testing::AssertionFailure

(

const Message &

msg

)

AssertionSuccess()

AssertionResult testing::AssertionSuccess

(

)

Assign()

template<typename T1, typename T2>

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

AtLeast()

GTEST_API_ Cardinality testing::AtLeast

(

int

n

)

AtMost()

GTEST_API_ Cardinality testing::AtMost

(

int

n

)

BeginEndDistanceIs()

template<typename DistanceMatcher>

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

inline

Between()

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

ByMove()

template<typename R>

internal::ByMoveWrapper< R > testing::ByMove

(

R

x

)

ByRef()

template<typename T>

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

inline

Const()

template<typename T>

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

inline

ContainerEq()

template<typename Container>

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

inline

Contains()

template<typename M>

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

inline

ContainsRegex() [1/2]

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

inline

ContainsRegex() [2/2]

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

inline

CountIf() [1/2]

template<class Container, typename Predicate>

int testing::internal::CountIf ( const Container & c, Predicate predicate )

inline

CountIf() [2/2]

template<class Container, typename Predicate>

int testing::internal::CountIf ( const Container & c, Predicate predicate )

inline

DoAll() [1/9]

template<typename Action1, typename Action2>

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

inline

DoAll() [2/9]

template<typename Action1, typename Action2, typename Action3>

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

inline

DoAll() [3/9]

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

DoAll() [4/9]

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

DoAll() [5/9]

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

DoAll() [6/9]

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

DoAll() [7/9]

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

DoAll() [8/9]

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

DoAll() [9/9]

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

DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

DoubleEq()

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

inline

DoubleLE()

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

DoubleNear()

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

inline

Each()

template<typename M>

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

inline

ElementsAre() [1/11]

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

inline

ElementsAre() [2/11]

template<typename T1>

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

inline

ElementsAre() [3/11]

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

ElementsAre() [4/11]

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

ElementsAre() [5/11]

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

ElementsAre() [6/11]

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

ElementsAre() [7/11]

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

ElementsAre() [8/11]

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

ElementsAre() [9/11]

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

ElementsAre() [10/11]

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

ElementsAre() [11/11]

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

ElementsAreArray() [1/4]

template<typename Container>

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

inline

ElementsAreArray() [2/4]

template<typename T>

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

inline

ElementsAreArray() [3/4]

template<typename T, size_t N>

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

inline

ElementsAreArray() [4/4]

template<typename Iter>

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

inline

EndsWith()

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

inline

Eq() [1/2]

internal::Eq2Matcher testing::Eq ( )

inline

Eq() [2/2]

template<typename T>

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

inline

Exactly()

GTEST_API_ Cardinality testing::Exactly

(

int

n

)

ExplainMatchResult()

template<typename T, typename M>

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

inline

Field()

template<typename Class, typename FieldType, typename FieldMatcher>

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

inline

FloatEq()

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

inline

FloatLE()

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

FloatNear()

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

inline

ForEach() [1/2]

template<class Container, typename Functor>

void testing::internal::ForEach	(	const Container &	c,
		Functor	functor )

ForEach() [2/2]

template<class Container, typename Functor>

void testing::internal::ForEach	(	const Container &	c,
		Functor	functor )

FormatCountableNoun() [1/2]

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

static

FormatCountableNoun() [2/2]

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

static

FormatTestCaseCount() [1/2]

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

static

FormatTestCaseCount() [2/2]

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

static

FormatTestCount() [1/2]

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

static

FormatTestCount() [2/2]

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

static

FormatWordList() [1/2]

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

static

FormatWordList() [2/2]

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

static

Ge() [1/2]

internal::Ge2Matcher testing::Ge ( )

inline

Ge() [2/2]

template<typename Rhs>

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

inline

GetDefaultFilter() [1/2]

const char * testing::GetDefaultFilter ( )

static

GetDefaultFilter() [2/2]

const char * testing::GetDefaultFilter ( )

static

GetElementOr() [1/2]

template<typename E>

E testing::internal::GetElementOr ( const std::vector< E > & v, int i, E default_value )

inline

GetElementOr() [2/2]

template<typename E>

E testing::internal::GetElementOr ( const std::vector< E > & v, int i, E default_value )

inline

GetReservedAttributesForElement() [1/2]

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

static

GetReservedAttributesForElement() [2/2]

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

static

GetUnitTestImpl() [1/2]

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

GetUnitTestImpl() [2/2]

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

GMOCK_DECLARE_bool_()

testing::GMOCK_DECLARE_bool_

(

catch_leaked_mocks

)

GMOCK_DECLARE_string_()

testing::GMOCK_DECLARE_string_

(

verbose

)

GMOCK_DEFINE_bool_()

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

GMOCK_DEFINE_string_()

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."	)

Gt() [1/2]

internal::Gt2Matcher testing::Gt ( )

inline

Gt() [2/2]

template<typename Rhs>

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

inline

GTEST_DECLARE_bool_() [1/9]

testing::GTEST_DECLARE_bool_

(

also_run_disabled_tests

)

GTEST_DECLARE_bool_() [2/9]

testing::GTEST_DECLARE_bool_

(

break_on_failure

)

GTEST_DECLARE_bool_() [3/9]

testing::GTEST_DECLARE_bool_

(

catch_exceptions

)

GTEST_DECLARE_bool_() [4/9]

testing::GTEST_DECLARE_bool_

(

death_test_use_fork

)

GTEST_DECLARE_bool_() [5/9]

testing::GTEST_DECLARE_bool_

(

list_tests

)

GTEST_DECLARE_bool_() [6/9]

testing::GTEST_DECLARE_bool_

(

print_time

)

GTEST_DECLARE_bool_() [7/9]

testing::GTEST_DECLARE_bool_

(

show_internal_stack_frames

)

GTEST_DECLARE_bool_() [8/9]

testing::GTEST_DECLARE_bool_

(

shuffle

)

GTEST_DECLARE_bool_() [9/9]

testing::GTEST_DECLARE_bool_

(

throw_on_failure

)

GTEST_DECLARE_int32_() [1/3]

testing::GTEST_DECLARE_int32_

(

random_seed

)

GTEST_DECLARE_int32_() [2/3]

testing::GTEST_DECLARE_int32_

(

repeat

)

GTEST_DECLARE_int32_() [3/3]

testing::GTEST_DECLARE_int32_

(

stack_trace_depth

)

GTEST_DECLARE_string_() [1/5]

testing::GTEST_DECLARE_string_

(

color

)

GTEST_DECLARE_string_() [2/5]

testing::GTEST_DECLARE_string_

(

death_test_style

)

GTEST_DECLARE_string_() [3/5]

testing::GTEST_DECLARE_string_

(

filter

)

GTEST_DECLARE_string_() [4/5]

testing::GTEST_DECLARE_string_

(

output

)

GTEST_DECLARE_string_() [5/5]

testing::GTEST_DECLARE_string_

(

stream_result_to

)

GTEST_DEFINE_bool_() [1/9]

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."	)

GTEST_DEFINE_bool_() [2/9]

testing::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_() [3/9]

testing::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_bool_() [4/9]

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."	)

GTEST_DEFINE_bool_() [5/9]

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

GTEST_DEFINE_bool_() [6/9]

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

GTEST_DEFINE_bool_() [7/9]

testing::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_() [8/9]

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

GTEST_DEFINE_bool_() [9/9]

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."	)

GTEST_DEFINE_int32_() [1/3]

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."	)

GTEST_DEFINE_int32_() [2/3]

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."	)

GTEST_DEFINE_int32_() [3/3]

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."	)

GTEST_DEFINE_string_() [1/5]

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."	)

GTEST_DEFINE_string_() [2/5]

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)."	)

GTEST_DEFINE_string_() [3/5]

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."	)

GTEST_DEFINE_string_() [4/5]

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."	)

GTEST_DEFINE_string_() [5/5]

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."	)

HasSubstr()

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

inline

IgnoreResult()

template<typename A>

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

inline

InitGoogleMock() [1/2]

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

InitGoogleMock() [2/2]

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

InitGoogleTest() [1/2]

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

InitGoogleTest() [2/2]

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

INSTANTIATE_TEST_CASE_P()

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

INSTANTIATE_TYPED_TEST_CASE_P()

testing::INSTANTIATE_TYPED_TEST_CASE_P	(	My	,
		CodeLocationForTYPEDTESTP	,
		int	)

Invoke() [1/2]

template<class Class, typename MethodPtr>

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

Invoke() [2/2]

template<typename FunctionImpl>

PolymorphicAction< internal::InvokeAction< FunctionImpl > > testing::Invoke

(

FunctionImpl

function_impl

)

InvokeWithoutArgs() [1/2]

template<class Class, typename MethodPtr>

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

InvokeWithoutArgs() [2/2]

template<typename FunctionImpl>

PolymorphicAction< internal::InvokeWithoutArgsAction< FunctionImpl > > testing::InvokeWithoutArgs

(

FunctionImpl

function_impl

)

IsNotSubstring() [1/3]

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

IsNotSubstring() [2/3]

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

IsNotSubstring() [3/3]

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

IsNull()

PolymorphicMatcher< internal::IsNullMatcher > testing::IsNull ( )

inline

IsSubstring() [1/3]

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

IsSubstring() [2/3]

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

IsSubstring() [3/3]

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

Key()

template<typename M>

internal::KeyMatcher< M > testing::Key ( M inner_matcher )

inline

Le() [1/2]

internal::Le2Matcher testing::Le ( )

inline

Le() [2/2]

template<typename Rhs>

internal::LeMatcher< Rhs > testing::Le ( Rhs x )

inline

Lt() [1/2]

internal::Lt2Matcher testing::Lt ( )

inline

Lt() [2/2]

template<typename Rhs>

internal::LtMatcher< Rhs > testing::Lt ( Rhs x )

inline

MakeAction()

template<typename F>

Action< F > testing::MakeAction

(

ActionInterface< F > *

impl

)

MakeCardinality()

Cardinality testing::MakeCardinality ( const CardinalityInterface * c )

inline

MakeMatcher()

template<typename T>

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

inline

MakePolymorphicAction()

template<typename Impl>

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

inline

MakePolymorphicMatcher()

template<class Impl>

PolymorphicMatcher< Impl > testing::MakePolymorphicMatcher ( const Impl & impl )

inline

MATCHER()

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

MatcherCast()

template<typename T, typename M>

Matcher< T > testing::MatcherCast ( const M & matcher )

inline

Matches()

template<typename M>

internal::MatcherAsPredicate< M > testing::Matches ( M matcher )

inline

MatchesRegex() [1/2]

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

inline

MatchesRegex() [2/2]

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

inline

NanSensitiveDoubleEq()

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

inline

NanSensitiveDoubleNear()

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

inline

NanSensitiveFloatEq()

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

inline

NanSensitiveFloatNear()

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

inline

Ne() [1/2]

internal::Ne2Matcher testing::Ne ( )

inline

Ne() [2/2]

template<typename Rhs>

internal::NeMatcher< Rhs > testing::Ne ( Rhs x )

inline

Not()

template<typename InnerMatcher>

internal::NotMatcher< InnerMatcher > testing::Not ( InnerMatcher m )

inline

NotNull()

PolymorphicMatcher< internal::NotNullMatcher > testing::NotNull ( )

inline

operator<<() [1/2]

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

inline

operator<<() [2/2]

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

Pair()

template<typename FirstMatcher, typename SecondMatcher>

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

inline

Pointee()

template<typename InnerMatcher>

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

inline

Pointwise()

template<typename TupleMatcher, typename Container>

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

inline

PrintFlag()

void testing::PrintFlag

(

const char *

flag

)

PrintToString()

template<typename T>

::std::string testing::PrintToString

(

const T &

value

)

Property()

template<typename Class, typename PropertyType, typename PropertyMatcher>

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

inline

Ref()

template<typename T>

internal::RefMatcher< T & > testing::Ref ( T & x )

inline

REGISTER_TYPED_TEST_CASE_P()

testing::REGISTER_TYPED_TEST_CASE_P	(	CodeLocationForTYPEDTESTP	,
		Verify	)

ResultOf()

template<typename Callable, typename ResultOfMatcher>

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

Return() [1/2]

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

inline

Return() [2/2]

template<typename R>

internal::ReturnAction< R > testing::Return

(

R

value

)

ReturnNull()

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

inline

ReturnRef()

template<typename R>

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

inline

ReturnRefOfCopy()

template<typename R>

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

inline

SafeMatcherCast()

template<typename T, typename M>

Matcher< T > testing::SafeMatcherCast ( const M & polymorphic_matcher )

inline

SetArgPointee() [1/3]

template<size_t N>

PolymorphicAction< internal::SetArgumentPointeeAction< N, const char *, false > > testing::SetArgPointee

(

const char *

p

)

SetArgPointee() [2/3]

template<size_t N, typename T>

PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > > testing::SetArgPointee

(

const T &

x

)

SetArgPointee() [3/3]

template<size_t N>

PolymorphicAction< internal::SetArgumentPointeeAction< N, const wchar_t *, false > > testing::SetArgPointee

(

const wchar_t *

p

)

SetArgumentPointee()

template<size_t N, typename T>

PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > > testing::SetArgumentPointee

(

const T &

x

)

SetErrnoAndReturn()

template<typename T>

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

Shuffle() [1/2]

template<typename E>

void testing::internal::Shuffle ( internal::Random * random, std::vector< E > * v )

inline

Shuffle() [2/2]

template<typename E>

void testing::internal::Shuffle ( internal::Random * random, std::vector< E > * v )

inline

SizeIs()

template<typename SizeMatcher>

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

inline

StartsWith()

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

inline

StaticAssertTypeEq()

template<typename T1, typename T2>

bool testing::StaticAssertTypeEq

(

)

StrCaseEq()

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

inline

StrCaseNe()

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

inline

StrEq()

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

inline

StrNe()

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

inline

TEST() [1/7]

testing::TEST	(	CodeLocationForTEST	,
		Verify	)

TEST() [2/7]

testing::TEST	(	GTestEnvVarTest	,
		Dummy	)

TEST() [3/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT	)

TEST() [4/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT_STR	)

TEST() [5/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT	)

TEST() [6/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT_STR	)

TEST() [7/7]

testing::TEST	(	SuccessfulAssertionTest	,
		SUCCEED	)

TEST_F() [1/48]

testing::TEST_F	(	CodeLocationForTESTF	,
		Verify	)

TEST_F() [2/48]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForFirstTestInATestCase	)

TEST_F() [3/48]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForSecondTestInATestCase	)

TEST_F() [4/48]

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsFalse	)

TEST_F() [5/48]

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsFlag	)

TEST_F() [6/48]

testing::TEST_F	(	InitGoogleTestTest	,
		AlsoRunDisabledTestsTrue	)

TEST_F() [7/48]

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_0	)

TEST_F() [8/48]

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_F	)

TEST_F() [9/48]

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureFalse_f	)

TEST_F() [10/48]

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureTrue	)

TEST_F() [11/48]

testing::TEST_F	(	InitGoogleTestTest	,
		BreakOnFailureWithoutValue	)

TEST_F() [12/48]

testing::TEST_F	(	InitGoogleTestTest	,
		CatchExceptions	)

TEST_F() [13/48]

testing::TEST_F	(	InitGoogleTestTest	,
		DeathTestUseFork	)

TEST_F() [14/48]

testing::TEST_F	(	InitGoogleTestTest	,
		DuplicatedFlags	)

TEST_F() [15/48]

testing::TEST_F	(	InitGoogleTestTest	,
		Empty	)

TEST_F() [16/48]

testing::TEST_F	(	InitGoogleTestTest	,
		FilterBad	)

TEST_F() [17/48]

testing::TEST_F	(	InitGoogleTestTest	,
		FilterEmpty	)

TEST_F() [18/48]

testing::TEST_F	(	InitGoogleTestTest	,
		FilterNonEmpty	)

TEST_F() [19/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse	)

TEST_F() [20/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse_F	)

TEST_F() [21/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFalse_f	)

TEST_F() [22/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsFlag	)

TEST_F() [23/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ListTestsTrue	)

TEST_F() [24/48]

testing::TEST_F	(	InitGoogleTestTest	,
		NoFlag	)

TEST_F() [25/48]

testing::TEST_F	(	InitGoogleTestTest	,
		OutputEmpty	)

TEST_F() [26/48]

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXml	)

TEST_F() [27/48]

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXmlDirectory	)

TEST_F() [28/48]

testing::TEST_F	(	InitGoogleTestTest	,
		OutputXmlFile	)

TEST_F() [29/48]

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse	)

TEST_F() [30/48]

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse_F	)

TEST_F() [31/48]

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFalse_f	)

TEST_F() [32/48]

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeFlag	)

TEST_F() [33/48]

testing::TEST_F	(	InitGoogleTestTest	,
		PrintTimeTrue	)

TEST_F() [34/48]

testing::TEST_F	(	InitGoogleTestTest	,
		RandomSeed	)

TEST_F() [35/48]

testing::TEST_F	(	InitGoogleTestTest	,
		Repeat	)

TEST_F() [36/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleFalse_0	)

TEST_F() [37/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleTrue	)

TEST_F() [38/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ShuffleWithoutValue	)

TEST_F() [39/48]

testing::TEST_F	(	InitGoogleTestTest	,
		StackTraceDepth	)

TEST_F() [40/48]

testing::TEST_F	(	InitGoogleTestTest	,
		StreamResultTo	)

TEST_F() [41/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureFalse_0	)

TEST_F() [42/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureTrue	)

TEST_F() [43/48]

testing::TEST_F	(	InitGoogleTestTest	,
		ThrowOnFailureWithoutValue	)

TEST_F() [44/48]

testing::TEST_F	(	InitGoogleTestTest	,
		UnrecognizedFlag	)

TEST_F() [45/48]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test1	)

TEST_F() [46/48]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test2	)

TEST_F() [47/48]

testing::TEST_F	(	TestInfoTest	,
		Names	)

TEST_F() [48/48]

testing::TEST_F	(	TestInfoTest	,
		result	)

TEST_P()

testing::TEST_P	(	CodeLocationForTESTP	,
		Verify	)

TestPartFatallyFailed() [1/2]

bool testing::TestPartFatallyFailed ( const TestPartResult & result )

static

TestPartFatallyFailed() [2/2]

bool testing::TestPartFatallyFailed ( const TestPartResult & result )

static

TestPartNonfatallyFailed() [1/2]

bool testing::TestPartNonfatallyFailed ( const TestPartResult & result )

static

TestPartNonfatallyFailed() [2/2]

bool testing::TestPartNonfatallyFailed ( const TestPartResult & result )

static

TestPartResultTypeToString() [1/2]

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

static

TestPartResultTypeToString() [2/2]

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

static

Truly()

template<typename Predicate>

PolymorphicMatcher< internal::TrulyMatcher< Predicate > > testing::Truly ( Predicate pred )

inline

TYPED_TEST()

testing::TYPED_TEST	(	CodeLocationForTYPEDTEST	,
		Verify	)

TYPED_TEST_CASE()

testing::TYPED_TEST_CASE	(	CodeLocationForTYPEDTEST	,
		int	)

TYPED_TEST_CASE_P()

testing::TYPED_TEST_CASE_P

(

CodeLocationForTYPEDTESTP

)

TYPED_TEST_P()

testing::TYPED_TEST_P	(	CodeLocationForTYPEDTESTP	,
		Verify	)

TypedEq()

template<typename Lhs, typename Rhs>

Matcher< Lhs > testing::TypedEq ( const Rhs & rhs )

inline

UnorderedElementsAre() [1/11]

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

inline

UnorderedElementsAre() [2/11]

template<typename T1>

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

inline

UnorderedElementsAre() [3/11]

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

UnorderedElementsAre() [4/11]

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

UnorderedElementsAre() [5/11]

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

UnorderedElementsAre() [6/11]

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

UnorderedElementsAre() [7/11]

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

UnorderedElementsAre() [8/11]

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

UnorderedElementsAre() [9/11]

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

UnorderedElementsAre() [10/11]

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

UnorderedElementsAre() [11/11]

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

UnorderedElementsAreArray() [1/4]

template<typename Container>

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

inline

UnorderedElementsAreArray() [2/4]

template<typename T>

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

inline

UnorderedElementsAreArray() [3/4]

template<typename T, size_t N>

internal::UnorderedElementsAreArrayMatcher< T > testing::UnorderedElementsAreArray ( const T(&) array[N] )

inline

UnorderedElementsAreArray() [4/4]

template<typename Iter>

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

inline

UnorderedPointwise()

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

ValidateTestPropertyName()

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

Value()

template<typename T, typename M>

bool testing::Value ( const T & value, M matcher )

inline

WhenDynamicCastTo()

template<typename To>

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

inline

WhenSorted()

template<typename ContainerMatcher>

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

inline

WhenSortedBy()

template<typename Comparator, typename ContainerMatcher>

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

inline

WithArg()

template<int k, typename InnerAction>

internal::WithArgsAction< InnerAction, k > testing::WithArg ( const InnerAction & action )

inline

WithArgs() [1/10]

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

WithArgs() [2/10]

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

WithArgs() [3/10]

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

WithArgs() [4/10]

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

WithArgs() [5/10]

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

WithArgs() [6/10]

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

WithArgs() [7/10]

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

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

inline

WithArgs() [8/10]

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

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

inline

WithArgs() [9/10]

template<int k1, int k2, typename InnerAction>

internal::WithArgsAction< InnerAction, k1, k2 > testing::WithArgs ( const InnerAction & action )

inline

WithArgs() [10/10]

template<int k1, typename InnerAction>

internal::WithArgsAction< InnerAction, k1 > testing::WithArgs ( const InnerAction & action )

inline

WithoutArgs()

template<typename InnerAction>

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

inline

Variable Documentation

_

const internal::AnythingMatcher testing::_ = {}

DefaultValue< T & >::address_

template<typename T>

T* testing::DefaultValue< T & >::address_ = NULL

DefaultValue< T >::producer_

template<typename T>

DefaultValue<T>::ValueProducer* testing::DefaultValue< T >::producer_ = NULL

GTEST_ATTRIBUTE_UNUSED_

class GTEST_API_ testing::InSequence testing::GTEST_ATTRIBUTE_UNUSED_

kDeathTestCaseFilter [1/2]

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

static

kDeathTestCaseFilter [2/2]

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

static

kDefaultDeathTestStyle [1/2]

const char testing::kDefaultDeathTestStyle[] = "fast"

static

kDefaultDeathTestStyle [2/2]

const char testing::kDefaultDeathTestStyle[] = "fast"

static

kDefaultOutputFile [1/2]

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

static

kDefaultOutputFile [2/2]

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

static

kDisableTestFilter [1/2]

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

static

kDisableTestFilter [2/2]

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

static

kMaxStackTraceDepth

const int testing::kMaxStackTraceDepth = 100

kReservedTestCaseAttributes [1/2]

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

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

kReservedTestCaseAttributes [2/2]

const char* const testing::kReservedTestCaseAttributes[]

static

Initial value:

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

kReservedTestSuiteAttributes [1/2]

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

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

kReservedTestSuiteAttributes [2/2]

const char* const testing::kReservedTestSuiteAttributes[]

static

Initial value:

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

kReservedTestSuitesAttributes [1/2]

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

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

kReservedTestSuitesAttributes [2/2]

const char* const testing::kReservedTestSuitesAttributes[]

static

Initial value:

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

kTestShardIndex [1/2]

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

static

kTestShardIndex [2/2]

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

static

kTestShardStatusFile [1/2]

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

static

kTestShardStatusFile [2/2]

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

static

kTestTotalShards [1/2]

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

static

kTestTotalShards [2/2]

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

static

kUniversalFilter [1/2]

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

static

kUniversalFilter [2/2]

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

static