testing Namespace Reference

Namespaces
namespace	internal
namespace	internal2

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	FunctionMocker
class	MockSpec

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)
	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_DECLARE_bool_ (death_test_use_fork)

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

Typedef Documentation

TimeInMillis

typedef internal::TimeInMillis testing::TimeInMillis

Definition at line 480 of file gtest.h.

Unused

typedef internal::IgnoredValue testing::Unused

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

Function Documentation

A()

template<typename T>

Matcher< T > testing::A ( )

inline

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

ACTION_P()

testing::ACTION_P	(	ReturnPointee	,
		pointer	)

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

{ return *pointer; }

ACTION_TEMPLATE() [1/28]

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

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

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

ACTION_TEMPLATE() [2/28]

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

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

                                      {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args));
}

Here is the call graph for this function:

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

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

                                                                             {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [4/28]

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

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

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

Here is the call graph for this function:

ACTION_TEMPLATE() [5/28]

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

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

                                            {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [6/28]

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

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

                                                {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [7/28]

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

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

                                                    {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [8/28]

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

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

                                                        {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [9/28]

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

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

                                                            {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
}

Here is the call graph for this function:

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

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

                                                                {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
}

Here is the call graph for this function:

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

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

                                                                    {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
}

Here is the call graph for this function:

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

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

                                                                        {
  using internal::invoke_argument::InvokeArgumentAdl;
  return InvokeArgumentAdl<return_type>(
      internal::invoke_argument::AdlTag(),
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
}

Here is the call graph for this function:

ACTION_TEMPLATE() [13/28]

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

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

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

ACTION_TEMPLATE() [14/28]

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

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

                                      {
  return new T();
}

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

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

                                                                             {
  return new T(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)	)

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

                                        {
  return new T(p0);
}

ACTION_TEMPLATE() [17/28]

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

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

                                            {
  return new T(p0, p1);
}

ACTION_TEMPLATE() [18/28]

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

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

                                                {
  return new T(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)	)

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

                                                    {
  return new T(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)	)

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

                                                        {
  return new T(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)	)

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

                                                            {
  return new T(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)	)

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

                                                                {
  return new T(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)	)

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

                                                                    {
  return new T(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)	)

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

                                                                        {
  return new T(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)	)

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

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

ACTION_TEMPLATE() [26/28]

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

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

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

ACTION_TEMPLATE() [27/28]

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

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

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

ACTION_TEMPLATE() [28/28]

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

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

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

Here is the call graph for this function:

AddGlobalTestEnvironment()

Environment * testing::AddGlobalTestEnvironment ( Environment * env )

inline

Definition at line 1350 of file gtest.h.

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

AllArgs()

template<typename InnerMatcher>

InnerMatcher testing::AllArgs ( const InnerMatcher & matcher )

inline

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

{ return matcher; }

AllOf() [1/9]

template<typename M1, typename M2>

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

inline

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

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

Here is the caller graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

An()

template<typename T>

Matcher< T > testing::An ( )

inline

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

{ return A<T>(); }

Here is the call graph for this function:

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

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

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

Here is the caller graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Args() [8/11]

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

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

inline

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

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

Args() [9/11]

template<int k1, int k2, typename InnerMatcher>

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

inline

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

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

Args() [10/11]

template<int k1, typename InnerMatcher>

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

inline

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

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

Args() [11/11]

template<typename InnerMatcher>

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

inline

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

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

Here is the caller graph for this function:

AssertionFailure() [1/2]

GTEST_API_ AssertionResult testing::AssertionFailure

(

)

Here is the caller graph for this function:

AssertionFailure() [2/2]

GTEST_API_ AssertionResult testing::AssertionFailure

(

const Message &

msg

)

AssertionSuccess()

GTEST_API_ AssertionResult testing::AssertionSuccess

(

)

Here is the caller graph for this function:

Assign()

template<typename T1, typename T2>

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

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

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

Here is the call graph for this function:

AtLeast()

GTEST_API_ Cardinality testing::AtLeast

(

int

n

)

Here is the caller graph for this function:

AtMost()

GTEST_API_ Cardinality testing::AtMost

(

int

n

)

BeginEndDistanceIs()

template<typename DistanceMatcher>

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

inline

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

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

Between()

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

ByMove()

template<typename R>

internal::ByMoveWrapper< R > testing::ByMove

(

R

x

)

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

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

Here is the call graph for this function:

ByRef()

template<typename T>

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

inline

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

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

Const()

template<typename T>

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

inline

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

{ return x; }

Here is the call graph for this function:

Here is the caller graph for this function:

ContainerEq()

template<typename Container>

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

inline

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

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

Here is the call graph for this function:

Contains()

template<typename M>

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

inline

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

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

ContainsRegex() [1/2]

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

inline

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

ContainsRegex() [2/2]

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

inline

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

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

Here is the call graph for this function:

DoAll() [1/9]

template<typename Action1, typename Action2>

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

inline

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

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

Here is the caller graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

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

                                           {
  return internal::DoDefaultAction();
}

Here is the caller graph for this function:

DoubleEq()

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

inline

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

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

DoubleLE()

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

Here is the call graph for this function:

Here is the caller graph for this function:

DoubleNear()

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

inline

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

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

Each()

template<typename M>

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

inline

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

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

ElementsAre() [1/11]

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

inline

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

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

Here is the call graph for this function:

ElementsAre() [2/11]

template<typename T1>

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

inline

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

ElementsAreArray() [1/4]

template<typename Container>

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

inline

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

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

Here is the call graph for this function:

ElementsAreArray() [2/4]

template<typename T>

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

inline

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

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

Here is the call graph for this function:

ElementsAreArray() [3/4]

template<typename T, size_t N>

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

inline

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

                         {
  return ElementsAreArray(array, N);
}

Here is the call graph for this function:

ElementsAreArray() [4/4]

template<typename Iter>

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

inline

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

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

Here is the caller graph for this function:

EndsWith()

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

inline

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

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

Here is the call graph for this function:

Eq() [1/2]

internal::Eq2Matcher testing::Eq ( )

inline

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

{ return internal::Eq2Matcher(); }

Here is the caller graph for this function:

Eq() [2/2]

template<typename T>

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

inline

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

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

Exactly()

GTEST_API_ Cardinality testing::Exactly

(

int

n

)

Here is the caller graph for this function:

ExplainMatchResult()

template<typename T, typename M>

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

inline

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

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

Here is the call graph for this function:

Field()

template<typename Class, typename FieldType, typename FieldMatcher>

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

inline

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

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

Here is the call graph for this function:

FloatEq()

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

inline

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

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

FloatLE()

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

Here is the call graph for this function:

Here is the caller graph for this function:

FloatNear()

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

inline

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

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

Ge() [1/2]

internal::Ge2Matcher testing::Ge ( )

inline

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

{ return internal::Ge2Matcher(); }

Ge() [2/2]

template<typename Rhs>

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

inline

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

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

GMOCK_DECLARE_bool_()

testing::GMOCK_DECLARE_bool_

(

catch_leaked_mocks

)

GMOCK_DECLARE_string_()

testing::GMOCK_DECLARE_string_

(

verbose

)

Here is the call graph for this function:

Gt() [1/2]

internal::Gt2Matcher testing::Gt ( )

inline

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

{ return internal::Gt2Matcher(); }

Gt() [2/2]

template<typename Rhs>

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

inline

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

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

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

)

HasSubstr()

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

inline

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

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

Here is the call graph for this function:

IgnoreResult()

template<typename A>

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

inline

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

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

Here is the call graph for this function:

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]

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

Here is the call graph for this function:

Here is the caller graph for this function:

InitGoogleTest() [2/2]

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

Here is the call graph for this function:

Invoke() [1/2]

template<class Class, typename MethodPtr>

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

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

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

Here is the call graph for this function:

Invoke() [2/2]

template<typename FunctionImpl>

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

(

FunctionImpl

function_impl

)

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

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

Here is the call graph for this function:

InvokeWithoutArgs() [1/2]

template<class Class, typename MethodPtr>

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

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

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

Here is the call graph for this function:

InvokeWithoutArgs() [2/2]

template<typename FunctionImpl>

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

(

FunctionImpl

function_impl

)

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

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

Here is the call graph for this function:

IsNotSubstring() [1/3]

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

Here is the call graph for this function:

IsNotSubstring() [2/3]

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

Here is the call graph for this function:

Here is the caller graph for this function:

IsNotSubstring() [3/3]

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

Here is the call graph for this function:

IsNull()

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

inline

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

                                                           {
  return MakePolymorphicMatcher(internal::IsNullMatcher());
}

Here is the call graph for this function:

IsSubstring() [1/3]

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

Here is the call graph for this function:

IsSubstring() [2/3]

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

Here is the call graph for this function:

Here is the caller graph for this function:

IsSubstring() [3/3]

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

Here is the call graph for this function:

Key()

template<typename M>

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

inline

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

                                                  {
  return internal::KeyMatcher<M>(inner_matcher);
}

Le() [1/2]

internal::Le2Matcher testing::Le ( )

inline

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

{ return internal::Le2Matcher(); }

Le() [2/2]

template<typename Rhs>

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

inline

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

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

Lt() [1/2]

internal::Lt2Matcher testing::Lt ( )

inline

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

{ return internal::Lt2Matcher(); }

Lt() [2/2]

template<typename Rhs>

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

inline

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

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

MakeAction()

template<typename F>

Action< F > testing::MakeAction

(

ActionInterface< F > *

impl

)

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

                                               {
  return Action<F>(impl);
}

Here is the caller graph for this function:

MakeCardinality()

Cardinality testing::MakeCardinality ( const CardinalityInterface * c )

inline

Definition at line 141 of file gmock-cardinalities.h.

                                                                  {
  return Cardinality(c);
}

MakeMatcher()

template<typename T>

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

inline

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

                                                               {
  return Matcher<T>(impl);
}

Here is the caller graph for this function:

MakePolymorphicAction()

template<typename Impl>

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

inline

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

                                                                       {
  return PolymorphicAction<Impl>(impl);
}

Here is the caller graph for this function:

MakePolymorphicMatcher()

template<class Impl>

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

inline

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

                                                                         {
  return PolymorphicMatcher<Impl>(impl);
}

Here is the caller graph for this function:

MATCHER()

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

Definition at line 48 of file gmock-more-matchers.h.

                                          : "is empty") {
  if (arg.empty()) {
    return true;
  }
  *result_listener << "whose size is " << arg.size();
  return false;
}

MatcherCast()

template<typename T, typename M>

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

inline

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

                                                {
  return internal::MatcherCastImpl<T, M>::Cast(matcher);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matches()

template<typename M>

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

inline

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

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

Here is the caller graph for this function:

MatchesRegex() [1/2]

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

inline

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

MatchesRegex() [2/2]

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

inline

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

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

Here is the call graph for this function:

NanSensitiveDoubleEq()

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

inline

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

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

NanSensitiveDoubleNear()

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

inline

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

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

NanSensitiveFloatEq()

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

inline

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

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

NanSensitiveFloatNear()

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

inline

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

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

Ne() [1/2]

internal::Ne2Matcher testing::Ne ( )

inline

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

{ return internal::Ne2Matcher(); }

Ne() [2/2]

template<typename Rhs>

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

inline

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

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

Not()

template<typename InnerMatcher>

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

inline

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

                                                            {
  return internal::NotMatcher<InnerMatcher>(m);
}

NotNull()

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

inline

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

                                                             {
  return MakePolymorphicMatcher(internal::NotNullMatcher());
}

Here is the call graph for this function:

operator<<() [1/2]

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

inline

Definition at line 232 of file gtest-message.h.

                                                                  {
  return os << sb.GetString();
}

Here is the call graph for this function:

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

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

                                                               {
  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
      first_matcher, second_matcher);
}

Pointee()

template<typename InnerMatcher>

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

inline

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

                                       {
  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
}

Pointwise()

template<typename TupleMatcher, typename Container>

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

inline

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

                                                                   {
  // This following line is for working around a bug in MSVC 8.0,
  // which causes Container to be a const type sometimes (e.g. when
  // rhs is a const int[])..
  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
  return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
      tuple_matcher, rhs);
}

PrintToString()

template<typename T>

::std::string testing::PrintToString

(

const T &

value

)

Definition at line 980 of file gtest-printers.h.

                                        {
  ::std::stringstream ss;
  internal::UniversalTersePrinter<T>::Print(value, &ss);
  return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Property()

template<typename Class, typename PropertyType, typename PropertyMatcher>

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

inline

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

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

Here is the call graph for this function:

Ref()

template<typename T>

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

inline

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

                                        {  // NOLINT
  return internal::RefMatcher<T&>(x);
}

ResultOf()

template<typename Callable, typename ResultOfMatcher>

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

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

                                                       {
  return internal::ResultOfMatcher<Callable>(
          callable,
          MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
              matcher));
  // The call to MatcherCast() is required for supporting inner
  // matchers of compatible types.  For example, it allows
  //   ResultOf(Function, m)
  // to compile where Function() returns an int32 and m is a matcher for int64.
}

Here is the call graph for this function:

Return() [1/2]

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

inline

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

                                                            {
  return MakePolymorphicAction(internal::ReturnVoidAction());
}

Here is the call graph for this function:

Return() [2/2]

template<typename R>

internal::ReturnAction< R > testing::Return

(

R

value

)

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

                                        {
  return internal::ReturnAction<R>(internal::move(value));
}

Here is the call graph for this function:

ReturnNull()

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

inline

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

                                                                {
  return MakePolymorphicAction(internal::ReturnNullAction());
}

Here is the call graph for this function:

ReturnRef()

template<typename R>

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

inline

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

                                                  {  // NOLINT
  return internal::ReturnRefAction<R>(x);
}

ReturnRefOfCopy()

template<typename R>

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

inline

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

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

SafeMatcherCast()

template<typename T, typename M>

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

inline

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

                                                                {
  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetArgPointee() [1/3]

template<size_t N>

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

(

const char *

p

)

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

                             {
  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
      N, const char*, false>(p));
}

Here is the call graph for this function:

SetArgPointee() [2/3]

template<size_t N, typename T>

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

(

const T &

x

)

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

                          {
  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
      N, T, internal::IsAProtocolMessage<T>::value>(x));
}

Here is the call graph for this function:

SetArgPointee() [3/3]

template<size_t N>

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

(

const wchar_t *

p

)

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

                                {
  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
      N, const wchar_t*, false>(p));
}

Here is the call graph for this function:

SetArgumentPointee()

template<size_t N, typename T>

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

(

const T &

x

)

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

                               {
  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
      N, T, internal::IsAProtocolMessage<T>::value>(x));
}

Here is the call graph for this function:

SetErrnoAndReturn()

template<typename T>

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

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

                                        {
  return MakePolymorphicAction(
      internal::SetErrnoAndReturnAction<T>(errval, result));
}

Here is the call graph for this function:

SizeIs()

template<typename SizeMatcher>

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

inline

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

                                        {
  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
}

StartsWith()

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

inline

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

                                             {
  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
      prefix));
}

Here is the call graph for this function:

StaticAssertTypeEq()

template<typename T1, typename T2>

bool testing::StaticAssertTypeEq

(

)

Definition at line 2150 of file gtest.h.

                          {
  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StrCaseEq()

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

inline

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

                                         {
  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
      str, true, false));
}

Here is the call graph for this function:

StrCaseNe()

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

inline

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

                                         {
  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
      str, false, false));
}

Here is the call graph for this function:

StrEq()

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

inline

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

                                     {
  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
      str, true, true));
}

Here is the call graph for this function:

StrNe()

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

inline

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

                                     {
  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
      str, false, true));
}

Here is the call graph for this function:

Truly()

template<typename Predicate>

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

inline

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

                      {
  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
}

Here is the call graph for this function:

TypedEq()

template<typename Lhs, typename Rhs>

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

inline

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

{ return Eq(rhs); }

Here is the call graph for this function:

UnorderedElementsAre() [1/11]

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

inline

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

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

Here is the call graph for this function:

UnorderedElementsAre() [2/11]

template<typename T1>

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

inline

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

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

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

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

Here is the call graph for this function:

UnorderedElementsAreArray() [1/4]

template<typename Container>

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

inline

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

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

Here is the call graph for this function:

UnorderedElementsAreArray() [2/4]

template<typename T>

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

inline

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

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

Here is the call graph for this function:

UnorderedElementsAreArray() [3/4]

template<typename T, size_t N>

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

inline

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

                                               {
  return UnorderedElementsAreArray(array, N);
}

Here is the call graph for this function:

UnorderedElementsAreArray() [4/4]

template<typename Iter>

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

inline

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

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

Here is the caller graph for this function:

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

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

                                                      {
  // This following line is for working around a bug in MSVC 8.0,
  // which causes RhsContainer to be a const type sometimes (e.g. when
  // rhs_container is a const int[]).
  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
 
  // RhsView allows the same code to handle RhsContainer being a
  // STL-style container and it being a native C-style array.
  typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
  typedef typename RhsView::type RhsStlContainer;
  typedef typename RhsStlContainer::value_type Second;
  const RhsStlContainer& rhs_stl_container =
      RhsView::ConstReference(rhs_container);
 
  // Create a matcher for each element in rhs_container.
  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
       it != rhs_stl_container.end(); ++it) {
    matchers.push_back(
        internal::MatcherBindSecond(tuple2_matcher, *it));
  }
 
  // Delegate the work to UnorderedElementsAreArray().
  return UnorderedElementsAreArray(matchers);
}

Here is the call graph for this function:

Value()

template<typename T, typename M>

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

inline

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

                                             {
  return testing::Matches(matcher)(value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WhenDynamicCastTo()

template<typename To>

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

inline

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

                                                    {
  return MakePolymorphicMatcher(
      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
}

Here is the call graph for this function:

WhenSorted()

template<typename ContainerMatcher>

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

inline

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

                                                      {
  return
      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
          internal::LessComparator(), container_matcher);
}

WhenSortedBy()

template<typename Comparator, typename ContainerMatcher>

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

inline

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

                                                        {
  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
      comparator, container_matcher);
}

WithArg()

template<int k, typename InnerAction>

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

inline

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

                                   {
  return internal::WithArgsAction<InnerAction, k>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
      k9, k10>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
      k9>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
      k8>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
      k7>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
}

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

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
}

WithArgs() [8/10]

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

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

inline

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
}

WithArgs() [9/10]

template<int k1, int k2, typename InnerAction>

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

inline

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

                                    {
  return internal::WithArgsAction<InnerAction, k1, k2>(action);
}

WithArgs() [10/10]

template<int k1, typename InnerAction>

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

inline

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

                                    {
  return internal::WithArgsAction<InnerAction, k1>(action);
}

WithoutArgs()

template<typename InnerAction>

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

inline

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

                                       {
  return internal::WithArgsAction<InnerAction>(action);
}

Variable Documentation

_

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

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

{};

DefaultValue< T & >::address_

template<typename T>

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

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

DefaultValue< T >::producer_

template<typename T>

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

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

GTEST_ATTRIBUTE_UNUSED_

class GTEST_API_ testing::InSequence testing::GTEST_ATTRIBUTE_UNUSED_

kMaxStackTraceDepth

const int testing::kMaxStackTraceDepth = 100

Definition at line 147 of file gtest.h.