Orxonox  0.0.5 Codename: Arcturus
Namespaces | Classes | Typedefs | Functions | Variables
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  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  NiceMock
 
class  PolymorphicAction
 
class  PolymorphicMatcher
 
class  SafeMatcherCastImpl
 
class  ScopedFakeTestPartResultReporter
 
class  Sequence
 
class  StrictMock
 
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::TimeInMillis TimeInMillis
 
typedef internal::IgnoredValue Unused
 

Functions

template<typename T >
Matcher< T > A ()
 
 ACTION_P (ReturnPointee, pointer)
 
 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_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))
 
Environment * AddGlobalTestEnvironment (Environment *env)
 
template<typename InnerMatcher >
InnerMatcher AllArgs (const InnerMatcher &matcher)
 
template<typename Matcher1 , typename Matcher2 >
internal::BothOfMatcher< Matcher1, Matcher2 > AllOf (Matcher1 m1, Matcher2 m2)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, Matcher3 > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, Matcher4 > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, Matcher5 > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, internal::BothOfMatcher< Matcher5, Matcher6 > > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, internal::BothOfMatcher< Matcher5, internal::BothOfMatcher< Matcher6, Matcher7 > > > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, internal::BothOfMatcher< Matcher5, internal::BothOfMatcher< Matcher6, internal::BothOfMatcher< Matcher7, Matcher8 > > > > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, internal::BothOfMatcher< Matcher5, internal::BothOfMatcher< Matcher6, internal::BothOfMatcher< Matcher7, internal::BothOfMatcher< Matcher8, Matcher9 > > > > > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 , typename Matcher10 >
internal::BothOfMatcher< Matcher1, internal::BothOfMatcher< Matcher2, internal::BothOfMatcher< Matcher3, internal::BothOfMatcher< Matcher4, internal::BothOfMatcher< Matcher5, internal::BothOfMatcher< Matcher6, internal::BothOfMatcher< Matcher7, internal::BothOfMatcher< Matcher8, internal::BothOfMatcher< Matcher9, Matcher10 > > > > > > > > > AllOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9, Matcher10 m10)
 
template<typename T >
Matcher< T > An ()
 
Cardinality AnyNumber ()
 
template<typename Matcher1 , typename Matcher2 >
internal::EitherOfMatcher< Matcher1, Matcher2 > AnyOf (Matcher1 m1, Matcher2 m2)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, Matcher3 > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, Matcher4 > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, Matcher5 > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, internal::EitherOfMatcher< Matcher5, Matcher6 > > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, internal::EitherOfMatcher< Matcher5, internal::EitherOfMatcher< Matcher6, Matcher7 > > > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, internal::EitherOfMatcher< Matcher5, internal::EitherOfMatcher< Matcher6, internal::EitherOfMatcher< Matcher7, Matcher8 > > > > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, internal::EitherOfMatcher< Matcher5, internal::EitherOfMatcher< Matcher6, internal::EitherOfMatcher< Matcher7, internal::EitherOfMatcher< Matcher8, Matcher9 > > > > > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9)
 
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 , typename Matcher10 >
internal::EitherOfMatcher< Matcher1, internal::EitherOfMatcher< Matcher2, internal::EitherOfMatcher< Matcher3, internal::EitherOfMatcher< Matcher4, internal::EitherOfMatcher< Matcher5, internal::EitherOfMatcher< Matcher6, internal::EitherOfMatcher< Matcher7, internal::EitherOfMatcher< Matcher8, internal::EitherOfMatcher< Matcher9, Matcher10 > > > > > > > > > AnyOf (Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5, Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9, Matcher10 m10)
 
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)
 
GTEST_API_ AssertionResult AssertionFailure ()
 
GTEST_API_ AssertionResult AssertionFailure (const Message &msg)
 
GTEST_API_ AssertionResult AssertionSuccess ()
 
template<typename T1 , typename T2 >
PolymorphicAction< internal::AssignAction< T1, T2 > > Assign (T1 *ptr, T2 val)
 
Cardinality AtLeast (int n)
 
Cardinality AtMost (int n)
 
Cardinality Between (int min, int max)
 
template<typename T >
internal::ReferenceWrapper< T > ByRef (T &l_value)
 
template<typename T >
const T & Const (const T &x)
 
template<typename Container >
PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> > ContainerEq (const Container &rhs)
 
template<typename M >
internal::ContainsMatcher< M > Contains (M matcher)
 
PolymorphicMatcher< internal::MatchesRegexMatcher > ContainsRegex (const internal::RE *regex)
 
PolymorphicMatcher< internal::MatchesRegexMatcher > ContainsRegex (const internal::string &regex)
 
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)
 
internal::DoDefaultAction DoDefault ()
 
internal::FloatingEqMatcher< double > DoubleEq (double rhs)
 
GTEST_API_ AssertionResult DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
 
template<typename M >
internal::EachMatcher< M > Each (M matcher)
 
internal::ElementsAreMatcher0 ElementsAre ()
 
template<typename T1 >
internal::ElementsAreMatcher1< T1 > ElementsAre (const T1 &e1)
 
template<typename T1 , typename T2 >
internal::ElementsAreMatcher2< T1, T2 > ElementsAre (const T1 &e1, const T2 &e2)
 
template<typename T1 , typename T2 , typename T3 >
internal::ElementsAreMatcher3< T1, T2, T3 > ElementsAre (const T1 &e1, const T2 &e2, const T3 &e3)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
internal::ElementsAreMatcher4< T1, T2, T3, T4 > 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::ElementsAreMatcher5< T1, T2, T3, T4, T5 > 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::ElementsAreMatcher6< T1, T2, T3, T4, T5, T6 > 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::ElementsAreMatcher7< T1, T2, T3, T4, T5, T6, T7 > 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::ElementsAreMatcher8< T1, T2, T3, T4, T5, T6, T7, T8 > 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::ElementsAreMatcher9< T1, T2, T3, T4, T5, T6, T7, T8, T9 > 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::ElementsAreMatcher10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > 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)
 
template<typename T >
internal::ElementsAreArrayMatcher< T > ElementsAreArray (const T *first, size_t count)
 
template<typename T , size_t N>
internal::ElementsAreArrayMatcher< T > ElementsAreArray (const T(&array)[N])
 
PolymorphicMatcher< internal::EndsWithMatcher< internal::string > > EndsWith (const internal::string &suffix)
 
template<typename T >
internal::EqMatcher< T > Eq (T x)
 
internal::Eq2Matcher Eq ()
 
Cardinality Exactly (int n)
 
template<typename T , typename M >
bool ExplainMatchResult (M matcher, const T &value, MatchResultListener *listener)
 
template<typename Class , typename FieldType , typename FieldMatcher >
PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > > Field (FieldType Class::*field, const FieldMatcher &matcher)
 
internal::FloatingEqMatcher< float > FloatEq (float rhs)
 
GTEST_API_ AssertionResult FloatLE (const char *expr1, const char *expr2, float val1, float val2)
 
static internal::String FormatCountableNoun (int count, const char *singular_form, const char *plural_form)
 
static internal::String FormatTestCaseCount (int test_case_count)
 
static internal::String FormatTestCount (int test_count)
 
template<typename Rhs >
internal::GeMatcher< Rhs > Ge (Rhs x)
 
internal::Ge2Matcher Ge ()
 
 GMOCK_DECLARE_bool_ (catch_leaked_mocks)
 
 GMOCK_DECLARE_string_ (verbose)
 
 GMOCK_DEFINE_bool_ (catch_leaked_mocks, true,"true iff Google Mock should report leaked mock objects ""as failures.")
 
 GMOCK_DEFINE_string_ (verbose, internal::kWarningVerbosity,"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only.")
 
template<typename Rhs >
internal::GtMatcher< Rhs > Gt (Rhs x)
 
internal::Gt2Matcher Gt ()
 
 GTEST_DECLARE_bool_ (death_test_use_fork)
 
 GTEST_DECLARE_bool_ (also_run_disabled_tests)
 
 GTEST_DECLARE_bool_ (break_on_failure)
 
 GTEST_DECLARE_bool_ (catch_exceptions)
 
 GTEST_DECLARE_bool_ (list_tests)
 
 GTEST_DECLARE_bool_ (print_time)
 
 GTEST_DECLARE_bool_ (show_internal_stack_frames)
 
 GTEST_DECLARE_bool_ (shuffle)
 
 GTEST_DECLARE_bool_ (throw_on_failure)
 
 GTEST_DECLARE_int32_ (random_seed)
 
 GTEST_DECLARE_int32_ (repeat)
 
 GTEST_DECLARE_int32_ (stack_trace_depth)
 
 GTEST_DECLARE_string_ (death_test_style)
 
 GTEST_DECLARE_string_ (color)
 
 GTEST_DECLARE_string_ (filter)
 
 GTEST_DECLARE_string_ (output)
 
 GTEST_DECLARE_string_ (stream_result_to)
 
 GTEST_DEFINE_bool_ (death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false),"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is fixed, this flag will ""most likely be removed.")
 
 GTEST_DEFINE_bool_ (also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false),"Run disabled tests too, in addition to the tests normally being run.")
 
 GTEST_DEFINE_bool_ (break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),"True iff a failed assertion should be a debugger break-point.")
 
 GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true),"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures.")
 
 GTEST_DEFINE_bool_ (list_tests, false,"List all tests without running them.")
 
 GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true),"True iff "GTEST_NAME_" should display elapsed time in text output.")
 
 GTEST_DEFINE_bool_ (show_internal_stack_frames, false,"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces.")
 
 GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false),"True iff "GTEST_NAME_" should randomize tests' order on every run.")
 
 GTEST_DEFINE_bool_ (throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false),"When this flag is specified, a failed assertion will throw an exception ""if exceptions are enabled or exit the program with a non-zero code ""otherwise.")
 
 GTEST_DEFINE_int32_ (random_seed, internal::Int32FromGTestEnv("random_seed", 0),"Random number seed to use when shuffling test orders. Must be in range ""[1, 99999], or 0 to use a seed based on the current time.")
 
 GTEST_DEFINE_int32_ (repeat, internal::Int32FromGTestEnv("repeat", 1),"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests.")
 
 GTEST_DEFINE_int32_ (stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through 100, inclusive.")
 
 GTEST_DEFINE_string_ (death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking).")
 
 GTEST_DEFINE_string_ (color, internal::StringFromGTestEnv("color","auto"),"Whether to use colors in the output. Valid values: yes, no, ""and auto. 'auto' means to use colors if the output is ""being sent to a terminal and the TERM environment variable ""is set to xterm, xterm-color, xterm-256color, linux or cygwin.")
 
 GTEST_DEFINE_string_ (filter, internal::StringFromGTestEnv("filter", kUniversalFilter),"A colon-separated list of glob (not regex) patterns ""for filtering the tests to run, optionally followed by a ""'-' and a : separated list of negative patterns (tests to ""exclude). A test is run if it matches one of the positive ""patterns and does not match any of the negative patterns.")
 
 GTEST_DEFINE_string_ (output, internal::StringFromGTestEnv("output",""),"A format (currently must be \"xml\"), optionally followed ""by a colon and an output file name or directory. A directory ""is indicated by a trailing pathname separator. ""Examples: \"xml:filename.xml\", \"xml::directoryname/\". ""If a directory is specified, output files will be created ""within that directory, with file-names based on the test ""executable's name and, if necessary, made unique by adding ""digits.")
 
 GTEST_DEFINE_string_ (stream_result_to, internal::StringFromGTestEnv("stream_result_to",""),"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux.")
 
PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > > HasSubstr (const internal::string &substring)
 
template<typename A >
internal::IgnoreResultAction< A > IgnoreResult (const A &an_action)
 
void InitGoogleMock (int *argc, char **argv)
 
void InitGoogleMock (int *argc, wchar_t **argv)
 
GTEST_API_ void InitGoogleTest (int *argc, char **argv)
 
GTEST_API_ void InitGoogleTest (int *argc, wchar_t **argv)
 
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 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)
 
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 IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
 
PolymorphicMatcher< internal::IsNullMatcher > IsNull ()
 
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 IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
 
template<typename M >
internal::KeyMatcher< M > Key (M inner_matcher)
 
template<typename Rhs >
internal::LeMatcher< Rhs > Le (Rhs x)
 
internal::Le2Matcher Le ()
 
template<typename Rhs >
internal::LtMatcher< Rhs > Lt (Rhs x)
 
internal::Lt2Matcher Lt ()
 
template<typename F >
Action< F > MakeAction (ActionInterface< F > *impl)
 
Cardinality MakeCardinality (const CardinalityInterface *c)
 
template<typename T >
Matcher< T > MakeMatcher (const MatcherInterface< T > *impl)
 
template<typename Impl >
PolymorphicAction< Impl > MakePolymorphicAction (const Impl &impl)
 
template<class Impl >
PolymorphicMatcher< Impl > MakePolymorphicMatcher (const Impl &impl)
 
template<typename T , typename M >
Matcher< T > MatcherCast (M m)
 
template<typename M >
internal::MatcherAsPredicate< M > Matches (M matcher)
 
PolymorphicMatcher< internal::MatchesRegexMatcher > MatchesRegex (const internal::RE *regex)
 
PolymorphicMatcher< internal::MatchesRegexMatcher > MatchesRegex (const internal::string &regex)
 
internal::FloatingEqMatcher< double > NanSensitiveDoubleEq (double rhs)
 
internal::FloatingEqMatcher< float > NanSensitiveFloatEq (float rhs)
 
template<typename Rhs >
internal::NeMatcher< Rhs > Ne (Rhs x)
 
internal::Ne2Matcher Ne ()
 
template<typename InnerMatcher >
internal::NotMatcher< InnerMatcher > Not (InnerMatcher m)
 
PolymorphicMatcher< internal::NotNullMatcher > NotNull ()
 
std::ostream & operator<< (std::ostream &os, const TestPartResult &result)
 
std::ostream & operator<< (std::ostream &os, const Message &sb)
 
template<typename FirstMatcher , typename SecondMatcher >
internal::PairMatcher< FirstMatcher, SecondMatcher > Pair (FirstMatcher first_matcher, SecondMatcher second_matcher)
 
template<typename InnerMatcher >
internal::PointeeMatcher< InnerMatcher > Pointee (const InnerMatcher &inner_matcher)
 
template<typename TupleMatcher , typename Container >
internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)> Pointwise (const TupleMatcher &tuple_matcher, const Container &rhs)
 
static void PrintTestPartResult (const TestPartResult &test_part_result)
 
static internal::String PrintTestPartResultToString (const TestPartResult &test_part_result)
 
template<typename T >
::std::string PrintToString (const T &value)
 
template<typename Class , typename PropertyType , typename PropertyMatcher >
PolymorphicMatcher< internal::PropertyMatcher< Class, PropertyType > > Property (PropertyType(Class::*property)() const, const PropertyMatcher &matcher)
 
template<typename T >
internal::RefMatcher< T & > Ref (T &x)
 
template<typename Callable , typename ResultOfMatcher >
internal::ResultOfMatcher< Callable > ResultOf (Callable callable, const ResultOfMatcher &matcher)
 
template<typename R >
internal::ReturnAction< R > Return (R value)
 
PolymorphicAction< internal::ReturnVoidAction > Return ()
 
PolymorphicAction< internal::ReturnNullAction > ReturnNull ()
 
template<typename R >
internal::ReturnRefAction< R > ReturnRef (R &x)
 
template<typename R >
internal::ReturnRefOfCopyAction< R > ReturnRefOfCopy (const R &x)
 
template<typename T , typename M >
Matcher< T > SafeMatcherCast (const M &polymorphic_matcher)
 
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 T >
PolymorphicAction< internal::SetErrnoAndReturnAction< T > > SetErrnoAndReturn (int errval, T result)
 
PolymorphicMatcher< internal::StartsWithMatcher< internal::string > > StartsWith (const internal::string &prefix)
 
template<typename T1 , typename T2 >
bool StaticAssertTypeEq ()
 
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrCaseEq (const internal::string &str)
 
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrCaseNe (const internal::string &str)
 
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrEq (const internal::string &str)
 
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrNe (const internal::string &str)
 
static bool TestPartFatallyFailed (const TestPartResult &result)
 
static bool TestPartNonfatallyFailed (const TestPartResult &result)
 
static const char * TestPartResultTypeToString (TestPartResult::Type type)
 
template<typename Predicate >
PolymorphicMatcher< internal::TrulyMatcher< Predicate > > Truly (Predicate pred)
 
template<typename Lhs , typename Rhs >
Matcher< Lhs > TypedEq (const Rhs &rhs)
 
template<typename T , typename M >
bool Value (const T &value, M matcher)
 
template<int k, typename InnerAction >
internal::WithArgsAction< InnerAction, k > WithArg (const InnerAction &action)
 
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 InnerAction >
internal::WithArgsAction< InnerAction > WithoutArgs (const InnerAction &action)
 

Variables

const internal::AnythingMatcher _ = {}
 
class testing::InSequence GTEST_ATTRIBUTE_UNUSED_
 
static const char kDeathTestCaseFilter [] = "*DeathTest:*DeathTest/*"
 
static const char kDefaultDeathTestStyle [] = "fast"
 
static const char kDefaultOutputFile [] = "test_detail.xml"
 
static const char kDisableTestFilter [] = "DISABLED_*:*/DISABLED_*"
 
const int kMaxStackTraceDepth = 100
 
static const char kTestShardIndex [] = "GTEST_SHARD_INDEX"
 
static const char kTestShardStatusFile [] = "GTEST_SHARD_STATUS_FILE"
 
static const char kTestTotalShards [] = "GTEST_TOTAL_SHARDS"
 
static const char kUniversalFilter [] = "*"
 

Typedef Documentation

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

Function Documentation

template<typename T >
Matcher< T > testing::A ( )
inline
testing::ACTION_P ( ReturnPointee  ,
pointer   
)
testing::ACTION_TEMPLATE ( ReturnArg  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_0_VALUE_PARAMS()   
)
testing::ACTION_TEMPLATE ( SaveArg  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_1_VALUE_PARAMS(pointer)   
)
testing::ACTION_TEMPLATE ( SaveArgPointee  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_1_VALUE_PARAMS(pointer)   
)
testing::ACTION_TEMPLATE ( SetArgReferee  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_1_VALUE_PARAMS(value)   
)
testing::ACTION_TEMPLATE ( SetArrayArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_2_VALUE_PARAMS(first, last)   
)
testing::ACTION_TEMPLATE ( DeleteArg  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_0_VALUE_PARAMS()   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_0_VALUE_PARAMS()   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_1_VALUE_PARAMS(p0)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_2_VALUE_PARAMS(p0, p1)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_3_VALUE_PARAMS(p0, p1, p2)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_4_VALUE_PARAMS(p0, p1, p2, p3)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)   
)
testing::ACTION_TEMPLATE ( InvokeArgument  ,
HAS_1_TEMPLATE_PARAMS(int, k)  ,
AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_0_VALUE_PARAMS()   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_1_VALUE_PARAMS(p0)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_2_VALUE_PARAMS(p0, p1)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_3_VALUE_PARAMS(p0, p1, p2)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_4_VALUE_PARAMS(p0, p1, p2, p3)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)   
)
testing::ACTION_TEMPLATE ( ReturnNew  ,
HAS_1_TEMPLATE_PARAMS(typename, T)  ,
AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)   
)
Environment* testing::AddGlobalTestEnvironment ( Environment *  env)
inline
template<typename InnerMatcher >
InnerMatcher testing::AllArgs ( const InnerMatcher &  matcher)
inline
template<typename Matcher1 , typename Matcher2 >
internal::BothOfMatcher<Matcher1, Matcher2> testing::AllOf ( Matcher1  m1,
Matcher2  m2 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, Matcher3> > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, Matcher4> > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, Matcher5> > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, internal::BothOfMatcher<Matcher5, Matcher6> > > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6, Matcher7> > > > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6, internal::BothOfMatcher<Matcher7, Matcher8> > > > > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6, internal::BothOfMatcher<Matcher7, internal::BothOfMatcher<Matcher8, Matcher9> > > > > > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8,
Matcher9  m9 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 , typename Matcher10 >
internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2, internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4, internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6, internal::BothOfMatcher<Matcher7, internal::BothOfMatcher<Matcher8, internal::BothOfMatcher<Matcher9, Matcher10> > > > > > > > > testing::AllOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8,
Matcher9  m9,
Matcher10  m10 
)
inline
template<typename T >
Matcher<T> testing::An ( )
inline
Cardinality testing::AnyNumber ( )
template<typename Matcher1 , typename Matcher2 >
internal::EitherOfMatcher<Matcher1, Matcher2> testing::AnyOf ( Matcher1  m1,
Matcher2  m2 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, Matcher3> > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, Matcher4> > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, Matcher5> > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, internal::EitherOfMatcher<Matcher5, Matcher6> > > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6, Matcher7> > > > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6, internal::EitherOfMatcher<Matcher7, Matcher8> > > > > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6, internal::EitherOfMatcher<Matcher7, internal::EitherOfMatcher<Matcher8, Matcher9> > > > > > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8,
Matcher9  m9 
)
inline
template<typename Matcher1 , typename Matcher2 , typename Matcher3 , typename Matcher4 , typename Matcher5 , typename Matcher6 , typename Matcher7 , typename Matcher8 , typename Matcher9 , typename Matcher10 >
internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2, internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4, internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6, internal::EitherOfMatcher<Matcher7, internal::EitherOfMatcher<Matcher8, internal::EitherOfMatcher<Matcher9, Matcher10> > > > > > > > > testing::AnyOf ( Matcher1  m1,
Matcher2  m2,
Matcher3  m3,
Matcher4  m4,
Matcher5  m5,
Matcher6  m6,
Matcher7  m7,
Matcher8  m8,
Matcher9  m9,
Matcher10  m10 
)
inline
template<typename InnerMatcher >
internal::ArgsMatcher<InnerMatcher> testing::Args ( const InnerMatcher &  matcher)
inline
template<int k1, typename InnerMatcher >
internal::ArgsMatcher<InnerMatcher, k1> testing::Args ( const InnerMatcher &  matcher)
inline
template<int k1, int k2, typename InnerMatcher >
internal::ArgsMatcher<InnerMatcher, k1, k2> testing::Args ( const InnerMatcher &  matcher)
inline
template<int k1, int k2, int k3, typename InnerMatcher >
internal::ArgsMatcher<InnerMatcher, k1, k2, k3> testing::Args ( const InnerMatcher &  matcher)
inline
template<int k1, int k2, int k3, int k4, typename InnerMatcher >
internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4> testing::Args ( const InnerMatcher &  matcher)
inline
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
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
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
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
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
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
AssertionResult testing::AssertionFailure ( )
AssertionResult testing::AssertionFailure ( const Message &  msg)
AssertionResult testing::AssertionSuccess ( )
template<typename T1 , typename T2 >
PolymorphicAction<internal::AssignAction<T1, T2> > testing::Assign ( T1 *  ptr,
T2  val 
)
Cardinality testing::AtLeast ( int  n)
Cardinality testing::AtMost ( int  n)
Cardinality testing::Between ( int  min,
int  max 
)
template<typename T >
internal::ReferenceWrapper<T> testing::ByRef ( T &  l_value)
inline
template<typename T >
const T& testing::Const ( const T &  x)
inline
template<typename Container >
PolymorphicMatcher<internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> > testing::ContainerEq ( const Container &  rhs)
inline
template<typename M >
internal::ContainsMatcher<M> testing::Contains ( M  matcher)
inline
PolymorphicMatcher<internal::MatchesRegexMatcher> testing::ContainsRegex ( const internal::RE *  regex)
inline
PolymorphicMatcher<internal::MatchesRegexMatcher> testing::ContainsRegex ( const internal::string &  regex)
inline
template<typename Action1 , typename Action2 >
internal::DoBothAction<Action1, Action2> testing::DoAll ( Action1  a1,
Action2  a2 
)
inline
template<typename Action1 , typename Action2 , typename Action3 >
internal::DoBothAction<Action1, internal::DoBothAction<Action2, Action3> > testing::DoAll ( Action1  a1,
Action2  a2,
Action3  a3 
)
inline
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
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
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
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
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
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
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
internal::DoDefaultAction testing::DoDefault ( )
inline
internal::FloatingEqMatcher<double> testing::DoubleEq ( double  rhs)
inline
AssertionResult testing::DoubleLE ( const char *  expr1,
const char *  expr2,
double  val1,
double  val2 
)
template<typename M >
internal::EachMatcher<M> testing::Each ( M  matcher)
inline
internal::ElementsAreMatcher0 testing::ElementsAre ( )
inline
template<typename T1 >
internal::ElementsAreMatcher1<T1> testing::ElementsAre ( const T1 &  e1)
inline
template<typename T1 , typename T2 >
internal::ElementsAreMatcher2<T1, T2> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2 
)
inline
template<typename T1 , typename T2 , typename T3 >
internal::ElementsAreMatcher3<T1, T2, T3> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2,
const T3 &  e3 
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 >
internal::ElementsAreMatcher4<T1, T2, T3, T4> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2,
const T3 &  e3,
const T4 &  e4 
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
internal::ElementsAreMatcher5<T1, T2, T3, T4, T5> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2,
const T3 &  e3,
const T4 &  e4,
const T5 &  e5 
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
internal::ElementsAreMatcher6<T1, T2, T3, T4, T5, T6> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2,
const T3 &  e3,
const T4 &  e4,
const T5 &  e5,
const T6 &  e6 
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
internal::ElementsAreMatcher7<T1, T2, T3, T4, T5, T6, T7> testing::ElementsAre ( const T1 &  e1,
const T2 &  e2,
const T3 &  e3,
const T4 &  e4,
const T5 &  e5,
const T6 &  e6,
const T7 &  e7 
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
internal::ElementsAreMatcher8<T1, T2, T3, T4, T5, T6, T7, T8> 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
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
internal::ElementsAreMatcher9<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
internal::ElementsAreMatcher10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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
template<typename T >
internal::ElementsAreArrayMatcher<T> testing::ElementsAreArray ( const T *  first,
size_t  count 
)
inline
template<typename T , size_t N>
internal::ElementsAreArrayMatcher<T> testing::ElementsAreArray ( const T(&)  array[N])
inline
PolymorphicMatcher<internal::EndsWithMatcher<internal::string> > testing::EndsWith ( const internal::string &  suffix)
inline
template<typename T >
internal::EqMatcher<T> testing::Eq ( T  x)
inline
internal::Eq2Matcher testing::Eq ( )
inline
Cardinality testing::Exactly ( int  n)
template<typename T , typename M >
bool testing::ExplainMatchResult ( M  matcher,
const T &  value,
MatchResultListener *  listener 
)
inline
template<typename Class , typename FieldType , typename FieldMatcher >
PolymorphicMatcher< internal::FieldMatcher<Class, FieldType> > testing::Field ( FieldType Class::*  field,
const FieldMatcher &  matcher 
)
inline
internal::FloatingEqMatcher<float> testing::FloatEq ( float  rhs)
inline
AssertionResult testing::FloatLE ( const char *  expr1,
const char *  expr2,
float  val1,
float  val2 
)
static internal::String testing::FormatCountableNoun ( int  count,
const char *  singular_form,
const char *  plural_form 
)
static
static internal::String testing::FormatTestCaseCount ( int  test_case_count)
static
static internal::String testing::FormatTestCount ( int  test_count)
static
template<typename Rhs >
internal::GeMatcher<Rhs> testing::Ge ( Rhs  x)
inline
internal::Ge2Matcher testing::Ge ( )
inline
testing::GMOCK_DECLARE_bool_ ( catch_leaked_mocks  )
testing::GMOCK_DECLARE_string_ ( verbose  )
testing::GMOCK_DEFINE_bool_ ( catch_leaked_mocks  ,
true  ,
"true iff Google Mock should report leaked mock objects ""as failures."   
)
testing::GMOCK_DEFINE_string_ ( verbose  ,
internal::kWarningVerbosity  ,
"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only."   
)
template<typename Rhs >
internal::GtMatcher<Rhs> testing::Gt ( Rhs  x)
inline
internal::Gt2Matcher testing::Gt ( )
inline
testing::GTEST_DECLARE_bool_ ( death_test_use_fork  )
testing::GTEST_DECLARE_bool_ ( also_run_disabled_tests  )
testing::GTEST_DECLARE_bool_ ( break_on_failure  )
testing::GTEST_DECLARE_bool_ ( catch_exceptions  )
testing::GTEST_DECLARE_bool_ ( list_tests  )
testing::GTEST_DECLARE_bool_ ( print_time  )
testing::GTEST_DECLARE_bool_ ( show_internal_stack_frames  )
testing::GTEST_DECLARE_bool_ ( shuffle  )
testing::GTEST_DECLARE_bool_ ( throw_on_failure  )
testing::GTEST_DECLARE_int32_ ( random_seed  )
testing::GTEST_DECLARE_int32_ ( repeat  )
testing::GTEST_DECLARE_int32_ ( stack_trace_depth  )
testing::GTEST_DECLARE_string_ ( death_test_style  )
testing::GTEST_DECLARE_string_ ( color  )
testing::GTEST_DECLARE_string_ ( filter  )
testing::GTEST_DECLARE_string_ ( output  )
testing::GTEST_DECLARE_string_ ( stream_result_to  )
testing::GTEST_DEFINE_bool_ ( death_test_use_fork  ,
internal::BoolFromGTestEnv("death_test_use_fork", false)  ,
"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is  fixed,
this flag will""most likely be removed."   
)
testing::GTEST_DEFINE_bool_ ( also_run_disabled_tests  ,
internal::BoolFromGTestEnv("also_run_disabled_tests", false)  ,
"Run disabled tests  too,
in addition to the tests normally being run."   
)
testing::GTEST_DEFINE_bool_ ( break_on_failure  ,
internal::BoolFromGTestEnv("break_on_failure", false)  ,
"True iff a failed assertion should be a debugger break-point."   
)
testing::GTEST_DEFINE_bool_ ( catch_exceptions  ,
internal::BoolFromGTestEnv("catch_exceptions", true)  ,
"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures."   
)
testing::GTEST_DEFINE_bool_ ( list_tests  ,
false  ,
"List all tests without running them."   
)
testing::GTEST_DEFINE_bool_ ( print_time  ,
internal::BoolFromGTestEnv("print_time", true)  ,
"True iff "GTEST_NAME_" should display elapsed time in text output."   
)
testing::GTEST_DEFINE_bool_ ( show_internal_stack_frames  ,
false  ,
"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces."   
)
testing::GTEST_DEFINE_bool_ ( shuffle  ,
internal::BoolFromGTestEnv("shuffle", false)  ,
"True iff "GTEST_NAME_" should randomize tests' order on every run."   
)
testing::GTEST_DEFINE_bool_ ( throw_on_failure  ,
internal::BoolFromGTestEnv("throw_on_failure", false)  ,
"When this flag is  specified,
a failed assertion will throw an exception""if exceptions are enabled or exit the program with a non-zero code""otherwise."   
)
testing::GTEST_DEFINE_int32_ ( random_seed  ,
internal::Int32FromGTestEnv("random_seed", 0)  ,
"Random number seed to use when shuffling test orders. Must be in range ""  [1, 99999],
or 0 to use a seed based on the current time."   
)
testing::GTEST_DEFINE_int32_ ( repeat  ,
internal::Int32FromGTestEnv("repeat", 1)  ,
"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests."   
)
testing::GTEST_DEFINE_int32_ ( stack_trace_depth  ,
internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth)  ,
"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through  100,
inclusive."   
)
testing::GTEST_DEFINE_string_ ( death_test_style  ,
internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle)  ,
"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking)."   
)
testing::GTEST_DEFINE_string_ ( color  ,
internal::StringFromGTestEnv("color","auto")  ,
"Whether to use colors in the output. Valid values:  yes,
no  ,
""and auto. 'auto'means to use colors if the output is""being sent to a terminal and the TERM environment variable""is set to  xterm,
xterm-  color,
xterm-  256color,
linux or cygwin."   
)
testing::GTEST_DEFINE_string_ ( filter  ,
internal::StringFromGTestEnv("filter", kUniversalFilter)  ,
"A colon-separated list of glob (not regex) patterns ""for filtering the tests to  run,
optionally followed by a""'-'and a:separated list of negative patterns(tests to""exclude).A test is run if it matches one of the positive""patterns and does not match any of the negative patterns."   
)
testing::GTEST_DEFINE_string_ ( output  ,
internal::StringFromGTestEnv("output","")  ,
"A format   currently must be \"xml\",
optionally followed""by a colon and an output file name or directory.A directory""is indicated by a trailing pathname separator.""Examples:\"xml:filename.xml\"  ,
\"xml::directoryname/\". ""If a directory is  specified,
output files will be created""within that  directory,
with file-names based on the test""executable's name  and,
if  necessary,
made unique by adding""digits."   
)
testing::GTEST_DEFINE_string_ ( stream_result_to  ,
internal::StringFromGTestEnv("stream_result_to","")  ,
"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux."   
)
PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> > testing::HasSubstr ( const internal::string &  substring)
inline
template<typename A >
internal::IgnoreResultAction<A> testing::IgnoreResult ( const A &  an_action)
inline
void testing::InitGoogleMock ( int *  argc,
char **  argv 
)
void testing::InitGoogleMock ( int *  argc,
wchar_t **  argv 
)
void testing::InitGoogleTest ( int *  argc,
char **  argv 
)
void testing::InitGoogleTest ( int *  argc,
wchar_t **  argv 
)
template<typename FunctionImpl >
PolymorphicAction<internal::InvokeAction<FunctionImpl> > testing::Invoke ( FunctionImpl  function_impl)
template<class Class , typename MethodPtr >
PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > testing::Invoke ( Class *  obj_ptr,
MethodPtr  method_ptr 
)
template<typename FunctionImpl >
PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> > testing::InvokeWithoutArgs ( FunctionImpl  function_impl)
template<class Class , typename MethodPtr >
PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> > testing::InvokeWithoutArgs ( Class *  obj_ptr,
MethodPtr  method_ptr 
)
AssertionResult testing::IsNotSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const char *  needle,
const char *  haystack 
)
AssertionResult testing::IsNotSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const wchar_t *  needle,
const wchar_t *  haystack 
)
AssertionResult testing::IsNotSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const ::std::string &  needle,
const ::std::string &  haystack 
)
PolymorphicMatcher<internal::IsNullMatcher > testing::IsNull ( )
inline
AssertionResult testing::IsSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const char *  needle,
const char *  haystack 
)
AssertionResult testing::IsSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const wchar_t *  needle,
const wchar_t *  haystack 
)
AssertionResult testing::IsSubstring ( const char *  needle_expr,
const char *  haystack_expr,
const ::std::string &  needle,
const ::std::string &  haystack 
)
template<typename M >
internal::KeyMatcher<M> testing::Key ( M  inner_matcher)
inline
template<typename Rhs >
internal::LeMatcher<Rhs> testing::Le ( Rhs  x)
inline
internal::Le2Matcher testing::Le ( )
inline
template<typename Rhs >
internal::LtMatcher<Rhs> testing::Lt ( Rhs  x)
inline
internal::Lt2Matcher testing::Lt ( )
inline
template<typename F >
Action<F> testing::MakeAction ( ActionInterface< F > *  impl)
Cardinality testing::MakeCardinality ( const CardinalityInterface *  c)
inline
template<typename T >
Matcher<T> testing::MakeMatcher ( const MatcherInterface< T > *  impl)
inline
template<typename Impl >
PolymorphicAction<Impl> testing::MakePolymorphicAction ( const Impl &  impl)
inline
template<class Impl >
PolymorphicMatcher<Impl> testing::MakePolymorphicMatcher ( const Impl &  impl)
inline
template<typename T , typename M >
Matcher< T > testing::MatcherCast ( M  m)
inline
template<typename M >
internal::MatcherAsPredicate<M> testing::Matches ( M  matcher)
inline
PolymorphicMatcher<internal::MatchesRegexMatcher> testing::MatchesRegex ( const internal::RE *  regex)
inline
PolymorphicMatcher<internal::MatchesRegexMatcher> testing::MatchesRegex ( const internal::string &  regex)
inline
internal::FloatingEqMatcher<double> testing::NanSensitiveDoubleEq ( double  rhs)
inline
internal::FloatingEqMatcher<float> testing::NanSensitiveFloatEq ( float  rhs)
inline
template<typename Rhs >
internal::NeMatcher<Rhs> testing::Ne ( Rhs  x)
inline
internal::Ne2Matcher testing::Ne ( )
inline
template<typename InnerMatcher >
internal::NotMatcher<InnerMatcher> testing::Not ( InnerMatcher  m)
inline
PolymorphicMatcher<internal::NotNullMatcher > testing::NotNull ( )
inline
std::ostream & testing::operator<< ( std::ostream &  os,
const TestPartResult &  result 
)
std::ostream& testing::operator<< ( std::ostream &  os,
const Message &  sb 
)
inline
template<typename FirstMatcher , typename SecondMatcher >
internal::PairMatcher<FirstMatcher, SecondMatcher> testing::Pair ( FirstMatcher  first_matcher,
SecondMatcher  second_matcher 
)
inline
template<typename InnerMatcher >
internal::PointeeMatcher<InnerMatcher> testing::Pointee ( const InnerMatcher &  inner_matcher)
inline
template<typename TupleMatcher , typename Container >
internal::PointwiseMatcher<TupleMatcher, GTEST_REMOVE_CONST_(Container)> testing::Pointwise ( const TupleMatcher &  tuple_matcher,
const Container &  rhs 
)
inline
static void testing::PrintTestPartResult ( const TestPartResult &  test_part_result)
static
static internal::String testing::PrintTestPartResultToString ( const TestPartResult &  test_part_result)
static
template<typename T >
::std::string testing::PrintToString ( const T &  value)
template<typename Class , typename PropertyType , typename PropertyMatcher >
PolymorphicMatcher< internal::PropertyMatcher<Class, PropertyType> > testing::Property ( PropertyType(Class::*)() const  property,
const PropertyMatcher &  matcher 
)
inline
template<typename T >
internal::RefMatcher<T&> testing::Ref ( T &  x)
inline
template<typename Callable , typename ResultOfMatcher >
internal::ResultOfMatcher<Callable> testing::ResultOf ( Callable  callable,
const ResultOfMatcher &  matcher 
)
template<typename R >
internal::ReturnAction<R> testing::Return ( R  value)
PolymorphicAction<internal::ReturnVoidAction> testing::Return ( )
inline
PolymorphicAction<internal::ReturnNullAction> testing::ReturnNull ( )
inline
template<typename R >
internal::ReturnRefAction<R> testing::ReturnRef ( R &  x)
inline
template<typename R >
internal::ReturnRefOfCopyAction<R> testing::ReturnRefOfCopy ( const R &  x)
inline
template<typename T , typename M >
Matcher<T> testing::SafeMatcherCast ( const M &  polymorphic_matcher)
inline
template<size_t N, typename T >
PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage<T>::value> > testing::SetArgPointee ( const T &  x)
template<size_t N>
PolymorphicAction< internal::SetArgumentPointeeAction<N, const char*, false> > testing::SetArgPointee ( const char *  p)
template<size_t N>
PolymorphicAction< internal::SetArgumentPointeeAction<N, const wchar_t*, false> > testing::SetArgPointee ( const wchar_t *  p)
template<size_t N, typename T >
PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage<T>::value> > testing::SetArgumentPointee ( const T &  x)
template<typename T >
PolymorphicAction<internal::SetErrnoAndReturnAction<T> > testing::SetErrnoAndReturn ( int  errval,
T  result 
)
PolymorphicMatcher<internal::StartsWithMatcher<internal::string> > testing::StartsWith ( const internal::string &  prefix)
inline
template<typename T1 , typename T2 >
bool testing::StaticAssertTypeEq ( )
PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > testing::StrCaseEq ( const internal::string &  str)
inline
PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > testing::StrCaseNe ( const internal::string &  str)
inline
PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > testing::StrEq ( const internal::string &  str)
inline
PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > testing::StrNe ( const internal::string &  str)
inline
static bool testing::TestPartFatallyFailed ( const TestPartResult &  result)
static
static bool testing::TestPartNonfatallyFailed ( const TestPartResult &  result)
static
static const char* testing::TestPartResultTypeToString ( TestPartResult::Type  type)
static
template<typename Predicate >
PolymorphicMatcher<internal::TrulyMatcher<Predicate> > testing::Truly ( Predicate  pred)
inline
template<typename Lhs , typename Rhs >
Matcher<Lhs> testing::TypedEq ( const Rhs &  rhs)
inline
template<typename T , typename M >
bool testing::Value ( const T &  value,
M  matcher 
)
inline
template<int k, typename InnerAction >
internal::WithArgsAction<InnerAction, k> testing::WithArg ( const InnerAction &  action)
inline
template<int k1, typename InnerAction >
internal::WithArgsAction<InnerAction, k1> testing::WithArgs ( const InnerAction &  action)
inline
template<int k1, int k2, typename InnerAction >
internal::WithArgsAction<InnerAction, k1, k2> testing::WithArgs ( const InnerAction &  action)
inline
template<int k1, int k2, int k3, typename InnerAction >
internal::WithArgsAction<InnerAction, k1, k2, k3> testing::WithArgs ( const InnerAction &  action)
inline
template<int k1, int k2, int k3, int k4, typename InnerAction >
internal::WithArgsAction<InnerAction, k1, k2, k3, k4> testing::WithArgs ( const InnerAction &  action)
inline
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
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
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
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
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
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
template<typename InnerAction >
internal::WithArgsAction<InnerAction> testing::WithoutArgs ( const InnerAction &  action)
inline

Variable Documentation

const internal::AnythingMatcher testing::_ = {}
class testing::InSequence testing::GTEST_ATTRIBUTE_UNUSED_
const char testing::kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"
static
const char testing::kDefaultDeathTestStyle[] = "fast"
static
const char testing::kDefaultOutputFile[] = "test_detail.xml"
static
const char testing::kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"
static
const int testing::kMaxStackTraceDepth = 100
const char testing::kTestShardIndex[] = "GTEST_SHARD_INDEX"
static
const char testing::kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"
static
const char testing::kTestTotalShards[] = "GTEST_TOTAL_SHARDS"
static
const char testing::kUniversalFilter[] = "*"
static
Generated on Fri Apr 12 2019 01:26:12 for Orxonox by   doxygen 1.8.11