gmock_link_test.h File Reference

#include "gmock/gmock.h"
#include <errno.h>
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h"
#include <iostream>
#include <vector>

Include dependency graph for gmock_link_test.h:

Go to the source code of this file.

Classes
class	Interface
class	Mock
class	InvokeHelper
class	FieldHelper
class	Matcher< T >

Functions
	TEST (LinkTest, TestReturnVoid)
	TEST (LinkTest, TestReturn)
	TEST (LinkTest, TestReturnNull)
	TEST (LinkTest, TestReturnRef)
	TEST (LinkTest, TestAssign)
	TEST (LinkTest, TestSetArgPointee)
	TEST (LinkTest, TestSetArrayArgument)
	TEST (LinkTest, TestSetErrnoAndReturn)
	TEST (LinkTest, TestInvoke)
	TEST (LinkTest, TestInvokeWithoutArgs)
	TEST (LinkTest, TestInvokeArgument)
	TEST (LinkTest, TestWithArg)
	TEST (LinkTest, TestWithArgs)
	TEST (LinkTest, TestWithoutArgs)
	TEST (LinkTest, TestDoAll)
	TEST (LinkTest, TestDoDefault)
	TEST (LinkTest, TestIgnoreResult)
	TEST (LinkTest, TestActionMacro)
	TEST (LinkTest, TestActionPMacro)
	TEST (LinkTest, TestActionP2Macro)
	TEST (LinkTest, TestMatcherAnything)
	TEST (LinkTest, TestMatcherA)
	TEST (LinkTest, TestMatchersEq)
	TEST (LinkTest, TestMatchersRelations)
	TEST (LinkTest, TestMatcherNotNull)
	TEST (LinkTest, TestMatcherIsNull)
	TEST (LinkTest, TestMatcherRef)
	TEST (LinkTest, TestMatcherTypedEq)
	TEST (LinkTest, TestMatchersFloatingPoint)
	TEST (LinkTest, TestMatcherContainsRegex)
	TEST (LinkTest, TestMatcherMatchesRegex)
	TEST (LinkTest, TestMatchersSubstrings)
	TEST (LinkTest, TestMatchersStringEquality)
	TEST (LinkTest, TestMatcherElementsAre)
	TEST (LinkTest, TestMatcherElementsAreArray)
	TEST (LinkTest, TestMatcherContainerEq)
	TEST (LinkTest, TestMatcherField)
	TEST (LinkTest, TestMatcherProperty)
	TEST (LinkTest, TestMatcherResultOf)
	TEST (LinkTest, TestMatcherPointee)
	TEST (LinkTest, TestMatcherTruly)
	TEST (LinkTest, TestMatcherAllOf)
	TEST (LinkTest, TestMatcherAnyOf)
	TEST (LinkTest, TestMatcherNot)
	TEST (LinkTest, TestMatcherCast)
template<typename T>
Matcher< T >	A ()
template<typename M1, typename M2>
internal::AllOfResult2< M1, M2 >::type	AllOf (M1 m1, M2 m2)
template<typename M1, typename M2>
internal::AnyOfResult2< M1, M2 >::type	AnyOf (M1 m1, M2 m2)
template<typename T1, typename T2>
PolymorphicAction< internal::AssignAction< T1, T2 > >	Assign (T1 *ptr, T2 val)
template<typename Container>
PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> >	ContainerEq (const Container &rhs)
template<typename Action1, typename Action2>
internal::DoBothAction< Action1, Action2 >	DoAll (Action1 a1, Action2 a2)
internal::DoDefaultAction	DoDefault ()
internal::FloatingEqMatcher< double >	DoubleEq (double rhs)
internal::ElementsAreMatcher< ::testing::tuple<> >	ElementsAre ()
template<typename Iter>
internal::ElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type >	ElementsAreArray (Iter first, Iter last)
PolymorphicMatcher< internal::EndsWithMatcher< internal::string > >	EndsWith (const internal::string &suffix)
template<typename T>
internal::EqMatcher< T >	Eq (T x)
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)
template<typename Rhs>
internal::GeMatcher< Rhs >	Ge (Rhs x)
template<typename Rhs>
internal::GtMatcher< Rhs >	Gt (Rhs x)
PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > >	HasSubstr (const internal::string &substring)
template<typename A>
internal::IgnoreResultAction< A >	IgnoreResult (const A &an_action)
template<typename FunctionImpl>
PolymorphicAction< internal::InvokeAction< FunctionImpl > >	Invoke (FunctionImpl function_impl)
template<typename FunctionImpl>
PolymorphicAction< internal::InvokeWithoutArgsAction< FunctionImpl > >	InvokeWithoutArgs (FunctionImpl function_impl)
PolymorphicMatcher< internal::IsNullMatcher >	IsNull ()
template<typename Rhs>
internal::LeMatcher< Rhs >	Le (Rhs x)
template<typename Rhs>
internal::LtMatcher< Rhs >	Lt (Rhs x)
template<typename T, typename M>
Matcher< T >	MatcherCast (const M &matcher)
internal::FloatingEqMatcher< double >	NanSensitiveDoubleEq (double rhs)
internal::FloatingEqMatcher< float >	NanSensitiveFloatEq (float rhs)
template<typename Rhs>
internal::NeMatcher< Rhs >	Ne (Rhs x)
template<typename InnerMatcher>
internal::NotMatcher< InnerMatcher >	Not (InnerMatcher m)
PolymorphicMatcher< internal::NotNullMatcher >	NotNull ()
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::ReturnNullAction >	ReturnNull ()
template<typename R>
internal::ReturnRefAction< R >	ReturnRef (R &x)
template<size_t N, typename T>
PolymorphicAction< internal::SetArgumentPointeeAction< N, T, internal::IsAProtocolMessage< T >::value > >	SetArgPointee (const T &x)
PolymorphicMatcher< internal::StartsWithMatcher< internal::string > >	StartsWith (const internal::string &prefix)
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)
template<typename Predicate>
PolymorphicMatcher< internal::TrulyMatcher< Predicate > >	Truly (Predicate pred)
template<typename Lhs, typename Rhs>
Matcher< Lhs >	TypedEq (const Rhs &rhs)
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<typename InnerAction>
internal::WithArgsAction< InnerAction >	WithoutArgs (const InnerAction &action)
template<typename T>
PolymorphicAction< internal::SetErrnoAndReturnAction< T > >	SetErrnoAndReturn (int errval, T result)
PolymorphicMatcher< internal::MatchesRegexMatcher >	ContainsRegex (const internal::RE *regex)
PolymorphicMatcher< internal::MatchesRegexMatcher >	MatchesRegex (const internal::RE *regex)

Variables
const internal::AnythingMatcher	_

Function Documentation

A()

template<typename T>

Matcher< T > testing::A ( )

inline

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

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

Here is the caller graph for this function:

AllOf()

template<typename M1, typename M2>

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

inline

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

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

Here is the caller graph for this function:

AnyOf()

template<typename M1, typename M2>

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

inline

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

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

Here is the caller graph for this function:

Assign()

template<typename T1, typename T2>

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

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

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

Here is the caller graph for this function:

ContainerEq()

template<typename Container>

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

inline

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

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

Here is the caller graph for this function:

ContainsRegex()

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

inline

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

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

Here is the caller graph for this function:

DoAll()

template<typename Action1, typename Action2>

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

inline

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

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

Here is the caller graph for this function:

DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

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

                                           {
  return internal::DoDefaultAction();
}

Here is the caller graph for this function:

DoubleEq()

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

inline

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

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

Here is the caller graph for this function:

ElementsAre()

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

inline

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

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

Here is the caller graph for this function:

ElementsAreArray()

template<typename Iter>

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

inline

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

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

Here is the caller graph for this function:

EndsWith()

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

inline

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

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

Here is the caller graph for this function:

Eq()

template<typename T>

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

inline

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

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

Here is the caller graph for this function:

Field()

template<typename Class, typename FieldType, typename FieldMatcher>

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

inline

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

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

Here is the caller graph for this function:

FloatEq()

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

inline

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

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

Here is the caller graph for this function:

Ge()

template<typename Rhs>

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

inline

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

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

Here is the caller graph for this function:

Gt()

template<typename Rhs>

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

inline

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

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

Here is the caller graph for this function:

HasSubstr()

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

inline

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

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

Here is the 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.

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

Here is the caller graph for this function:

Invoke()

template<typename FunctionImpl>

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

(

FunctionImpl

function_impl

)

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

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

Here is the caller graph for this function:

InvokeWithoutArgs()

template<typename FunctionImpl>

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

(

FunctionImpl

function_impl

)

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

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

Here is the caller graph for this function:

IsNull()

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

inline

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

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

Here is the caller graph for this function:

Le()

template<typename Rhs>

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

inline

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

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

Here is the caller graph for this function:

Lt()

template<typename Rhs>

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

inline

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

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

Here is the caller graph for this function:

MatcherCast()

template<typename T, typename M>

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

inline

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

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

Here is the caller graph for this function:

MatchesRegex()

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

inline

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

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

Here is the caller graph for this function:

NanSensitiveDoubleEq()

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

inline

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

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

Here is the caller graph for this function:

NanSensitiveFloatEq()

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

inline

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

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

Here is the caller graph for this function:

Ne()

template<typename Rhs>

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

inline

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

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

Here is the caller graph for this function:

Not()

template<typename InnerMatcher>

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

inline

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

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

Here is the caller graph for this function:

NotNull()

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

inline

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

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

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.

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

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.

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

Here is the caller graph for this function:

Return()

template<typename R>

internal::ReturnAction< R > testing::Return

(

R

value

)

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

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

Here is the caller graph for this function:

ReturnNull()

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

inline

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

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

ReturnRef()

template<typename R>

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

inline

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

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

Here is the caller graph for this function:

SetArgPointee()

template<size_t N, typename T>

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

(

const T &

x

)

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

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

Here is the caller graph for this function:

SetErrnoAndReturn()

template<typename T>

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

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

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

Here is the caller graph for this function:

StartsWith()

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

inline

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

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

Here is the caller graph for this function:

StrCaseEq()

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

inline

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

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

Here is the caller graph for this function:

StrCaseNe()

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

inline

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

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

Here is the caller graph for this function:

StrEq()

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

inline

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

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

Here is the caller graph for this function:

StrNe()

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

inline

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

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

Here is the caller graph for this function:

TEST() [1/45]

TEST	(	LinkTest	,
		TestActionMacro	)

Definition at line 431 of file gmock_link_test.h.

                                {
  Mock mock;
 
  EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
  mock.IntFromString(NULL);
}

Here is the call graph for this function:

TEST() [2/45]

TEST	(	LinkTest	,
		TestActionP2Macro	)

Definition at line 461 of file gmock_link_test.h.

                                  {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, IntFromString(_))
      .WillOnce(ReturnEqualsEitherOf("one", "two"));
  mock.IntFromString(&ch);
}

Here is the call graph for this function:

TEST() [3/45]

TEST	(	LinkTest	,
		TestActionPMacro	)

Definition at line 443 of file gmock_link_test.h.

                                 {
  Mock mock;
 
  EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
  mock.IntFromString(NULL);
}

Here is the call graph for this function:

TEST() [4/45]

TEST	(	LinkTest	,
		TestAssign	)

Definition at line 276 of file gmock_link_test.h.

                           {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [5/45]

TEST	(	LinkTest	,
		TestDoAll	)

Definition at line 379 of file gmock_link_test.h.

                          {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
  mock.VoidFromString(&ch);
}

Here is the call graph for this function:

TEST() [6/45]

TEST	(	LinkTest	,
		TestDoDefault	)

Definition at line 389 of file gmock_link_test.h.

                              {
  Mock mock;
  char ch = 'x';
 
  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
  mock.VoidFromString(&ch);
}

Here is the call graph for this function:

TEST() [7/45]

TEST	(	LinkTest	,
		TestIgnoreResult	)

Definition at line 399 of file gmock_link_test.h.

                                 {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [8/45]

TEST	(	LinkTest	,
		TestInvoke	)

Definition at line 319 of file gmock_link_test.h.

                           {
  Mock mock;
  InvokeHelper test_invoke_helper;
 
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
      .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
  mock.VoidFromString(NULL);
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [9/45]

TEST	(	LinkTest	,
		TestInvokeArgument	)

Definition at line 344 of file gmock_link_test.h.

                                   {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
  mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
}

Here is the call graph for this function:

TEST() [10/45]

TEST	(	LinkTest	,
		TestInvokeWithoutArgs	)

Definition at line 331 of file gmock_link_test.h.

                                      {
  Mock mock;
  InvokeHelper test_invoke_helper;
 
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
      .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
                                  &InvokeHelper::VoidFromVoid));
  mock.VoidFromString(NULL);
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [11/45]

TEST	(	LinkTest	,
		TestMatcherA	)

Definition at line 478 of file gmock_link_test.h.

                             {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [12/45]

TEST	(	LinkTest	,
		TestMatcherAllOf	)

Definition at line 646 of file gmock_link_test.h.

                                 {
  Matcher<int> m = AllOf(_, Eq(1));
  EXPECT_TRUE(m.Matches(1));
}

Here is the call graph for this function:

TEST() [13/45]

TEST	(	LinkTest	,
		TestMatcherAnyOf	)

Definition at line 652 of file gmock_link_test.h.

                                 {
  Matcher<int> m = AnyOf(_, Eq(1));
  EXPECT_TRUE(m.Matches(1));
}

Here is the call graph for this function:

TEST() [14/45]

TEST	(	LinkTest	,
		TestMatcherAnything	)

Definition at line 471 of file gmock_link_test.h.

                                    {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [15/45]

TEST	(	LinkTest	,
		TestMatcherCast	)

Definition at line 664 of file gmock_link_test.h.

                                {
  Matcher<const char*> m = MatcherCast<const char*>(_);
  EXPECT_TRUE(m.Matches(NULL));
}

Here is the call graph for this function:

TEST() [16/45]

TEST	(	LinkTest	,
		TestMatcherContainerEq	)

Definition at line 596 of file gmock_link_test.h.

                                       {
  Mock mock;
  std::vector<int> v;
 
  ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [17/45]

TEST	(	LinkTest	,
		TestMatcherContainsRegex	)

Definition at line 549 of file gmock_link_test.h.

                                         {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [18/45]

TEST	(	LinkTest	,
		TestMatcherElementsAre	)

Definition at line 581 of file gmock_link_test.h.

                                       {
  Mock mock;
 
  ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [19/45]

TEST	(	LinkTest	,
		TestMatcherElementsAreArray	)

Definition at line 588 of file gmock_link_test.h.

                                            {
  Mock mock;
  char arr[] = { 'a', 'b' };
 
  ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [20/45]

TEST	(	LinkTest	,
		TestMatcherField	)

Definition at line 604 of file gmock_link_test.h.

                                 {
  FieldHelper helper(0);
 
  Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
  EXPECT_TRUE(m.Matches(helper));
 
  Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
  EXPECT_TRUE(m2.Matches(&helper));
}

Here is the call graph for this function:

TEST() [21/45]

TEST	(	LinkTest	,
		TestMatcherIsNull	)

Definition at line 513 of file gmock_link_test.h.

                                  {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [22/45]

TEST	(	LinkTest	,
		TestMatcherMatchesRegex	)

Definition at line 556 of file gmock_link_test.h.

                                        {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [23/45]

TEST	(	LinkTest	,
		TestMatcherNot	)

Definition at line 658 of file gmock_link_test.h.

                               {
  Matcher<int> m = Not(_);
  EXPECT_FALSE(m.Matches(1));
}

Here is the call graph for this function:

TEST() [24/45]

TEST	(	LinkTest	,
		TestMatcherNotNull	)

Definition at line 506 of file gmock_link_test.h.

                                   {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [25/45]

TEST	(	LinkTest	,
		TestMatcherPointee	)

Definition at line 632 of file gmock_link_test.h.

                                   {
  int n = 1;
 
  Matcher<int*> m = Pointee(Eq(1));
  EXPECT_TRUE(m.Matches(&n));
}

Here is the call graph for this function:

TEST() [26/45]

TEST	(	LinkTest	,
		TestMatcherProperty	)

Definition at line 615 of file gmock_link_test.h.

                                    {
  FieldHelper helper(0);
 
  Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
  EXPECT_TRUE(m.Matches(helper));
 
  Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
  EXPECT_TRUE(m2.Matches(&helper));
}

Here is the call graph for this function:

TEST() [27/45]

TEST	(	LinkTest	,
		TestMatcherRef	)

Definition at line 520 of file gmock_link_test.h.

                               {
  Mock mock;
  int a = 0;
 
  ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [28/45]

TEST	(	LinkTest	,
		TestMatcherResultOf	)

Definition at line 626 of file gmock_link_test.h.

                                    {
  Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
  EXPECT_TRUE(m.Matches(NULL));
}

Here is the call graph for this function:

TEST() [29/45]

TEST	(	LinkTest	,
		TestMatchersEq	)

Definition at line 485 of file gmock_link_test.h.

                               {
  Mock mock;
  const char* p = "x";
 
  ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
      .WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [30/45]

TEST	(	LinkTest	,
		TestMatchersFloatingPoint	)

Definition at line 537 of file gmock_link_test.h.

                                          {
  Mock mock;
  float a = 0;
 
  ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
      .WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [31/45]

TEST	(	LinkTest	,
		TestMatchersRelations	)

Definition at line 495 of file gmock_link_test.h.

                                      {
  Mock mock;
 
  ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [32/45]

TEST	(	LinkTest	,
		TestMatchersStringEquality	)

Definition at line 572 of file gmock_link_test.h.

                                           {
  Mock mock;
  ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [33/45]

TEST	(	LinkTest	,
		TestMatchersSubstrings	)

Definition at line 563 of file gmock_link_test.h.

                                       {
  Mock mock;
 
  ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [34/45]

TEST	(	LinkTest	,
		TestMatcherTruly	)

Definition at line 640 of file gmock_link_test.h.

                                 {
  Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
  EXPECT_TRUE(m.Matches(NULL));
}

Here is the call graph for this function:

TEST() [35/45]

TEST	(	LinkTest	,
		TestMatcherTypedEq	)

Definition at line 528 of file gmock_link_test.h.

                                   {
  Mock mock;
  long a = 0;
 
  ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
}

Here is the call graph for this function:

TEST() [36/45]

TEST	(	LinkTest	,
		TestReturn	)

Definition at line 250 of file gmock_link_test.h.

                           {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
  mock.StringFromString(NULL);
}

Here is the call graph for this function:

TEST() [37/45]

TEST	(	LinkTest	,
		TestReturnNull	)

Definition at line 259 of file gmock_link_test.h.

                               {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [38/45]

TEST	(	LinkTest	,
		TestReturnRef	)

Definition at line 267 of file gmock_link_test.h.

                              {
  Mock mock;
  int n = 42;
 
  EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
  mock.IntRefFromString(NULL);
}

Here is the call graph for this function:

TEST() [39/45]

TEST	(	LinkTest	,
		TestReturnVoid	)

Definition at line 242 of file gmock_link_test.h.

                               {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [40/45]

TEST	(	LinkTest	,
		TestSetArgPointee	)

Definition at line 285 of file gmock_link_test.h.

                                  {
  Mock mock;
  char ch = 'x';
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
  mock.VoidFromString(&ch);
}

Here is the call graph for this function:

TEST() [41/45]

TEST	(	LinkTest	,
		TestSetArrayArgument	)

Definition at line 294 of file gmock_link_test.h.

                                     {
  Mock mock;
  char ch = 'x';
  char ch2 = 'y';
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
                                                                    &ch2 + 1));
  mock.VoidFromString(&ch);
}

Here is the call graph for this function:

TEST() [42/45]

TEST	(	LinkTest	,
		TestSetErrnoAndReturn	)

Definition at line 307 of file gmock_link_test.h.

                                      {
  Mock mock;
 
  int saved_errno = errno;
  EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
  mock.IntFromString(NULL);
  errno = saved_errno;
}

Here is the call graph for this function:

TEST() [43/45]

TEST	(	LinkTest	,
		TestWithArg	)

Definition at line 353 of file gmock_link_test.h.

                            {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [44/45]

TEST	(	LinkTest	,
		TestWithArgs	)

Definition at line 362 of file gmock_link_test.h.

                             {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

TEST() [45/45]

TEST	(	LinkTest	,
		TestWithoutArgs	)

Definition at line 371 of file gmock_link_test.h.

                                {
  Mock mock;
 
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
  mock.VoidFromString(NULL);
}

Here is the call graph for this function:

Truly()

template<typename Predicate>

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

inline

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

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

Here is the 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.

{ return Eq(rhs); }

Here is the caller graph for this function:

WithArg()

template<int k, typename InnerAction>

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

inline

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

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

Here is the caller graph for this function:

WithArgs()

template<int k1, typename InnerAction>

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

inline

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

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

Here is the caller graph for this function:

WithoutArgs()

template<typename InnerAction>

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

inline

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

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

Here is the caller graph for this function:

Variable Documentation

_

const internal::AnythingMatcher testing::_

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

{};