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 std::string &s)
bool	ReferencesGlobalDouble (const double &x)
std::string	ByNonConstRef (std::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)
std::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)
std::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)
std::string	Concat6 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6)
std::string	Concat7 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7)
std::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)
std::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)
std::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

Binary()

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

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

{ return input + n; }  // NOLINT

ByConstRef()

bool testing::gmock_more_actions_test::ByConstRef

(

const std::string &

s

)

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

{ return s == "Hi"; }

ByNonConstRef()

std::string testing::gmock_more_actions_test::ByNonConstRef

(

std::string &

s

)

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

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

Char()

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

inline

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

{ return ch; }

Here is the caller graph for this function:

CharPtr()

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

inline

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

{ return s; }

Here is the caller graph for this function:

Concat10()

std::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.

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

Here is the caller graph for this function:

Concat4()

std::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.

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

Concat5()

std::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.

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

Concat6()

std::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.

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

Concat7()

std::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.

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

Here is the caller graph for this function:

Concat8()

std::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.

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

Here is the caller graph for this function:

Concat9()

std::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.

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

Here is the caller graph for this function:

Nullary()

int testing::gmock_more_actions_test::Nullary

(

)

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

{ return 1; }

Here is the caller graph for this function:

Plus1()

const char * testing::gmock_more_actions_test::Plus1

(

const char *

s

)

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

{ return s + 1; }

ReferencesGlobalDouble()

bool testing::gmock_more_actions_test::ReferencesGlobalDouble

(

const double &

x

)

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

{ return &x == &g_double; }

Short()

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

inline

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

{ return n; }  // NOLINT

Here is the caller graph for this function:

SumOf4()

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.

{ return a + b + c + d; }

Here is the caller graph for this function:

SumOf5()

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.

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

Here is the caller graph for this function:

SumOf6()

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.

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

Here is the caller graph for this function:

SumOfFirst2()

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

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

{ return a + b; }

Here is the caller graph for this function:

Ternary()

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

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

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

Here is the caller graph for this function:

TEST() [1/47]

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

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

                                  {
  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);
}

Here is the call graph for this function:

TEST() [2/47]

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

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

                                   {
  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);
}

Here is the call graph for this function:

TEST() [3/47]

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

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

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

Here is the call graph for this function:

TEST() [4/47]

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

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

                                                   {
  Foo foo;
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [5/47]

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

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

                                                  {
  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)));
}

Here is the call graph for this function:

TEST() [6/47]

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

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

                                                  {
  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)));
}

Here is the call graph for this function:

TEST() [7/47]

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

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

                                                  {
  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)));
}

Here is the call graph for this function:

TEST() [8/47]

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

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

                                                  {
  Foo foo;
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [9/47]

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

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

                                                  {
  Foo foo;
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [10/47]

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

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

                                                  {
  Foo foo;
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [11/47]

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

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

                                                 {
  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)));
}

Here is the call graph for this function:

TEST() [12/47]

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

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

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

Here is the call graph for this function:

TEST() [13/47]

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

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

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

Here is the call graph for this function:

TEST() [14/47]

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

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

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

Here is the call graph for this function:

TEST() [15/47]

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

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

                         {
  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))));
}

Here is the call graph for this function:

TEST() [16/47]

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

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

                                               {
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [17/47]

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

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

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

Here is the call graph for this function:

TEST() [18/47]

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

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

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

Here is the call graph for this function:

TEST() [19/47]

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

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

                                              {
  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)));
}

Here is the call graph for this function:

TEST() [20/47]

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

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

                                              {
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [21/47]

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

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

                                              {
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [22/47]

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

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

                                              {
  Action<std::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"))));
}

Here is the call graph for this function:

TEST() [23/47]

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

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

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

Here is the call graph for this function:

TEST() [24/47]

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

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

                                               {
  Action<int(int, int, double, const std::string&)> a1 = Invoke(SumOfFirst2);
  tuple<int, int, double, std::string> dummy =
      make_tuple(10, 2, 5.6, std::string("hi"));
  EXPECT_EQ(12, a1.Perform(dummy));
 
  Action<int(int, int, bool, int*)> a2 =
      Invoke(SumOfFirst2);
  EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
}

Here is the call graph for this function:

TEST() [25/47]

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

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

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

Here is the call graph for this function:

TEST() [26/47]

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

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

                                             {
  Foo foo;
  Action<int(std::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)));
}

Here is the call graph for this function:

TEST() [27/47]

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

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

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

Here is the call graph for this function:

TEST() [28/47]

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

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

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

Here is the call graph for this function:

TEST() [29/47]

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

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

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

Here is the call graph for this function:

TEST() [30/47]

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

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

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

TEST() [31/47]

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

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

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

TEST() [32/47]

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

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

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

TEST() [33/47]

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

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

                               {
  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()));
}

TEST() [34/47]

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

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

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

Here is the call graph for this function:

TEST() [35/47]

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

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

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

Here is the call graph for this function:

TEST() [36/47]

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

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

                                                       {
  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);
}

Here is the call graph for this function:

TEST() [37/47]

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

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

                                                  {
  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);
}

Here is the call graph for this function:

TEST() [38/47]

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

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

                                                 {
  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);
}

Here is the call graph for this function:

TEST() [39/47]

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

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

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

Here is the call graph for this function:

TEST() [40/47]

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

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

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

Here is the call graph for this function:

TEST() [41/47]

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

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

                                                       {
  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);
}

Here is the call graph for this function:

TEST() [42/47]

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

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

                                            {
  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]);
}

TEST() [43/47]

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

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

                                                               {
  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]);
}

TEST() [44/47]

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

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

                                                          {
  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]);
}

TEST() [45/47]

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

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

                                                                {
  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);
}

TEST() [46/47]

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

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

                          {
  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)));
}

Here is the call graph for this function:

TEST() [47/47]

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

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

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

Here is the call graph for this function:

Unary()

bool testing::gmock_more_actions_test::Unary

(

int

x

)

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

{ return x < 0; }

VoidBinary()

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

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

{ g_done = true; }

VoidFunctionWithFourArguments()

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

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

{ g_done = true; }

VoidNullary()

void testing::gmock_more_actions_test::VoidNullary

(

)

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

{ g_done = true; }

VoidTernary()

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

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

{ g_done = true; }

VoidUnary()

void testing::gmock_more_actions_test::VoidUnary

(

int

)

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

{ g_done = true; }

Variable Documentation

g_done

bool testing::gmock_more_actions_test::g_done = false

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

g_double

const double testing::gmock_more_actions_test::g_double = 0

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