Electroneum
testing Namespace Reference

Namespaces

 internal
 
 internal2
 

Classes

class  Action
 
class  ActionInterface
 
class  AssertionResult
 
class  Cardinality
 
class  CardinalityInterface
 
class  DefaultValue
 
class  DefaultValue< T & >
 
class  DefaultValue< void >
 
class  EmptyTestEventListener
 
class  Environment
 
class  Expectation
 
class  ExpectationSet
 
class  InSequence
 
class  Matcher
 
class  Matcher< const internal::string &>
 
class  Matcher< internal::string >
 
class  MatcherDescriberInterface
 
class  MatcherInterface
 
class  MatchResultListener
 
class  Message
 
class  Mock
 
class  MockFunction
 
class  MockFunction< R(A0)>
 
class  MockFunction< R(A0, A1)>
 
class  MockFunction< R(A0, A1, A2)>
 
class  MockFunction< R(A0, A1, A2, A3)>
 
class  MockFunction< R(A0, A1, A2, A3, A4)>
 
class  MockFunction< R(A0, A1, A2, A3, A4, A5)>
 
class  MockFunction< R(A0, A1, A2, A3, A4, A5, A6)>
 
class  MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7)>
 
class  MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8)>
 
class  MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
class  NaggyMock
 
class  NiceMock
 
class  PolymorphicAction
 
class  PolymorphicMatcher
 
class  SafeMatcherCastImpl
 
class  ScopedFakeTestPartResultReporter
 
class  Sequence
 
class  StrictMock
 
class  StringMatchResultListener
 
class  Test
 
class  TestCase
 
class  TestEventListener
 
class  TestEventListeners
 
class  TestInfo
 
class  TestPartResult
 
class  TestPartResultArray
 
class  TestPartResultReporterInterface
 
class  TestProperty
 
class  TestResult
 
class  UnitTest
 

Typedefs

typedef internal::IgnoredValue Unused
 
typedef internal::TimeInMillis TimeInMillis
 

Functions

template<typename F >
Action< FMakeAction (ActionInterface< F > *impl)
 
template<typename Impl >
PolymorphicAction< Impl > MakePolymorphicAction (const Impl &impl)
 
template<typename R >
internal::ReturnAction< R > Return (R value)
 
PolymorphicAction< internal::ReturnNullActionReturnNull ()
 
PolymorphicAction< internal::ReturnVoidActionReturn ()
 
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< AIgnoreResult (const A &an_action)
 
template<typename T >
internal::ReferenceWrapper< TByRef (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< TMakeMatcher (const MatcherInterface< T > *impl)
 
template<class Impl >
PolymorphicMatcher< Impl > MakePolymorphicMatcher (const Impl &impl)
 
template<typename T , typename M >
Matcher< TMatcherCast (const M &matcher)
 
template<typename T , typename M >
Matcher< TSafeMatcherCast (const M &polymorphic_matcher)
 
template<typename T >
Matcher< TA ()
 
template<typename Iter >
internal::ElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type > ElementsAreArray (Iter first, Iter last)
 
template<typename T >
internal::ElementsAreArrayMatcher< TElementsAreArray (const T *pointer, size_t count)
 
template<typename T , size_t N>
internal::ElementsAreArrayMatcher< TElementsAreArray (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< TUnorderedElementsAreArray (const T *pointer, size_t count)
 
template<typename T , size_t N>
internal::UnorderedElementsAreArrayMatcher< TUnorderedElementsAreArray (const T(&array)[N])
 
template<typename Container >
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > UnorderedElementsAreArray (const Container &container)
 
template<typename T >
Matcher< TAn ()
 
template<typename T >
internal::EqMatcher< TEq (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::IsNullMatcherIsNull ()
 
PolymorphicMatcher< internal::NotNullMatcherNotNull ()
 
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::MatchesRegexMatcherMatchesRegex (const internal::RE *regex)
 
PolymorphicMatcher< internal::MatchesRegexMatcherMatchesRegex (const internal::string &regex)
 
PolymorphicMatcher< internal::MatchesRegexMatcherContainsRegex (const internal::RE *regex)
 
PolymorphicMatcher< internal::MatchesRegexMatcherContainsRegex (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 TConst (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)
 
EnvironmentAddGlobalTestEnvironment (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

const internal::AnythingMatcher _ = {}
 
class GTEST_API_ testing::InSequence GTEST_ATTRIBUTE_UNUSED_
 
const int kMaxStackTraceDepth = 100
 

Typedef Documentation

◆ TimeInMillis

Definition at line 480 of file gtest.h.

◆ 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.

3732 { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
Matcher< T > MakeMatcher(const MatcherInterface< T > *impl)
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.

222 { return *pointer; }
const GenericPointer< typename T::ValueType > & pointer
Definition: pointer.h:1124

◆ ACTION_TEMPLATE() [1/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.

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

◆ ACTION_TEMPLATE() [2/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.

171  {
172  *pointer = ::testing::get<k>(args);
173 }
const GenericPointer< typename T::ValueType > & pointer
Definition: pointer.h:1124

◆ ACTION_TEMPLATE() [3/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.

179  {
180  *pointer = *::testing::get<k>(args);
181 }
const GenericPointer< typename T::ValueType > & pointer
Definition: pointer.h:1124

◆ ACTION_TEMPLATE() [4/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.

187  {
188  typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
189  // Ensures that argument #k is a reference. If you get a compiler
190  // error on the next line, you are using SetArgReferee<k>(value) in
191  // a mock function whose k-th (0-based) argument is not a reference.
193  SetArgReferee_must_be_used_with_a_reference_argument);
194  ::testing::get<k>(args) = value;
195 }
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
#define GTEST_COMPILE_ASSERT_(expr, msg)
Definition: gtest-port.h:1032

◆ ACTION_TEMPLATE() [5/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.

204  {
205  // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
206 #ifdef _MSC_VER
207  internal::CopyElements(first, last, ::testing::get<k>(args));
208 #else
209  ::std::copy(first, last, ::testing::get<k>(args));
210 #endif
211 }
void copy(key &AA, const key &A)
Definition: rctOps.h:79
OutputIterator CopyElements(InputIterator first, InputIterator last, OutputIterator output)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [6/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.

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

◆ ACTION_TEMPLATE() [7/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.

2198  {
2200  return InvokeArgumentAdl<return_type>(
2201  internal::invoke_argument::AdlTag(),
2202  ::testing::get<k>(args));
2203 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [8/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.

2207  {
2209  return InvokeArgumentAdl<return_type>(
2210  internal::invoke_argument::AdlTag(),
2211  ::testing::get<k>(args), p0);
2212 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [9/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.

2216  {
2218  return InvokeArgumentAdl<return_type>(
2219  internal::invoke_argument::AdlTag(),
2220  ::testing::get<k>(args), p0, p1);
2221 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [10/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.

2225  {
2227  return InvokeArgumentAdl<return_type>(
2228  internal::invoke_argument::AdlTag(),
2229  ::testing::get<k>(args), p0, p1, p2);
2230 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [11/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.

2234  {
2236  return InvokeArgumentAdl<return_type>(
2237  internal::invoke_argument::AdlTag(),
2238  ::testing::get<k>(args), p0, p1, p2, p3);
2239 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [12/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.

2243  {
2245  return InvokeArgumentAdl<return_type>(
2246  internal::invoke_argument::AdlTag(),
2247  ::testing::get<k>(args), p0, p1, p2, p3, p4);
2248 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [13/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.

2252  {
2254  return InvokeArgumentAdl<return_type>(
2255  internal::invoke_argument::AdlTag(),
2256  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
2257 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [14/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.

2261  {
2263  return InvokeArgumentAdl<return_type>(
2264  internal::invoke_argument::AdlTag(),
2265  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
2266 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [15/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.

2270  {
2272  return InvokeArgumentAdl<return_type>(
2273  internal::invoke_argument::AdlTag(),
2274  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
2275 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [16/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.

2279  {
2281  return InvokeArgumentAdl<return_type>(
2282  internal::invoke_argument::AdlTag(),
2283  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
2284 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [17/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.

2288  {
2290  return InvokeArgumentAdl<return_type>(
2291  internal::invoke_argument::AdlTag(),
2292  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2293 }
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Here is the call graph for this function:

◆ ACTION_TEMPLATE() [18/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.

2302  {
2303  return new T();
2304 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [19/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.

2308  {
2309  return new T(p0);
2310 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [20/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.

2314  {
2315  return new T(p0, p1);
2316 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [21/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.

2320  {
2321  return new T(p0, p1, p2);
2322 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [22/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.

2326  {
2327  return new T(p0, p1, p2, p3);
2328 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [23/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.

2332  {
2333  return new T(p0, p1, p2, p3, p4);
2334 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [24/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.

2338  {
2339  return new T(p0, p1, p2, p3, p4, p5);
2340 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [25/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.

2344  {
2345  return new T(p0, p1, p2, p3, p4, p5, p6);
2346 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [26/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.

2350  {
2351  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
2352 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [27/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.

2356  {
2357  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
2358 }
const uint32_t T[512]

◆ ACTION_TEMPLATE() [28/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.

2362  {
2363  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2364 }
const uint32_t T[512]

◆ AddGlobalTestEnvironment()

Environment * testing::AddGlobalTestEnvironment ( Environment env)
inline

Definition at line 1350 of file gtest.h.

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

◆ AllArgs()

template<typename InnerMatcher >
InnerMatcher testing::AllArgs ( const InnerMatcher &  matcher)
inline

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

4382 { 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.

1002  {
1003  return typename internal::AllOfResult2<M1, M2>::type(
1004  m1,
1005  m2);
1006 }
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.

1010  {
1011  return typename internal::AllOfResult3<M1, M2, M3>::type(
1012  m1,
1013  ::testing::AllOf(m2, m3));
1014 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1018  {
1019  return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
1020  ::testing::AllOf(m1, m2),
1021  ::testing::AllOf(m3, m4));
1022 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1026  {
1027  return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
1028  ::testing::AllOf(m1, m2),
1029  ::testing::AllOf(m3, m4, m5));
1030 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1035  {
1036  return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
1037  ::testing::AllOf(m1, m2, m3),
1038  ::testing::AllOf(m4, m5, m6));
1039 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1044  {
1045  return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1046  ::testing::AllOf(m1, m2, m3),
1047  ::testing::AllOf(m4, m5, m6, m7));
1048 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1053  {
1054  return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1055  ::testing::AllOf(m1, m2, m3, m4),
1056  ::testing::AllOf(m5, m6, m7, m8));
1057 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1062  {
1063  return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1064  M9>::type(
1065  ::testing::AllOf(m1, m2, m3, m4),
1066  ::testing::AllOf(m5, m6, m7, m8, m9));
1067 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

1073  {
1074  return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1075  M10>::type(
1076  ::testing::AllOf(m1, m2, m3, m4, m5),
1077  ::testing::AllOf(m6, m7, m8, m9, m10));
1078 }
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)
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.

3736 { return A<T>(); }

◆ 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.

1085  {
1086  return typename internal::AnyOfResult2<M1, M2>::type(
1087  m1,
1088  m2);
1089 }
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.

1093  {
1094  return typename internal::AnyOfResult3<M1, M2, M3>::type(
1095  m1,
1096  ::testing::AnyOf(m2, m3));
1097 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1101  {
1102  return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
1103  ::testing::AnyOf(m1, m2),
1104  ::testing::AnyOf(m3, m4));
1105 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1109  {
1110  return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
1111  ::testing::AnyOf(m1, m2),
1112  ::testing::AnyOf(m3, m4, m5));
1113 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1118  {
1119  return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
1120  ::testing::AnyOf(m1, m2, m3),
1121  ::testing::AnyOf(m4, m5, m6));
1122 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1127  {
1128  return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1129  ::testing::AnyOf(m1, m2, m3),
1130  ::testing::AnyOf(m4, m5, m6, m7));
1131 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1136  {
1137  return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1138  ::testing::AnyOf(m1, m2, m3, m4),
1139  ::testing::AnyOf(m5, m6, m7, m8));
1140 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1145  {
1146  return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1147  M9>::type(
1148  ::testing::AnyOf(m1, m2, m3, m4),
1149  ::testing::AnyOf(m5, m6, m7, m8, m9));
1150 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
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.

1156  {
1157  return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1158  M10>::type(
1159  ::testing::AnyOf(m1, m2, m3, m4, m5),
1160  ::testing::AnyOf(m6, m7, m8, m9, m10));
1161 }
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
Here is the call graph for this function:

◆ Args() [1/11]

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

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

481  {
482  return internal::ArgsMatcher<InnerMatcher>(matcher);
483 }
Here is the caller graph for this function:

◆ Args() [2/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.

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

◆ Args() [3/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.

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

◆ Args() [4/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.

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

◆ Args() [5/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.

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

◆ 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.

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

◆ Args() [7/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.

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

◆ Args() [8/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.

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

◆ Args() [9/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.

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

◆ Args() [10/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.

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

◆ Args() [11/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.

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

◆ 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.

1147  {
1148  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
1149 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:
Here is the caller 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.

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

◆ Between()

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

◆ ByMove()

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

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

1094  {
1095  return internal::ByMoveWrapper<R>(internal::move(x));
1096 }
const T & move(const T &t)
Definition: gtest-port.h:1317
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.

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

◆ Const()

template<typename T >
const T& testing::Const ( const T x)
inline

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

1826 { return x; }

◆ 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.

4150  {
4151  // This following line is for working around a bug in MSVC 8.0,
4152  // which causes Container to be a const type sometimes.
4153  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
4154  return MakePolymorphicMatcher(
4155  internal::ContainerEqMatcher<RawContainer>(rhs));
4156 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
#define GTEST_REMOVE_CONST_(T)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Contains()

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

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

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

◆ ContainsRegex() [1/2]

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

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

4017  {
4018  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
4019 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
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.

4021  {
4022  return ContainsRegex(new internal::RE(regex));
4023 }
PolymorphicMatcher< internal::MatchesRegexMatcher > ContainsRegex(const internal::string &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.

696  {
697  return internal::DoBothAction<Action1, Action2>(a1, a2);
698 }
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.

703  {
704  return DoAll(a1, DoAll(a2, a3));
705 }
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)
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.

711  {
712  return DoAll(a1, DoAll(a2, a3, a4));
713 }
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)
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.

720  {
721  return DoAll(a1, DoAll(a2, a3, a4, a5));
722 }
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)
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.

729  {
730  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
731 }
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)
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.

740  {
741  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
742 }
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)
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.

752  {
753  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
754 }
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)
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.

765  {
766  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
767 }
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)
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.

778  {
779  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
780 }
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)
Here is the call graph for this function:

◆ DoDefault()

internal::DoDefaultAction testing::DoDefault ( )
inline

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

1099  {
1100  return internal::DoDefaultAction();
1101 }
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.

3815  {
3816  return internal::FloatingEqMatcher<double>(rhs, false);
3817 }
Here is the caller graph for this function:

◆ DoubleLE()

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

◆ DoubleNear()

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

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

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

◆ Each()

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

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

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

◆ ElementsAre() [1/11]

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

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

570  {
571  typedef ::testing::tuple<> Args;
572  return internal::ElementsAreMatcher<Args>(Args());
573 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
Here is the call graph for this function:
Here is the caller 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.

579  {
580  typedef ::testing::tuple<
581  typename internal::DecayArray<T1>::type> Args;
582  return internal::ElementsAreMatcher<Args>(Args(e1));
583 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

590  {
591  typedef ::testing::tuple<
592  typename internal::DecayArray<T1>::type,
593  typename internal::DecayArray<T2>::type> Args;
594  return internal::ElementsAreMatcher<Args>(Args(e1, e2));
595 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

603  {
604  typedef ::testing::tuple<
605  typename internal::DecayArray<T1>::type,
606  typename internal::DecayArray<T2>::type,
607  typename internal::DecayArray<T3>::type> Args;
608  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
609 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

618  {
619  typedef ::testing::tuple<
620  typename internal::DecayArray<T1>::type,
621  typename internal::DecayArray<T2>::type,
622  typename internal::DecayArray<T3>::type,
623  typename internal::DecayArray<T4>::type> Args;
624  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
625 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

636  {
637  typedef ::testing::tuple<
638  typename internal::DecayArray<T1>::type,
639  typename internal::DecayArray<T2>::type,
640  typename internal::DecayArray<T3>::type,
641  typename internal::DecayArray<T4>::type,
642  typename internal::DecayArray<T5>::type> Args;
643  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
644 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

657  {
658  typedef ::testing::tuple<
659  typename internal::DecayArray<T1>::type,
660  typename internal::DecayArray<T2>::type,
661  typename internal::DecayArray<T3>::type,
662  typename internal::DecayArray<T4>::type,
663  typename internal::DecayArray<T5>::type,
664  typename internal::DecayArray<T6>::type> Args;
665  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
666 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

680  {
681  typedef ::testing::tuple<
682  typename internal::DecayArray<T1>::type,
683  typename internal::DecayArray<T2>::type,
684  typename internal::DecayArray<T3>::type,
685  typename internal::DecayArray<T4>::type,
686  typename internal::DecayArray<T5>::type,
687  typename internal::DecayArray<T6>::type,
688  typename internal::DecayArray<T7>::type> Args;
689  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
690 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

705  {
706  typedef ::testing::tuple<
707  typename internal::DecayArray<T1>::type,
708  typename internal::DecayArray<T2>::type,
709  typename internal::DecayArray<T3>::type,
710  typename internal::DecayArray<T4>::type,
711  typename internal::DecayArray<T5>::type,
712  typename internal::DecayArray<T6>::type,
713  typename internal::DecayArray<T7>::type,
714  typename internal::DecayArray<T8>::type> Args;
715  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
716  e8));
717 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

733  {
734  typedef ::testing::tuple<
735  typename internal::DecayArray<T1>::type,
736  typename internal::DecayArray<T2>::type,
737  typename internal::DecayArray<T3>::type,
738  typename internal::DecayArray<T4>::type,
739  typename internal::DecayArray<T5>::type,
740  typename internal::DecayArray<T6>::type,
741  typename internal::DecayArray<T7>::type,
742  typename internal::DecayArray<T8>::type,
743  typename internal::DecayArray<T9>::type> Args;
744  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
745  e8, e9));
746 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

764  {
765  typedef ::testing::tuple<
766  typename internal::DecayArray<T1>::type,
767  typename internal::DecayArray<T2>::type,
768  typename internal::DecayArray<T3>::type,
769  typename internal::DecayArray<T4>::type,
770  typename internal::DecayArray<T5>::type,
771  typename internal::DecayArray<T6>::type,
772  typename internal::DecayArray<T7>::type,
773  typename internal::DecayArray<T8>::type,
774  typename internal::DecayArray<T9>::type,
775  typename internal::DecayArray<T10>::type> Args;
776  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
777  e8, e9, e10));
778 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
Here is the call graph for this function:

◆ ElementsAreArray() [1/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.

3646  {
3647  typedef typename ::std::iterator_traits<Iter>::value_type T;
3648  return internal::ElementsAreArrayMatcher<T>(first, last);
3649 }
const uint32_t T[512]
Here is the caller 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.

3653  {
3655 }
mdb_size_t count(MDB_cursor *cur)
internal::ElementsAreArrayMatcher< typename Container::value_type > ElementsAreArray(const Container &container)
const GenericPointer< typename T::ValueType > & pointer
Definition: pointer.h:1124
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.

3659  {
3660  return ElementsAreArray(array, N);
3661 }
internal::ElementsAreArrayMatcher< typename Container::value_type > ElementsAreArray(const Container &container)
Here is the call graph for this function:

◆ ElementsAreArray() [4/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.

3665  {
3666  return ElementsAreArray(container.begin(), container.end());
3667 }
internal::ElementsAreArrayMatcher< typename Container::value_type > ElementsAreArray(const Container &container)
Here is the call 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.

3998  {
3999  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
4000  suffix));
4001 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Eq() [1/2]

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

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

3742 { return internal::EqMatcher<T>(x); }
Here is the caller graph for this function:

◆ Eq() [2/2]

internal::Eq2Matcher testing::Eq ( )
inline

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

4082 { return internal::Eq2Matcher(); }

◆ 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 ( matcher,
const T value,
MatchResultListener listener 
)
inline

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

4355  {
4356  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
4357 }
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225

◆ 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.

3897  {
3898  return MakePolymorphicMatcher(
3899  internal::FieldMatcher<Class, FieldType>(
3900  field, MatcherCast<const FieldType&>(matcher)));
3901  // The call to MatcherCast() is required for supporting inner
3902  // matchers of compatible types. For example, it allows
3903  // Field(&Foo::bar, m)
3904  // to compile where bar is an int32 and m is a matcher for int64.
3905 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ FloatEq()

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

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

3843  {
3844  return internal::FloatingEqMatcher<float>(rhs, false);
3845 }
Here is the caller graph for this function:

◆ FloatLE()

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

◆ FloatNear()

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

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

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

◆ Ge() [1/2]

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

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

3766  {
3767  return internal::GeMatcher<Rhs>(x);
3768 }
Here is the caller graph for this function:

◆ Ge() [2/2]

internal::Ge2Matcher testing::Ge ( )
inline

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

4086 { return internal::Ge2Matcher(); }

◆ GMOCK_DECLARE_bool_()

testing::GMOCK_DECLARE_bool_ ( catch_leaked_mocks  )

◆ GMOCK_DECLARE_string_()

testing::GMOCK_DECLARE_string_ ( verbose  )

◆ Gt() [1/2]

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

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

3772  {
3773  return internal::GtMatcher<Rhs>(x);
3774 }
Here is the caller graph for this function:

◆ Gt() [2/2]

internal::Gt2Matcher testing::Gt ( )
inline

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

4090 { return internal::Gt2Matcher(); }

◆ GTEST_DECLARE_bool_() [1/9]

testing::GTEST_DECLARE_bool_ ( death_test_use_fork  )

◆ GTEST_DECLARE_bool_() [2/9]

testing::GTEST_DECLARE_bool_ ( also_run_disabled_tests  )

◆ GTEST_DECLARE_bool_() [3/9]

testing::GTEST_DECLARE_bool_ ( break_on_failure  )

◆ GTEST_DECLARE_bool_() [4/9]

testing::GTEST_DECLARE_bool_ ( catch_exceptions  )

◆ 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_ ( death_test_style  )

◆ GTEST_DECLARE_string_() [2/5]

testing::GTEST_DECLARE_string_ ( color  )

◆ 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.

3984  {
3985  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
3986  substring));
3987 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller 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.

1187  {
1188  return internal::IgnoreResultAction<A>(an_action);
1189 }
Here is the caller 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 caller graph for this function:

◆ InitGoogleTest() [2/2]

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

◆ Invoke() [1/2]

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

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

115  {
116  return MakePolymorphicAction(
117  internal::InvokeAction<FunctionImpl>(function_impl));
118 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Invoke() [2/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.

124  {
125  return MakePolymorphicAction(
126  internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
127 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ InvokeWithoutArgs() [1/2]

template<typename FunctionImpl >
PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> > testing::InvokeWithoutArgs ( FunctionImpl  function_impl)

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

1168  {
1169  return MakePolymorphicAction(
1170  internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
1171 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ InvokeWithoutArgs() [2/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.

1177  {
1178  return MakePolymorphicAction(
1179  internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
1180  obj_ptr, method_ptr));
1181 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &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 char *  needle,
const char *  haystack 
)

◆ IsNotSubstring() [2/3]

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

◆ IsNotSubstring() [3/3]

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

◆ IsNull()

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

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

3795  {
3796  return MakePolymorphicMatcher(internal::IsNullMatcher());
3797 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ IsSubstring() [1/3]

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

◆ IsSubstring() [2/3]

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

◆ IsSubstring() [3/3]

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

◆ Key()

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

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

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

◆ Le() [1/2]

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

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

3778  {
3779  return internal::LeMatcher<Rhs>(x);
3780 }
Here is the caller graph for this function:

◆ Le() [2/2]

internal::Le2Matcher testing::Le ( )
inline

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

4094 { return internal::Le2Matcher(); }

◆ Lt() [1/2]

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

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

3784  {
3785  return internal::LtMatcher<Rhs>(x);
3786 }
Here is the caller graph for this function:

◆ Lt() [2/2]

internal::Lt2Matcher testing::Lt ( )
inline

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

4098 { return internal::Lt2Matcher(); }

◆ MakeAction()

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

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

463  {
464  return Action<F>(impl);
465 }
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.

141  {
142  return Cardinality(c);
143 }

◆ MakeMatcher()

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

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

484  {
485  return Matcher<T>(impl);
486 }
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.

475  {
476  return PolymorphicAction<Impl>(impl);
477 }
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.

496  {
497  return PolymorphicMatcher<Impl>(impl);
498 }
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.

48  : "is empty") {
49  if (arg.empty()) {
50  return true;
51  }
52  *result_listener << "whose size is " << arg.size();
53  return false;
54 }

◆ MatcherCast()

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

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

610  {
611  return internal::MatcherCastImpl<T, M>::Cast(matcher);
612 }
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 ( matcher)
inline

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

4341  {
4342  return internal::MatcherAsPredicate<M>(matcher);
4343 }
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.

4006  {
4007  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
4008 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
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.

4010  {
4011  return MatchesRegex(new internal::RE(regex));
4012 }
PolymorphicMatcher< internal::MatchesRegexMatcher > MatchesRegex(const internal::string &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.

3821  {
3822  return internal::FloatingEqMatcher<double>(rhs, true);
3823 }
Here is the caller graph for this function:

◆ NanSensitiveDoubleNear()

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

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

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

◆ NanSensitiveFloatEq()

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

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

3849  {
3850  return internal::FloatingEqMatcher<float>(rhs, true);
3851 }
Here is the caller graph for this function:

◆ NanSensitiveFloatNear()

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

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

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

◆ Ne() [1/2]

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

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

3790  {
3791  return internal::NeMatcher<Rhs>(x);
3792 }
Here is the caller graph for this function:

◆ Ne() [2/2]

internal::Ne2Matcher testing::Ne ( )
inline

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

4102 { return internal::Ne2Matcher(); }

◆ Not()

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

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

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

◆ NotNull()

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

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

3802  {
3803  return MakePolymorphicMatcher(internal::NotNullMatcher());
3804 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ operator<<() [1/2]

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

◆ operator<<() [2/2]

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

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

232  {
233  return os << sb.GetString();
234 }
Here is the call graph for this function:

◆ 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.

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

◆ Pointee()

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

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

3873  {
3874  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
3875 }
Here is the caller graph for this function:

◆ 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.

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

◆ PrintToString()

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

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

980  {
981  ::std::stringstream ss;
982  internal::UniversalTersePrinter<T>::Print(value, &ss);
983  return ss.str();
984 }
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
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::*)() const  property,
const PropertyMatcher &  matcher 
)
inline

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

3914  {
3915  return MakePolymorphicMatcher(
3916  internal::PropertyMatcher<Class, PropertyType>(
3917  property,
3918  MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
3919  // The call to MatcherCast() is required for supporting inner
3920  // matchers of compatible types. For example, it allows
3921  // Property(&Foo::bar, m)
3922  // to compile where bar() returns an int32 and m is a matcher for int64.
3923 }
#define GTEST_REFERENCE_TO_CONST_(T)
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Matcher< T > MatcherCast(const M &matcher)
Here is the call graph for this function:
Here is the caller 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.

3809  { // NOLINT
3810  return internal::RefMatcher<T&>(x);
3811 }
Here is the caller graph for this function:

◆ 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.

3940  {
3941  return internal::ResultOfMatcher<Callable>(
3942  callable,
3943  MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
3944  matcher));
3945  // The call to MatcherCast() is required for supporting inner
3946  // matchers of compatible types. For example, it allows
3947  // ResultOf(Function, m)
3948  // to compile where Function() returns an int32 and m is a matcher for int64.
3949 }
Here is the caller graph for this function:

◆ Return() [1/2]

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

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

1061  {
1062  return internal::ReturnAction<R>(internal::move(value));
1063 }
const T & move(const T &t)
Definition: gtest-port.h:1317
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Return() [2/2]

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

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

1071  {
1072  return MakePolymorphicAction(internal::ReturnVoidAction());
1073 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:

◆ ReturnNull()

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

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

1066  {
1067  return MakePolymorphicAction(internal::ReturnNullAction());
1068 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
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.

1077  { // NOLINT
1078  return internal::ReturnRefAction<R>(x);
1079 }
Here is the caller graph for this function:

◆ ReturnRefOfCopy()

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

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

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

◆ SafeMatcherCast()

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

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

665  {
666  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
667 }
Here is the call graph for this function:

◆ SetArgPointee() [1/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.

1109  {
1110  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
1112 }
const uint32_t T[512]
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
Here is the call graph for this function:

◆ SetArgPointee() [2/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.

1121  {
1122  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
1123  N, const char*, false>(p));
1124 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
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.

1129  {
1130  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
1131  N, const wchar_t*, false>(p));
1132 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
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.

1140  {
1141  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
1143 }
const uint32_t T[512]
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
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.

1156  {
1157  return MakePolymorphicAction(
1158  internal::SetErrnoAndReturnAction<T>(errval, result));
1159 }
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
Here is the call graph for this function:
Here is the caller 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.

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

◆ StartsWith()

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

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

3991  {
3992  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
3993  prefix));
3994 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ StaticAssertTypeEq()

template<typename T1 , typename T2 >
bool testing::StaticAssertTypeEq ( )

Definition at line 2150 of file gtest.h.

2150  {
2151  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
2152  return true;
2153 }
Here is the caller graph for this function:

◆ StrCaseEq()

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

3969  {
3970  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3971  str, true, false));
3972 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ StrCaseNe()

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

3976  {
3977  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3978  str, false, false));
3979 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ StrEq()

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

3955  {
3956  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3957  str, true, true));
3958 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ StrNe()

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

3962  {
3963  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3964  str, false, true));
3965 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller 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.

4116  {
4117  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
4118 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
Here is the call graph for this function:
Here is the caller 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.

3762 { return Eq(rhs); }
internal::Eq2Matcher Eq()
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.

785  {
786  typedef ::testing::tuple<> Args;
787  return internal::UnorderedElementsAreMatcher<Args>(Args());
788 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

794  {
795  typedef ::testing::tuple<
796  typename internal::DecayArray<T1>::type> Args;
797  return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
798 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

805  {
806  typedef ::testing::tuple<
807  typename internal::DecayArray<T1>::type,
808  typename internal::DecayArray<T2>::type> Args;
809  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
810 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

818  {
819  typedef ::testing::tuple<
820  typename internal::DecayArray<T1>::type,
821  typename internal::DecayArray<T2>::type,
822  typename internal::DecayArray<T3>::type> Args;
823  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
824 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

833  {
834  typedef ::testing::tuple<
835  typename internal::DecayArray<T1>::type,
836  typename internal::DecayArray<T2>::type,
837  typename internal::DecayArray<T3>::type,
838  typename internal::DecayArray<T4>::type> Args;
839  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
840 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

851  {
852  typedef ::testing::tuple<
853  typename internal::DecayArray<T1>::type,
854  typename internal::DecayArray<T2>::type,
855  typename internal::DecayArray<T3>::type,
856  typename internal::DecayArray<T4>::type,
857  typename internal::DecayArray<T5>::type> Args;
858  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
859 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

872  {
873  typedef ::testing::tuple<
874  typename internal::DecayArray<T1>::type,
875  typename internal::DecayArray<T2>::type,
876  typename internal::DecayArray<T3>::type,
877  typename internal::DecayArray<T4>::type,
878  typename internal::DecayArray<T5>::type,
879  typename internal::DecayArray<T6>::type> Args;
880  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
881  e6));
882 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

896  {
897  typedef ::testing::tuple<
898  typename internal::DecayArray<T1>::type,
899  typename internal::DecayArray<T2>::type,
900  typename internal::DecayArray<T3>::type,
901  typename internal::DecayArray<T4>::type,
902  typename internal::DecayArray<T5>::type,
903  typename internal::DecayArray<T6>::type,
904  typename internal::DecayArray<T7>::type> Args;
905  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
906  e6, e7));
907 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

922  {
923  typedef ::testing::tuple<
924  typename internal::DecayArray<T1>::type,
925  typename internal::DecayArray<T2>::type,
926  typename internal::DecayArray<T3>::type,
927  typename internal::DecayArray<T4>::type,
928  typename internal::DecayArray<T5>::type,
929  typename internal::DecayArray<T6>::type,
930  typename internal::DecayArray<T7>::type,
931  typename internal::DecayArray<T8>::type> Args;
932  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
933  e6, e7, e8));
934 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

950  {
951  typedef ::testing::tuple<
952  typename internal::DecayArray<T1>::type,
953  typename internal::DecayArray<T2>::type,
954  typename internal::DecayArray<T3>::type,
955  typename internal::DecayArray<T4>::type,
956  typename internal::DecayArray<T5>::type,
957  typename internal::DecayArray<T6>::type,
958  typename internal::DecayArray<T7>::type,
959  typename internal::DecayArray<T8>::type,
960  typename internal::DecayArray<T9>::type> Args;
961  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
962  e6, e7, e8, e9));
963 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
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.

981  {
982  typedef ::testing::tuple<
983  typename internal::DecayArray<T1>::type,
984  typename internal::DecayArray<T2>::type,
985  typename internal::DecayArray<T3>::type,
986  typename internal::DecayArray<T4>::type,
987  typename internal::DecayArray<T5>::type,
988  typename internal::DecayArray<T6>::type,
989  typename internal::DecayArray<T7>::type,
990  typename internal::DecayArray<T8>::type,
991  typename internal::DecayArray<T9>::type,
992  typename internal::DecayArray<T10>::type> Args;
993  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
994  e6, e7, e8, e9, e10));
995 }
internal::ArgsMatcher< InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > Args(const InnerMatcher &matcher)
Here is the call graph for this function:

◆ UnorderedElementsAreArray() [1/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.

3688  {
3689  typedef typename ::std::iterator_traits<Iter>::value_type T;
3690  return internal::UnorderedElementsAreArrayMatcher<T>(first, last);
3691 }
const uint32_t T[512]
Here is the caller 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.

3695  {
3697 }
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > UnorderedElementsAreArray(const Container &container)
mdb_size_t count(MDB_cursor *cur)
const GenericPointer< typename T::ValueType > & pointer
Definition: pointer.h:1124
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.

3701  {
3702  return UnorderedElementsAreArray(array, N);
3703 }
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > UnorderedElementsAreArray(const Container &container)
Here is the call graph for this function:

◆ UnorderedElementsAreArray() [4/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.

3708  {
3709  return UnorderedElementsAreArray(container.begin(), container.end());
3710 }
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > UnorderedElementsAreArray(const Container &container)
Here is the call 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.

4224  {
4225  // This following line is for working around a bug in MSVC 8.0,
4226  // which causes RhsContainer to be a const type sometimes (e.g. when
4227  // rhs_container is a const int[]).
4228  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
4229 
4230  // RhsView allows the same code to handle RhsContainer being a
4231  // STL-style container and it being a native C-style array.
4232  typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
4233  typedef typename RhsView::type RhsStlContainer;
4234  typedef typename RhsStlContainer::value_type Second;
4235  const RhsStlContainer& rhs_stl_container =
4236  RhsView::ConstReference(rhs_container);
4237 
4238  // Create a matcher for each element in rhs_container.
4239  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
4240  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
4241  it != rhs_stl_container.end(); ++it) {
4242  matchers.push_back(
4243  internal::MatcherBindSecond(tuple2_matcher, *it));
4244  }
4245 
4246  // Delegate the work to UnorderedElementsAreArray().
4247  return UnorderedElementsAreArray(matchers);
4248 }
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type > UnorderedElementsAreArray(const Container &container)
BoundSecondMatcher< Tuple2Matcher, Second > MatcherBindSecond(const Tuple2Matcher &tm, const Second &second)
#define GTEST_REMOVE_CONST_(T)
Here is the call graph for this function:

◆ Value()

template<typename T , typename M >
bool testing::Value ( const T value,
matcher 
)
inline

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

4347  {
4348  return testing::Matches(matcher)(value);
4349 }
internal::MatcherAsPredicate< M > Matches(M matcher)
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
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.

3885  {
3886  return MakePolymorphicMatcher(
3887  internal::WhenDynamicCastToMatcher<To>(inner_matcher));
3888 }
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
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.

4172  {
4173  return
4174  internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
4175  internal::LessComparator(), container_matcher);
4176 }

◆ 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.

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

◆ 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.

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

◆ WithArgs() [1/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.

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

◆ WithArgs() [2/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.

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

◆ WithArgs() [3/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.

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

◆ WithArgs() [4/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.

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

◆ WithArgs() [5/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.

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

◆ WithArgs() [6/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.

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

◆ WithArgs() [7/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.

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

◆ WithArgs() [8/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.

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

◆ WithArgs() [9/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.

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

◆ WithArgs() [10/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.

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

◆ WithoutArgs()

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

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

135  {
136  return internal::WithArgsAction<InnerAction>(action);
137 }
Here is the caller graph for this function:

Variable Documentation

◆ _

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

Definition at line 3729 of file gmock-matchers.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.