testing::gmock_more_actions_test Namespace Reference

Classes
class	DeletionTester
class	Foo
class	NullaryFunctor
struct	SumOf5Functor
struct	SumOf6Functor
struct	UnaryFunctor
class	VoidNullaryFunctor

Functions
short	Short (short n)
char	Char (char ch)
int	Nullary ()
void	VoidNullary ()
bool	Unary (int x)
const char *	Plus1 (const char *s)
void	VoidUnary (int)
bool	ByConstRef (const string &s)
bool	ReferencesGlobalDouble (const double &x)
string	ByNonConstRef (string &s)
const char *	Binary (const char *input, short n)
void	VoidBinary (int, char)
int	Ternary (int x, char y, short z)
void	VoidTernary (int, char, bool)
int	SumOf4 (int a, int b, int c, int d)
int	SumOfFirst2 (int a, int b, Unused, Unused)
void	VoidFunctionWithFourArguments (char, int, float, double)
string	Concat4 (const char *s1, const char *s2, const char *s3, const char *s4)
int	SumOf5 (int a, int b, int c, int d, int e)
string	Concat5 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5)
int	SumOf6 (int a, int b, int c, int d, int e, int f)
string	Concat6 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6)
string	Concat7 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7)
string	Concat8 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8)
string	Concat9 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8, const char *s9)
string	Concat10 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8, const char *s9, const char *s10)
	TEST (InvokeTest, Nullary)
	TEST (InvokeTest, Unary)
	TEST (InvokeTest, Binary)
	TEST (InvokeTest, Ternary)
	TEST (InvokeTest, FunctionThatTakes4Arguments)
	TEST (InvokeTest, FunctionThatTakes5Arguments)
	TEST (InvokeTest, FunctionThatTakes6Arguments)
const char *	CharPtr (const char *s)
	TEST (InvokeTest, FunctionThatTakes7Arguments)
	TEST (InvokeTest, FunctionThatTakes8Arguments)
	TEST (InvokeTest, FunctionThatTakes9Arguments)
	TEST (InvokeTest, FunctionThatTakes10Arguments)
	TEST (InvokeTest, FunctionWithUnusedParameters)
	TEST (InvokeTest, MethodWithUnusedParameters)
	TEST (InvokeTest, Functor)
	TEST (InvokeTest, FunctionWithCompatibleType)
	TEST (InvokeMethodTest, Nullary)
	TEST (InvokeMethodTest, Unary)
	TEST (InvokeMethodTest, Binary)
	TEST (InvokeMethodTest, Ternary)
	TEST (InvokeMethodTest, MethodThatTakes4Arguments)
	TEST (InvokeMethodTest, MethodThatTakes5Arguments)
	TEST (InvokeMethodTest, MethodThatTakes6Arguments)
	TEST (InvokeMethodTest, MethodThatTakes7Arguments)
	TEST (InvokeMethodTest, MethodThatTakes8Arguments)
	TEST (InvokeMethodTest, MethodThatTakes9Arguments)
	TEST (InvokeMethodTest, MethodThatTakes10Arguments)
	TEST (InvokeMethodTest, MethodWithCompatibleType)
	TEST (WithoutArgsTest, NoArg)
	TEST (WithArgTest, OneArg)
	TEST (ReturnArgActionTest, WorksForOneArgIntArg0)
	TEST (ReturnArgActionTest, WorksForMultiArgBoolArg0)
	TEST (ReturnArgActionTest, WorksForMultiArgStringArg2)
	TEST (SaveArgActionTest, WorksForSameType)
	TEST (SaveArgActionTest, WorksForCompatibleType)
	TEST (SaveArgPointeeActionTest, WorksForSameType)
	TEST (SaveArgPointeeActionTest, WorksForCompatibleType)
	TEST (SaveArgPointeeActionTest, WorksForLinkedPtr)
	TEST (SetArgRefereeActionTest, WorksForSameType)
	TEST (SetArgRefereeActionTest, WorksForCompatibleType)
	TEST (SetArgRefereeActionTest, WorksWithExtraArguments)
	TEST (DeleteArgActionTest, OneArg)
	TEST (DeleteArgActionTest, TenArgs)
	TEST (SetArrayArgumentTest, SetsTheNthArray)
	TEST (SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange)
	TEST (SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType)
	TEST (SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument)
	TEST (ReturnPointeeTest, Works)

Variables
bool	g_done = false
const double	g_double = 0

Function Documentation

const char * testing::gmock_more_actions_test::Binary	(	const char *	input,
		short	n
	)

Definition at line 108 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::UnaryFunctor::operator()(), and TEST().

{ return input + n; }  // NOLINT

bool testing::gmock_more_actions_test::ByConstRef

(

const string &

s

)

Definition at line 97 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()().

{ return s == "Hi"; }

string testing::gmock_more_actions_test::ByNonConstRef

(

string &

s

)

Definition at line 102 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()().

{ return s += "+"; }  // NOLINT

char testing::gmock_more_actions_test::Char ( char  ch )

inline

Definition at line 73 of file gmock-more-actions_test.cc.

References ch.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), and TEST().

{ return ch; }

const char * testing::gmock_more_actions_test::CharPtr ( const char *  s )

inline

Definition at line 279 of file gmock-more-actions_test.cc.

References s.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), TEST(), and testing::gmock_more_actions_test::DeletionTester::~DeletionTester().

{ return s; }

string testing::gmock_more_actions_test::Concat10	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5,
		const char *	s6,
		const char *	s7,
		const char *	s8,
		const char *	s9,
		const char *	s10
	)

Definition at line 173 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::SumOf6Functor::operator()(), and TEST().

                                 {
  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
}

string testing::gmock_more_actions_test::Concat4	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4
	)

Definition at line 122 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::UnaryFunctor::operator()().

                               {
  return string(s1) + s2 + s3 + s4;
}

string testing::gmock_more_actions_test::Concat5	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5
	)

Definition at line 135 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::SumOf5Functor::operator()().

                                               {
  return string(s1) + s2 + s3 + s4 + s5;
}

string testing::gmock_more_actions_test::Concat6	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5,
		const char *	s6
	)

Definition at line 150 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::SumOf6Functor::operator()().

                                                               {
  return string(s1) + s2 + s3 + s4 + s5 + s6;
}

string testing::gmock_more_actions_test::Concat7	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5,
		const char *	s6,
		const char *	s7
	)

Definition at line 155 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::SumOf6Functor::operator()(), and TEST().

                               {
  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
}

string testing::gmock_more_actions_test::Concat8	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5,
		const char *	s6,
		const char *	s7,
		const char *	s8
	)

Definition at line 161 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::SumOf6Functor::operator()(), and TEST().

                                               {
  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
}

string testing::gmock_more_actions_test::Concat9	(	const char *	s1,
		const char *	s2,
		const char *	s3,
		const char *	s4,
		const char *	s5,
		const char *	s6,
		const char *	s7,
		const char *	s8,
		const char *	s9
	)

Definition at line 167 of file gmock-more-actions_test.cc.

References string.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::SumOf6Functor::operator()(), and TEST().

                                                               {
  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
}

int testing::gmock_more_actions_test::Nullary

(

)

Definition at line 76 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), and TEST().

{ return 1; }

const char * testing::gmock_more_actions_test::Plus1

(

const char *

s

)

Definition at line 93 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()().

{ return s + 1; }

bool testing::gmock_more_actions_test::ReferencesGlobalDouble

(

const double &

x

)

Definition at line 100 of file gmock-more-actions_test.cc.

References g_double.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()().

{ return &x == &g_double; }

short testing::gmock_more_actions_test::Short ( short  n )

inline

Definition at line 72 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), and TEST().

{ return n; }  // NOLINT

int testing::gmock_more_actions_test::SumOf4	(	int	a,
		int	b,
		int	c,
		int	d
	)

Definition at line 116 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::UnaryFunctor::operator()(), and TEST().

{ return a + b + c + d; }

int testing::gmock_more_actions_test::SumOf5	(	int	a,
		int	b,
		int	c,
		int	d,
		int	e
	)

Definition at line 127 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::UnaryFunctor::operator()(), and TEST().

{ return a + b + c + d + e; }

int testing::gmock_more_actions_test::SumOf6	(	int	a,
		int	b,
		int	c,
		int	d,
		int	e,
		int	f
	)

Definition at line 140 of file gmock-more-actions_test.cc.

References f.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::SumOf5Functor::operator()(), and TEST().

                                                     {
  return a + b + c + d + e + f;
}

int testing::gmock_more_actions_test::SumOfFirst2	(	int	a,
		int	b,
		Unused	,
		Unused
	)

Definition at line 118 of file gmock-more-actions_test.cc.

References b.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::UnaryFunctor::operator()(), and TEST().

{ return a + b; }

int testing::gmock_more_actions_test::Ternary	(	int	x,
		char	y,
		short	z
	)

Definition at line 112 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::UnaryFunctor::operator()(), and TEST().

{ return x + y + z; }  // NOLINT

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		Nullary
	)

Definition at line 234 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), Nullary(), and testing::Action< F >::Perform().

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), TEST(), and testing::gmock_more_actions_test::DeletionTester::~DeletionTester().

                          {
  Action<int()> a = Invoke(Nullary);  // NOLINT
  EXPECT_EQ(1, a.Perform(make_tuple()));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		Unary
	)

Definition at line 240 of file gmock-more-actions_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and Unary().

                        {
  Action<bool(int)> a = Invoke(Unary);  // NOLINT
  EXPECT_FALSE(a.Perform(make_tuple(1)));
  EXPECT_TRUE(a.Perform(make_tuple(-1)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		Binary
	)

Definition at line 247 of file gmock-more-actions_test.cc.

References a, Binary(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and Short().

                         {
  Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
  const char* p = "Hello";
  EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		Ternary
	)

Definition at line 254 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), Short(), and Ternary().

                          {
  Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
  EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes4Arguments
	)

Definition at line 260 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and SumOf4().

                                              {
  Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
  EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes5Arguments
	)

Definition at line 266 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and SumOf5().

                                              {
  Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes6Arguments
	)

Definition at line 272 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and SumOf6().

                                              {
  Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes7Arguments
	)

Definition at line 282 of file gmock-more-actions_test.cc.

References a, CharPtr(), Concat7(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                              {
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*)> a =
      Invoke(Concat7);
  EXPECT_EQ("1234567",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes8Arguments
	)

Definition at line 293 of file gmock-more-actions_test.cc.

References a, CharPtr(), Concat8(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                              {
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*)> a =
      Invoke(Concat8);
  EXPECT_EQ("12345678",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes9Arguments
	)

Definition at line 304 of file gmock-more-actions_test.cc.

References a, CharPtr(), Concat9(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                              {
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*,
                const char*)> a = Invoke(Concat9);
  EXPECT_EQ("123456789",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionThatTakes10Arguments
	)

Definition at line 315 of file gmock-more-actions_test.cc.

References a, CharPtr(), Concat10(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                               {
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*,
                const char*, const char*)> a = Invoke(Concat10);
  EXPECT_EQ("1234567890",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
                                 CharPtr("0"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionWithUnusedParameters
	)

Definition at line 327 of file gmock-more-actions_test.cc.

References EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), s, and SumOfFirst2().

                                               {
  Action<int(int, int, double, const string&)> a1 =
      Invoke(SumOfFirst2);
  string s("hi");
  EXPECT_EQ(12, a1.Perform(
    tuple<int, int, double, const string&>(10, 2, 5.6, s)));

  Action<int(int, int, bool, int*)> a2 =
      Invoke(SumOfFirst2);
  EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		MethodWithUnusedParameters
	)

Definition at line 340 of file gmock-more-actions_test.cc.

References CharPtr(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::SumOfLast2().

                                             {
  Foo foo;
  Action<int(string, bool, int, int)> a1 =
      Invoke(&foo, &Foo::SumOfLast2);
  EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));

  Action<int(char, double, int, int)> a2 =
      Invoke(&foo, &Foo::SumOfLast2);
  EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		Functor
	)

Definition at line 352 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), and testing::Action< F >::Perform().

                          {
  Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
  EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
}

testing::gmock_more_actions_test::TEST	(	InvokeTest	,
		FunctionWithCompatibleType
	)

Definition at line 358 of file gmock-more-actions_test.cc.

References a, Char(), EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), Short(), and SumOf4().

                                             {
  Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
  EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		Nullary
	)

Definition at line 366 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::gmock_more_actions_test::Foo::Nullary(), and testing::Action< F >::Perform().

                                {
  Foo foo;
  Action<int()> a = Invoke(&foo, &Foo::Nullary);  // NOLINT
  EXPECT_EQ(123, a.Perform(make_tuple()));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		Unary
	)

Definition at line 373 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::Unary().

                              {
  Foo foo;
  Action<short(long)> a = Invoke(&foo, &Foo::Unary);  // NOLINT
  EXPECT_EQ(4123, a.Perform(make_tuple(4000)));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		Binary
	)

Definition at line 380 of file gmock-more-actions_test.cc.

References a, testing::gmock_more_actions_test::Foo::Binary(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), testing::Action< F >::Perform(), and s.

                               {
  Foo foo;
  Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary);
  string s("Hell");
  EXPECT_EQ("Hello", a.Perform(
      tuple<const string&, char>(s, 'o')));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		Ternary
	)

Definition at line 389 of file gmock-more-actions_test.cc.

References a, Char(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::Ternary().

                                {
  Foo foo;
  Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary);  // NOLINT
  EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes4Arguments
	)

Definition at line 396 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::SumOf4().

                                                  {
  Foo foo;
  Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4);  // NOLINT
  EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4)));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes5Arguments
	)

Definition at line 403 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::SumOf5().

                                                  {
  Foo foo;
  Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5);  // NOLINT
  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes6Arguments
	)

Definition at line 410 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::gmock_more_actions_test::Foo::SumOf6().

                                                  {
  Foo foo;
  Action<int(int, int, int, int, int, int)> a =  // NOLINT
      Invoke(&foo, &Foo::SumOf6);
  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes7Arguments
	)

Definition at line 418 of file gmock-more-actions_test.cc.

References a, CharPtr(), testing::gmock_more_actions_test::Foo::Concat7(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                                  {
  Foo foo;
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*)> a =
      Invoke(&foo, &Foo::Concat7);
  EXPECT_EQ("1234567",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes8Arguments
	)

Definition at line 430 of file gmock-more-actions_test.cc.

References a, CharPtr(), testing::gmock_more_actions_test::Foo::Concat8(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                                  {
  Foo foo;
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*)> a =
      Invoke(&foo, &Foo::Concat8);
  EXPECT_EQ("12345678",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes9Arguments
	)

Definition at line 442 of file gmock-more-actions_test.cc.

References a, CharPtr(), testing::gmock_more_actions_test::Foo::Concat9(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                                  {
  Foo foo;
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*,
                const char*)> a = Invoke(&foo, &Foo::Concat9);
  EXPECT_EQ("123456789",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodThatTakes10Arguments
	)

Definition at line 454 of file gmock-more-actions_test.cc.

References a, CharPtr(), testing::gmock_more_actions_test::Foo::Concat10(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and string.

                                                   {
  Foo foo;
  Action<string(const char*, const char*, const char*, const char*,
                const char*, const char*, const char*, const char*,
                const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
  EXPECT_EQ("1234567890",
            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
                                 CharPtr("0"))));
}

testing::gmock_more_actions_test::TEST	(	InvokeMethodTest	,
		MethodWithCompatibleType
	)

Definition at line 467 of file gmock-more-actions_test.cc.

References a, Char(), EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), Short(), and testing::gmock_more_actions_test::Foo::SumOf4().

                                                 {
  Foo foo;
  Action<long(int, short, char, bool)> a =  // NOLINT
      Invoke(&foo, &Foo::SumOf4);
  EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
}

testing::gmock_more_actions_test::TEST	(	WithoutArgsTest	,
		NoArg
	)

Definition at line 475 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, testing::Invoke(), std::tr1::make_tuple(), Nullary(), testing::Action< F >::Perform(), and testing::WithoutArgs().

                             {
  Action<int(int n)> a = WithoutArgs(Invoke(Nullary));  // NOLINT
  EXPECT_EQ(1, a.Perform(make_tuple(2)));
}

testing::gmock_more_actions_test::TEST	(	WithArgTest	,
		OneArg
	)

Definition at line 481 of file gmock-more-actions_test.cc.

References b, EXPECT_FALSE, EXPECT_TRUE, testing::Invoke(), std::tr1::make_tuple(), testing::Action< F >::Perform(), and Unary().

                          {
  Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
  EXPECT_TRUE(b.Perform(make_tuple(1.5, -1)));
  EXPECT_FALSE(b.Perform(make_tuple(1.5, 1)));
}

testing::gmock_more_actions_test::TEST	(	ReturnArgActionTest	,
		WorksForOneArgIntArg0
	)

Definition at line 487 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                                                 {
  const Action<int(int)> a = ReturnArg<0>();
  EXPECT_EQ(5, a.Perform(make_tuple(5)));
}

testing::gmock_more_actions_test::TEST	(	ReturnArgActionTest	,
		WorksForMultiArgBoolArg0
	)

Definition at line 492 of file gmock-more-actions_test.cc.

References a, EXPECT_TRUE, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                                                    {
  const Action<bool(bool, bool, bool)> a = ReturnArg<0>();
  EXPECT_TRUE(a.Perform(make_tuple(true, false, false)));
}

testing::gmock_more_actions_test::TEST	(	ReturnArgActionTest	,
		WorksForMultiArgStringArg2
	)

Definition at line 497 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                                                      {
  const Action<string(int, int, string, int)> a = ReturnArg<2>();
  EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8)));
}

testing::gmock_more_actions_test::TEST	(	SaveArgActionTest	,
		WorksForSameType
	)

Definition at line 502 of file gmock-more-actions_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                                          {
  int result = 0;
  const Action<void(int n)> a1 = SaveArg<0>(&result);
  a1.Perform(make_tuple(5));
  EXPECT_EQ(5, result);
}

testing::gmock_more_actions_test::TEST	(	SaveArgActionTest	,
		WorksForCompatibleType
	)

Definition at line 509 of file gmock-more-actions_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                                                {
  int result = 0;
  const Action<void(bool, char)> a1 = SaveArg<1>(&result);
  a1.Perform(make_tuple(true, 'a'));
  EXPECT_EQ('a', result);
}

testing::gmock_more_actions_test::TEST	(	SaveArgPointeeActionTest	,
		WorksForSameType
	)

Definition at line 516 of file gmock-more-actions_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), testing::Action< F >::Perform(), and value.

                                                 {
  int result = 0;
  const int value = 5;
  const Action<void(const int*)> a1 = SaveArgPointee<0>(&result);
  a1.Perform(make_tuple(&value));
  EXPECT_EQ(5, result);
}

testing::gmock_more_actions_test::TEST	(	SaveArgPointeeActionTest	,
		WorksForCompatibleType
	)

Definition at line 524 of file gmock-more-actions_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), testing::Action< F >::Perform(), and value.

                                                       {
  int result = 0;
  char value = 'a';
  const Action<void(bool, char*)> a1 = SaveArgPointee<1>(&result);
  a1.Perform(make_tuple(true, &value));
  EXPECT_EQ('a', result);
}

testing::gmock_more_actions_test::TEST	(	SaveArgPointeeActionTest	,
		WorksForLinkedPtr
	)

Definition at line 532 of file gmock-more-actions_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), testing::Action< F >::Perform(), and value.

                                                  {
  int result = 0;
  linked_ptr<int> value(new int(5));
  const Action<void(linked_ptr<int>)> a1 = SaveArgPointee<0>(&result);
  a1.Perform(make_tuple(value));
  EXPECT_EQ(5, result);
}

testing::gmock_more_actions_test::TEST	(	SetArgRefereeActionTest	,
		WorksForSameType
	)

Definition at line 540 of file gmock-more-actions_test.cc.

References EXPECT_EQ, testing::Action< F >::Perform(), and value.

                                                {
  int value = 0;
  const Action<void(int&)> a1 = SetArgReferee<0>(1);
  a1.Perform(tuple<int&>(value));
  EXPECT_EQ(1, value);
}

testing::gmock_more_actions_test::TEST	(	SetArgRefereeActionTest	,
		WorksForCompatibleType
	)

Definition at line 547 of file gmock-more-actions_test.cc.

References EXPECT_EQ, testing::Action< F >::Perform(), and value.

                                                      {
  int value = 0;
  const Action<void(int, int&)> a1 = SetArgReferee<1>('a');
  a1.Perform(tuple<int, int&>(0, value));
  EXPECT_EQ('a', value);
}

testing::gmock_more_actions_test::TEST	(	SetArgRefereeActionTest	,
		WorksWithExtraArguments
	)

Definition at line 554 of file gmock-more-actions_test.cc.

References EXPECT_EQ, testing::Action< F >::Perform(), and value.

                                                       {
  int value = 0;
  const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a');
  a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi"));
  EXPECT_EQ('a', value);
}

testing::gmock_more_actions_test::TEST	(	DeleteArgActionTest	,
		OneArg
	)

Definition at line 579 of file gmock-more-actions_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, std::tr1::make_tuple(), testing::Action< F >::Perform(), and folly::pushmi::detail::t.

                                  {
  bool is_deleted = false;
  DeletionTester* t = new DeletionTester(&is_deleted);
  const Action<void(DeletionTester*)> a1 = DeleteArg<0>();      // NOLINT
  EXPECT_FALSE(is_deleted);
  a1.Perform(make_tuple(t));
  EXPECT_TRUE(is_deleted);
}

testing::gmock_more_actions_test::TEST	(	DeleteArgActionTest	,
		TenArgs
	)

Definition at line 588 of file gmock-more-actions_test.cc.

References a, CharPtr(), EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, std::tr1::make_tuple(), testing::Action< F >::Perform(), folly::pushmi::detail::t, and TEST().

                                   {
  bool is_deleted = false;
  DeletionTester* t = new DeletionTester(&is_deleted);
  const Action<void(bool, int, int, const char*, bool,
                    int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
  EXPECT_FALSE(is_deleted);
  a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
  EXPECT_TRUE(is_deleted);
}

testing::gmock_more_actions_test::TEST	(	SetArrayArgumentTest	,
		SetsTheNthArray
	)

Definition at line 621 of file gmock-more-actions_test.cc.

References a, ch, EXPECT_EQ, std::tr1::make_tuple(), testing::gtest_printers_test::MyFunction(), testing::Action< F >::Perform(), and string.

                                            {
  typedef void MyFunction(bool, int*, char*);
  int numbers[] = { 1, 2, 3 };
  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);

  int n[4] = {};
  int* pn = n;
  char ch[4] = {};
  char* pch = ch;
  a.Perform(make_tuple(true, pn, pch));
  EXPECT_EQ(1, n[0]);
  EXPECT_EQ(2, n[1]);
  EXPECT_EQ(3, n[2]);
  EXPECT_EQ(0, n[3]);
  EXPECT_EQ('\0', ch[0]);
  EXPECT_EQ('\0', ch[1]);
  EXPECT_EQ('\0', ch[2]);
  EXPECT_EQ('\0', ch[3]);

  // Tests first and last are iterators.
  std::string letters = "abc";
  a = SetArrayArgument<2>(letters.begin(), letters.end());
  std::fill_n(n, 4, 0);
  std::fill_n(ch, 4, '\0');
  a.Perform(make_tuple(true, pn, pch));
  EXPECT_EQ(0, n[0]);
  EXPECT_EQ(0, n[1]);
  EXPECT_EQ(0, n[2]);
  EXPECT_EQ(0, n[3]);
  EXPECT_EQ('a', ch[0]);
  EXPECT_EQ('b', ch[1]);
  EXPECT_EQ('c', ch[2]);
  EXPECT_EQ('\0', ch[3]);
}

testing::gmock_more_actions_test::TEST	(	SetArrayArgumentTest	,
		SetsTheNthArrayWithEmptyRange
	)

Definition at line 657 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), testing::gtest_printers_test::MyFunction(), and testing::Action< F >::Perform().

                                                          {
  typedef void MyFunction(bool, int*);
  int numbers[] = { 1, 2, 3 };
  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);

  int n[4] = {};
  int* pn = n;
  a.Perform(make_tuple(true, pn));
  EXPECT_EQ(0, n[0]);
  EXPECT_EQ(0, n[1]);
  EXPECT_EQ(0, n[2]);
  EXPECT_EQ(0, n[3]);
}

testing::gmock_more_actions_test::TEST	(	SetArrayArgumentTest	,
		SetsTheNthArrayWithConvertibleType
	)

Definition at line 673 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), testing::gtest_printers_test::MyFunction(), and testing::Action< F >::Perform().

                                                               {
  typedef void MyFunction(bool, int*);
  char chars[] = { 97, 98, 99 };
  Action<MyFunction> a = SetArrayArgument<1>(chars, chars + 3);

  int codes[4] = { 111, 222, 333, 444 };
  int* pcodes = codes;
  a.Perform(make_tuple(true, pcodes));
  EXPECT_EQ(97, codes[0]);
  EXPECT_EQ(98, codes[1]);
  EXPECT_EQ(99, codes[2]);
  EXPECT_EQ(444, codes[3]);
}

testing::gmock_more_actions_test::TEST	(	SetArrayArgumentTest	,
		SetsTheNthArrayWithIteratorArgument
	)

Definition at line 688 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), testing::gtest_printers_test::MyFunction(), testing::Action< F >::Perform(), s, and string.

                                                                {
  typedef void MyFunction(bool, std::back_insert_iterator<std::string>);
  std::string letters = "abc";
  Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());

  std::string s;
  a.Perform(make_tuple(true, back_inserter(s)));
  EXPECT_EQ(letters, s);
}

testing::gmock_more_actions_test::TEST	(	ReturnPointeeTest	,
		Works
	)

Definition at line 698 of file gmock-more-actions_test.cc.

References a, EXPECT_EQ, std::tr1::make_tuple(), and testing::Action< F >::Perform().

                               {
  int n = 42;
  const Action<int()> a = ReturnPointee(&n);
  EXPECT_EQ(42, a.Perform(make_tuple()));

  n = 43;
  EXPECT_EQ(43, a.Perform(make_tuple()));
}

bool testing::gmock_more_actions_test::Unary

(

int

x

)

Definition at line 91 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::Foo::Concat10(), testing::gmock_more_actions_test::VoidNullaryFunctor::operator()(), and TEST().

{ return x < 0; }

void testing::gmock_more_actions_test::VoidBinary	(	int	,
		char
	)

Definition at line 110 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::UnaryFunctor::operator()().

{ g_done = true; }

void testing::gmock_more_actions_test::VoidFunctionWithFourArguments	(	char	,
		int	,
		float	,
		double
	)

Definition at line 120 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::UnaryFunctor::operator()().

{ g_done = true; }

void testing::gmock_more_actions_test::VoidNullary

(

)

Definition at line 84 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::NullaryFunctor::operator()().

{ g_done = true; }

void testing::gmock_more_actions_test::VoidTernary	(	int	,
		char	,
		bool
	)

Definition at line 114 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::UnaryFunctor::operator()().

{ g_done = true; }

void testing::gmock_more_actions_test::VoidUnary

(

int

)

Definition at line 95 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()().

{ g_done = true; }

Variable Documentation

bool testing::gmock_more_actions_test::g_done = false

Definition at line 83 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::NullaryFunctor::operator()().

const double testing::gmock_more_actions_test::g_double = 0

Definition at line 99 of file gmock-more-actions_test.cc.

Referenced by testing::gmock_more_actions_test::VoidNullaryFunctor::operator()(), and ReferencesGlobalDouble().