testing::gmock_more_actions_test Namespace Reference

Namespaces
namespace	action_test

Classes
class	BoolResetter
class	DeletionTester
class	Foo
struct	GiantTemplate
struct	SumOf5Functor
struct	SumOf6Functor
class	TenArgConstructorClass
struct	UnaryFunctor

Functions
short	Short (short n)
char	Char (char ch)
int	Nullary ()
bool	Unary (int x)
bool	ByConstRef (const std::string &s)
bool	ReferencesGlobalDouble (const double &x)
const char *	Binary (const char *input, short n)
int	Ternary (int x, char y, short z)
int	SumOf4 (int a, int b, int c, int d)
int	SumOfFirst2 (int a, int b, Unused, Unused)
int	SumOf5 (int a, int b, int c, int d, int e)
int	SumOf6 (int a, int b, int c, int d, int e, int f)
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 (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)
	TEST (InvokeArgumentTest, Function0)
	TEST (InvokeArgumentTest, Functor1)
	TEST (InvokeArgumentTest, Function5)
	TEST (InvokeArgumentTest, Functor5)
	TEST (InvokeArgumentTest, Function6)
	TEST (InvokeArgumentTest, Functor6)
	TEST (InvokeArgumentTest, Function7)
	TEST (InvokeArgumentTest, Function8)
	TEST (InvokeArgumentTest, Function9)
	TEST (InvokeArgumentTest, Function10)
	TEST (InvokeArgumentTest, ByPointerFunction)
	TEST (InvokeArgumentTest, FunctionWithCStringLiteral)
	TEST (InvokeArgumentTest, ByConstReferenceFunction)
	TEST (InvokeArgumentTest, ByExplicitConstReferenceFunction)
	TEST (DoAllTest, TwoActions)
	TEST (DoAllTest, ThreeActions)
	TEST (DoAllTest, FourActions)
	TEST (DoAllTest, FiveActions)
	TEST (DoAllTest, SixActions)
	TEST (DoAllTest, SevenActions)
	TEST (DoAllTest, EightActions)
	TEST (DoAllTest, NineActions)
	TEST (DoAllTest, TenActions)
	TEST (DoAllTest, NoArgs)
	TEST (DoAllTest, MoveOnlyArgs)
	TEST (DoAllTest, ImplicitlyConvertsActionArguments)
	ACTION (Return5)
	TEST (ActionMacroTest, WorksWhenNotReferencingArguments)
	ACTION (IncrementArg1)
	TEST (ActionMacroTest, WorksWhenReturningVoid)
	ACTION (IncrementArg2)
	TEST (ActionMacroTest, CanReferenceArgumentType)
	ACTION (Sum2)
	TEST (ActionMacroTest, CanReferenceArgumentTuple)
	ACTION (InvokeDummy)
	TEST (ActionMacroTest, CanReferenceMockFunctionType)
	ACTION (InvokeDummy2)
	TEST (ActionMacroTest, CanReferenceMockFunctionReturnType)
	ACTION (ReturnAddrOfConstBoolReferenceArg)
	TEST (ActionMacroTest, WorksForConstReferenceArg)
	ACTION (ReturnAddrOfIntReferenceArg)
	TEST (ActionMacroTest, WorksForNonConstReferenceArg)
	TEST (ActionMacroTest, WorksInNamespace)
	ACTION (PlusTwo)
	TEST (ActionMacroTest, WorksForDifferentArgumentNumbers)
	ACTION_P (Plus, n)
	TEST (ActionPMacroTest, DefinesParameterizedAction)
	ACTION_P (TypedPlus, n)
	TEST (ActionPMacroTest, CanReferenceArgumentAndParameterTypes)
	TEST (ActionPMacroTest, WorksInCompatibleMockFunction)
	ACTION (OverloadedAction)
	ACTION_P (OverloadedAction, default_value)
	ACTION_P2 (OverloadedAction, true_value, false_value)
	TEST (ActionMacroTest, CanDefineOverloadedActions)
	ACTION_P3 (Plus, m, n, k)
	TEST (ActionPnMacroTest, WorksFor3Parameters)
	ACTION_P4 (Plus, p0, p1, p2, p3)
	TEST (ActionPnMacroTest, WorksFor4Parameters)
	ACTION_P5 (Plus, p0, p1, p2, p3, p4)
	TEST (ActionPnMacroTest, WorksFor5Parameters)
	ACTION_P6 (Plus, p0, p1, p2, p3, p4, p5)
	TEST (ActionPnMacroTest, WorksFor6Parameters)
	ACTION_P7 (Plus, p0, p1, p2, p3, p4, p5, p6)
	TEST (ActionPnMacroTest, WorksFor7Parameters)
	ACTION_P8 (Plus, p0, p1, p2, p3, p4, p5, p6, p7)
	TEST (ActionPnMacroTest, WorksFor8Parameters)
	ACTION_P9 (Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8)
	TEST (ActionPnMacroTest, WorksFor9Parameters)
	ACTION_P10 (Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8, last_param)
	TEST (ActionPnMacroTest, WorksFor10Parameters)
	ACTION_P2 (PadArgument, prefix, suffix)
	TEST (ActionPnMacroTest, SimpleTypePromotion)
	ACTION_P3 (ConcatImpl, a, b, c)
template<typename T1 , typename T2 >
ConcatImplActionP3< std::string, T1, T2 >	Concat (const std::string &a, T1 b, T2 c)
template<typename T1 , typename T2 >
ConcatImplActionP3< T1, int, T2 >	Concat (T1 a, int b, T2 c)
	TEST (ActionPnMacroTest, CanPartiallyRestrictParameterTypes)
	ACTION (DoFoo)
	ACTION_P (DoFoo, p)
	ACTION_P2 (DoFoo, p0, p1)
	TEST (ActionPnMacroTest, TypesAreCorrect)
	ACTION_P (Plus1, x)
	ACTION_P2 (Plus2, x, y)
	ACTION_P3 (Plus3, x, y, z)
	ACTION_P10 (Plus10, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
	TEST (ActionPnMacroTest, CanExplicitlyInstantiateWithReferenceTypes)
	ACTION_TEMPLATE (CreateNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_0_VALUE_PARAMS())
	TEST (ActionTemplateTest, WorksWithoutValueParam)
	ACTION_TEMPLATE (CreateNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_1_VALUE_PARAMS(a0))
	TEST (ActionTemplateTest, WorksWithValueParams)
	ACTION_TEMPLATE (MyDeleteArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())
	TEST (ActionTemplateTest, WorksForIntegralTemplateParams)
	ACTION_TEMPLATE (ReturnSmartPointer, HAS_1_TEMPLATE_PARAMS(template< typename Pointee > class, Pointer), AND_1_VALUE_PARAMS(pointee))
	TEST (ActionTemplateTest, WorksForTemplateTemplateParameters)
	ACTION_TEMPLATE (ReturnGiant, HAS_10_TEMPLATE_PARAMS(typename, T1, typename, T2, typename, T3, int, k4, bool, k5, unsigned int, k6, class, T7, class, T8, class, T9, template< typename T > class, T10), AND_1_VALUE_PARAMS(value))
	TEST (ActionTemplateTest, WorksFor10TemplateParameters)
	ACTION_TEMPLATE (ReturnSum, HAS_1_TEMPLATE_PARAMS(typename, Number), AND_10_VALUE_PARAMS(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10))
	TEST (ActionTemplateTest, WorksFor10ValueParameters)
	ACTION (ReturnSum)
	ACTION_P (ReturnSum, x)
	ACTION_TEMPLATE (ReturnSum, HAS_1_TEMPLATE_PARAMS(typename, Number), AND_2_VALUE_PARAMS(v1, v2))
	ACTION_TEMPLATE (ReturnSum, HAS_1_TEMPLATE_PARAMS(typename, Number), AND_3_VALUE_PARAMS(v1, v2, v3))
	ACTION_TEMPLATE (ReturnSum, HAS_2_TEMPLATE_PARAMS(typename, Number, int, k), AND_4_VALUE_PARAMS(v1, v2, v3, v4))
	TEST (ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters)

Variables
bool	g_done = false
const double	g_double = 0

Function Documentation

ACTION() [1/12]

testing::gmock_more_actions_test::ACTION

(

DoFoo

)

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

{}

ACTION() [2/12]

testing::gmock_more_actions_test::ACTION

(

IncrementArg1

)

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

{ (*arg1)++; }

ACTION() [3/12]

testing::gmock_more_actions_test::ACTION

(

IncrementArg2

)

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

                      {
  StaticAssertTypeEq<int*, arg2_type>();
  arg2_type temp = arg2;
  (*temp)++;
}

ACTION() [4/12]

testing::gmock_more_actions_test::ACTION

(

InvokeDummy

)

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

                    {
  StaticAssertTypeEq<int(bool), function_type>();
  function_type* fp = &Dummy;
  return (*fp)(true);
}

ACTION() [5/12]

testing::gmock_more_actions_test::ACTION

(

InvokeDummy2

)

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

                     {
  StaticAssertTypeEq<int, return_type>();
  return_type result = Dummy(true);
  return result;
}

ACTION() [6/12]

testing::gmock_more_actions_test::ACTION

(

OverloadedAction

)

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

{ return arg0 ? arg1 : "hello"; }

ACTION() [7/12]

testing::gmock_more_actions_test::ACTION

(

PlusTwo

)

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

{ return arg0 + 2; }

ACTION() [8/12]

testing::gmock_more_actions_test::ACTION

(

Return5

)

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

{ return 5; }

ACTION() [9/12]

testing::gmock_more_actions_test::ACTION

(

ReturnAddrOfConstBoolReferenceArg

)

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

                                          {
  StaticAssertTypeEq<const bool&, arg1_type>();
  return &arg1;
}

ACTION() [10/12]

testing::gmock_more_actions_test::ACTION

(

ReturnAddrOfIntReferenceArg

)

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

                                    {
  StaticAssertTypeEq<int&, arg0_type>();
  return &arg0;
}

ACTION() [11/12]

testing::gmock_more_actions_test::ACTION

(

ReturnSum

)

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

{ return 0; }

ACTION() [12/12]

testing::gmock_more_actions_test::ACTION

(

Sum2

)

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

             {
  StaticAssertTypeEq<std::tuple<int, char, int*>, args_type>();
  args_type args_copy = args;
  return std::get<0>(args_copy) + std::get<1>(args_copy);
}

ACTION_P() [1/6]

testing::gmock_more_actions_test::ACTION_P	(	DoFoo	,
		p
	)

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

{}

ACTION_P() [2/6]

testing::gmock_more_actions_test::ACTION_P	(	OverloadedAction	,
		default_value
	)

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

                                          {
  return arg0 ? arg1 : default_value;
}

ACTION_P() [3/6]

testing::gmock_more_actions_test::ACTION_P	(	Plus	,
		n
	)

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

{ return arg0 + n; }

ACTION_P() [4/6]

testing::gmock_more_actions_test::ACTION_P	(	Plus1	,
		x
	)

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

{ return x; }

ACTION_P() [5/6]

testing::gmock_more_actions_test::ACTION_P	(	ReturnSum	,
		x
	)

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

{ return x; }

ACTION_P() [6/6]

testing::gmock_more_actions_test::ACTION_P	(	TypedPlus	,
		n
	)

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

                       {
  arg0_type t1 = arg0;
  n_type t2 = n;
  return t1 + t2;
}

ACTION_P10() [1/2]

testing::gmock_more_actions_test::ACTION_P10	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4	,
		p5	,
		p6	,
		p7	,
		p8	,
		last_param
	)

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

                                                                 {
  arg0_type t0 = arg0;
  last_param_type t9 = last_param;
  return t0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + t9;
}

ACTION_P10() [2/2]

testing::gmock_more_actions_test::ACTION_P10	(	Plus10	,
		a0	,
		a1	,
		a2	,
		a3	,
		a4	,
		a5	,
		a6	,
		a7	,
		a8	,
		a9
	)

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

                                                           {
  return a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9;
}

ACTION_P2() [1/4]

testing::gmock_more_actions_test::ACTION_P2	(	DoFoo	,
		p0	,
		p1
	)

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

{}

ACTION_P2() [2/4]

testing::gmock_more_actions_test::ACTION_P2	(	OverloadedAction	,
		true_value	,
		false_value
	)

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

                                                     {
  return arg0 ? true_value : false_value;
}

ACTION_P2() [3/4]

testing::gmock_more_actions_test::ACTION_P2	(	PadArgument	,
		prefix	,
		suffix
	)

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

                                       {
  // The following lines promote the two parameters to desired types.
  std::string prefix_str(prefix);
  char suffix_char = static_cast<char>(suffix);
  return prefix_str + arg0 + suffix_char;
}

ACTION_P2() [4/4]

testing::gmock_more_actions_test::ACTION_P2	(	Plus2	,
		x	,
		y
	)

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

{ return x + y; }

ACTION_P3() [1/3]

testing::gmock_more_actions_test::ACTION_P3	(	ConcatImpl	,
		a	,
		b	,
		c
	)

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

                               {
  std::stringstream ss;
  ss << a << b << c;
  return ss.str();
}

ACTION_P3() [2/3]

testing::gmock_more_actions_test::ACTION_P3	(	Plus	,
		m	,
		n	,
		k
	)

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

{ return arg0 + m + n + k; }

ACTION_P3() [3/3]

testing::gmock_more_actions_test::ACTION_P3	(	Plus3	,
		x	,
		y	,
		z
	)

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

{ return x + y + z; }

ACTION_P4()

testing::gmock_more_actions_test::ACTION_P4	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3
	)

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

{ return arg0 + p0 + p1 + p2 + p3; }

ACTION_P5()

testing::gmock_more_actions_test::ACTION_P5	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4
	)

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

{ return arg0 + p0 + p1 + p2 + p3 + p4; }

ACTION_P6()

testing::gmock_more_actions_test::ACTION_P6	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4	,
		p5
	)

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

                                        {
  return arg0 + p0 + p1 + p2 + p3 + p4 + p5;
}

ACTION_P7()

testing::gmock_more_actions_test::ACTION_P7	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4	,
		p5	,
		p6
	)

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

                                            {
  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6;
}

ACTION_P8()

testing::gmock_more_actions_test::ACTION_P8	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4	,
		p5	,
		p6	,
		p7
	)

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

                                                {
  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7;
}

ACTION_P9()

testing::gmock_more_actions_test::ACTION_P9	(	Plus	,
		p0	,
		p1	,
		p2	,
		p3	,
		p4	,
		p5	,
		p6	,
		p7	,
		p8
	)

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

                                                    {
  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8;
}

ACTION_TEMPLATE() [1/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	CreateNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_0_VALUE_PARAMS()
	)

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

                                      {
  return new T;
}

ACTION_TEMPLATE() [2/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	CreateNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_1_VALUE_PARAMS(a0)
	)

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

                                        {
  return new T(a0);
}

ACTION_TEMPLATE() [3/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	MyDeleteArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

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

                                      {
  delete std::get<k>(args);
}

ACTION_TEMPLATE() [4/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnGiant	,
		HAS_10_TEMPLATE_PARAMS(typename, T1, typename, T2, typename, T3, int, k4, bool, k5, unsigned int, k6, class, T7, class, T8, class, T9, template< typename T > class, T10)	,
		AND_1_VALUE_PARAMS(value)
	)

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

                                           {
  return GiantTemplate<T10<T1>, T2, T3, k4, k5, k6, T7, T8, T9>(value);
}

ACTION_TEMPLATE() [5/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnSmartPointer	,
		HAS_1_TEMPLATE_PARAMS(template< typename Pointee > class, Pointer)	,
		AND_1_VALUE_PARAMS(pointee)
	)

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

                                             {
  return Pointer<pointee_type>(new pointee_type(pointee));
}

ACTION_TEMPLATE() [6/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnSum	,
		HAS_1_TEMPLATE_PARAMS(typename, Number)	,
		AND_10_VALUE_PARAMS(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
	)

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

                                                                              {
  return static_cast<Number>(v1) + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10;
}

ACTION_TEMPLATE() [7/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnSum	,
		HAS_1_TEMPLATE_PARAMS(typename, Number)	,
		AND_2_VALUE_PARAMS(v1, v2)
	)

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

                                            {
  return static_cast<Number>(v1) + v2;
}

ACTION_TEMPLATE() [8/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnSum	,
		HAS_1_TEMPLATE_PARAMS(typename, Number)	,
		AND_3_VALUE_PARAMS(v1, v2, v3)
	)

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

                                                {
  return static_cast<Number>(v1) + v2 + v3;
}

ACTION_TEMPLATE() [9/9]

testing::gmock_more_actions_test::ACTION_TEMPLATE	(	ReturnSum	,
		HAS_2_TEMPLATE_PARAMS(typename, Number, int, k)	,
		AND_4_VALUE_PARAMS(v1, v2, v3, v4)
	)

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

                                                    {
  return static_cast<Number>(v1) + v2 + v3 + v4 + k;
}

Binary()

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

Definition at line 87 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 78 of file gmock-more-actions_test.cc.

{ return s == "Hi"; }

Char()

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

inline

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

{ return ch; }

CharPtr()

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

inline

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

{ return s; }

Concat() [1/2]

template<typename T1 , typename T2 >

ConcatImplActionP3< std::string, T1, T2 > testing::gmock_more_actions_test::Concat	(	const std::string &	a,
		T1	b,
		T2	c
	)

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

                                                     {
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
  if (true) {
    GTEST_INTENTIONAL_CONST_COND_POP_()
    // This branch verifies that ConcatImpl() can be invoked without
    // explicit template arguments.
    return ConcatImpl(a, b, c);
  } else {
    // This branch verifies that ConcatImpl() can also be invoked with
    // explicit template arguments.  It doesn't really need to be
    // executed as this is a compile-time verification.
    return ConcatImpl<std::string, T1, T2>(a, b, c);
  }
}

Concat() [2/2]

template<typename T1 , typename T2 >

ConcatImplActionP3< T1, int, T2 > testing::gmock_more_actions_test::Concat	(	T1	a,
		int	b,
		T2	c
	)

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

                                                          {
  return ConcatImpl(a, b, c);
}

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 131 of file gmock-more-actions_test.cc.

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

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 113 of file gmock-more-actions_test.cc.

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

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 119 of file gmock-more-actions_test.cc.

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

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 125 of file gmock-more-actions_test.cc.

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

Nullary()

int testing::gmock_more_actions_test::Nullary

(

)

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

{ return 1; }

ReferencesGlobalDouble()

bool testing::gmock_more_actions_test::ReferencesGlobalDouble

(

const double &

x

)

Definition at line 81 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 68 of file gmock-more-actions_test.cc.

{ return n; }  // NOLINT

SumOf4()

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

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

{ return a + b + c + d; }

SumOf5()

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

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

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

SumOf6()

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

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

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

SumOfFirst2()

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

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

{ return a + b; }

Ternary()

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

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

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

TEST() [1/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		CanDefineOverloadedActions
	)

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

                                                  {
  using MyAction = Action<const char*(bool, const char*)>;
 
  const MyAction a1 = OverloadedAction();
  EXPECT_STREQ("hello", a1.Perform(std::make_tuple(false, CharPtr("world"))));
  EXPECT_STREQ("world", a1.Perform(std::make_tuple(true, CharPtr("world"))));
 
  const MyAction a2 = OverloadedAction("hi");
  EXPECT_STREQ("hi", a2.Perform(std::make_tuple(false, CharPtr("world"))));
  EXPECT_STREQ("world", a2.Perform(std::make_tuple(true, CharPtr("world"))));
 
  const MyAction a3 = OverloadedAction("hi", "you");
  EXPECT_STREQ("hi", a3.Perform(std::make_tuple(true, CharPtr("world"))));
  EXPECT_STREQ("you", a3.Perform(std::make_tuple(false, CharPtr("world"))));
}

TEST() [2/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		CanReferenceArgumentTuple
	)

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

                                                 {
  Action<int(int, char, int*)> a1 = Sum2();
  int dummy = 0;
  EXPECT_EQ(11, a1.Perform(std::make_tuple(5, Char(6), &dummy)));
}

TEST() [3/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		CanReferenceArgumentType
	)

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

                                                {
  Action<void(int, bool, int*)> a1 = IncrementArg2();
  int n = 0;
  a1.Perform(std::make_tuple(5, false, &n));
  EXPECT_EQ(1, n);
}

TEST() [4/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		CanReferenceMockFunctionReturnType
	)

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

                                                          {
  Action<int(bool)> a1 = InvokeDummy2();
  EXPECT_EQ(1, a1.Perform(std::make_tuple(true)));
  EXPECT_EQ(1, a1.Perform(std::make_tuple(false)));
}

TEST() [5/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		CanReferenceMockFunctionType
	)

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

                                                    {
  Action<int(bool)> a1 = InvokeDummy();
  EXPECT_EQ(1, a1.Perform(std::make_tuple(true)));
  EXPECT_EQ(1, a1.Perform(std::make_tuple(false)));
}

TEST() [6/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksForConstReferenceArg
	)

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

                                                 {
  Action<const bool*(int, const bool&)> a = ReturnAddrOfConstBoolReferenceArg();
  const bool b = false;
  EXPECT_EQ(&b, a.Perform(std::tuple<int, const bool&>(0, b)));
}

TEST() [7/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksForDifferentArgumentNumbers
	)

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

                                                        {
  Action<int(int)> a1 = PlusTwo();
  EXPECT_EQ(4, a1.Perform(std::make_tuple(2)));
 
  Action<double(float, void*)> a2 = PlusTwo();
  int dummy;
  EXPECT_DOUBLE_EQ(6, a2.Perform(std::make_tuple(4.0f, &dummy)));
}

TEST() [8/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksForNonConstReferenceArg
	)

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

                                                    {
  Action<int*(int&, bool, int)> a = ReturnAddrOfIntReferenceArg();
  int n = 0;
  EXPECT_EQ(&n, a.Perform(std::tuple<int&, bool, int>(n, true, 1)));
}

TEST() [9/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksInNamespace
	)

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

                                        {
  Action<int(int, int)> a1 = action_test::Sum();
  EXPECT_EQ(3, a1.Perform(std::make_tuple(1, 2)));
}

TEST() [10/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksWhenNotReferencingArguments
	)

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

                                                        {
  Action<double()> a1 = Return5();
  EXPECT_DOUBLE_EQ(5, a1.Perform(std::make_tuple()));
 
  Action<int(double, bool)> a2 = Return5();
  EXPECT_EQ(5, a2.Perform(std::make_tuple(1, true)));
}

TEST() [11/105]

testing::gmock_more_actions_test::TEST	(	ActionMacroTest	,
		WorksWhenReturningVoid
	)

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

                                              {
  Action<void(int, int*)> a1 = IncrementArg1();
  int n = 0;
  a1.Perform(std::make_tuple(5, &n));
  EXPECT_EQ(1, n);
}

TEST() [12/105]

testing::gmock_more_actions_test::TEST	(	ActionPMacroTest	,
		CanReferenceArgumentAndParameterTypes
	)

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

                                                              {
  Action<int(char m, bool t)> a1 = TypedPlus(9);
  EXPECT_EQ(10, a1.Perform(std::make_tuple(Char(1), true)));
}

TEST() [13/105]

testing::gmock_more_actions_test::TEST	(	ActionPMacroTest	,
		DefinesParameterizedAction
	)

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

                                                   {
  Action<int(int m, bool t)> a1 = Plus(9);
  EXPECT_EQ(10, a1.Perform(std::make_tuple(1, true)));
}

TEST() [14/105]

testing::gmock_more_actions_test::TEST	(	ActionPMacroTest	,
		WorksInCompatibleMockFunction
	)

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

                                                      {
  Action<std::string(const std::string& s)> a1 = Plus("tail");
  const std::string re = "re";
  std::tuple<const std::string> dummy = std::make_tuple(re);
  EXPECT_EQ("retail", a1.Perform(dummy));
}

TEST() [15/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		CanExplicitlyInstantiateWithReferenceTypes
	)

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

                                                                    {
  int x = 1, y = 2, z = 3;
  const std::tuple<> empty = std::make_tuple();
 
  Action<int()> a = Plus1<int&>(x);
  EXPECT_EQ(1, a.Perform(empty));
 
  a = Plus2<const int&, int&>(x, y);
  EXPECT_EQ(3, a.Perform(empty));
 
  a = Plus3<int&, const int&, int&>(x, y, z);
  EXPECT_EQ(6, a.Perform(empty));
 
  int n[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  a = Plus10<const int&, int&, const int&, int&, const int&, int&, const int&,
             int&, const int&, int&>(n[0], n[1], n[2], n[3], n[4], n[5], n[6],
                                     n[7], n[8], n[9]);
  EXPECT_EQ(55, a.Perform(empty));
}

TEST() [16/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		CanPartiallyRestrictParameterTypes
	)

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

                                                            {
  Action<const std::string()> a1 = Concat("Hello", "1", 2);
  EXPECT_EQ("Hello12", a1.Perform(std::make_tuple()));
 
  a1 = Concat(1, 2, 3);
  EXPECT_EQ("123", a1.Perform(std::make_tuple()));
}

TEST() [17/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		SimpleTypePromotion
	)

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

                                             {
  Action<std::string(const char*)> no_promo =
      PadArgument(std::string("foo"), 'r');
  Action<std::string(const char*)> promo =
      PadArgument("foo", static_cast<int>('r'));
  EXPECT_EQ("foobar", no_promo.Perform(std::make_tuple(CharPtr("ba"))));
  EXPECT_EQ("foobar", promo.Perform(std::make_tuple(CharPtr("ba"))));
}

TEST() [18/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		TypesAreCorrect
	)

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

                                         {
  // DoFoo() must be assignable to a DoFooAction variable.
  DoFooAction a0 = DoFoo();
 
  // DoFoo(1) must be assignable to a DoFooActionP variable.
  DoFooActionP<int> a1 = DoFoo(1);
 
  // DoFoo(p1, ..., pk) must be assignable to a DoFooActionPk
  // variable, and so on.
  DoFooActionP2<int, char> a2 = DoFoo(1, '2');
  PlusActionP3<int, int, char> a3 = Plus(1, 2, '3');
  PlusActionP4<int, int, int, char> a4 = Plus(1, 2, 3, '4');
  PlusActionP5<int, int, int, int, char> a5 = Plus(1, 2, 3, 4, '5');
  PlusActionP6<int, int, int, int, int, char> a6 = Plus(1, 2, 3, 4, 5, '6');
  PlusActionP7<int, int, int, int, int, int, char> a7 =
      Plus(1, 2, 3, 4, 5, 6, '7');
  PlusActionP8<int, int, int, int, int, int, int, char> a8 =
      Plus(1, 2, 3, 4, 5, 6, 7, '8');
  PlusActionP9<int, int, int, int, int, int, int, int, char> a9 =
      Plus(1, 2, 3, 4, 5, 6, 7, 8, '9');
  PlusActionP10<int, int, int, int, int, int, int, int, int, char> a10 =
      Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
 
  // Avoid "unused variable" warnings.
  (void)a0;
  (void)a1;
  (void)a2;
  (void)a3;
  (void)a4;
  (void)a5;
  (void)a6;
  (void)a7;
  (void)a8;
  (void)a9;
  (void)a10;
}

TEST() [19/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor10Parameters
	)

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

                                              {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10,
            a1.Perform(std::make_tuple(10)));
}

TEST() [20/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor3Parameters
	)

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

                                             {
  Action<double(int m, bool t)> a1 = Plus(100, 20, 3.4);
  EXPECT_DOUBLE_EQ(3123.4, a1.Perform(std::make_tuple(3000, true)));
 
  Action<std::string(const std::string& s)> a2 = Plus("tail", "-", ">");
  const std::string re = "re";
  std::tuple<const std::string> dummy = std::make_tuple(re);
  EXPECT_EQ("retail->", a2.Perform(dummy));
}

TEST() [21/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor4Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4, a1.Perform(std::make_tuple(10)));
}

TEST() [22/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor5Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5, a1.Perform(std::make_tuple(10)));
}

TEST() [23/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor6Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6, a1.Perform(std::make_tuple(10)));
}

TEST() [24/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor7Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7, a1.Perform(std::make_tuple(10)));
}

TEST() [25/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor8Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
            a1.Perform(std::make_tuple(10)));
}

TEST() [26/105]

testing::gmock_more_actions_test::TEST	(	ActionPnMacroTest	,
		WorksFor9Parameters
	)

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

                                             {
  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9);
  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9,
            a1.Perform(std::make_tuple(10)));
}

TEST() [27/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		CanBeOverloadedOnNumberOfValueParameters
	)

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

                                                                   {
  const Action<int()> a0 = ReturnSum();
  const Action<int()> a1 = ReturnSum(1);
  const Action<int()> a2 = ReturnSum<int>(1, 2);
  const Action<int()> a3 = ReturnSum<int>(1, 2, 3);
  const Action<int()> a4 = ReturnSum<int, 10000>(2000, 300, 40, 5);
  EXPECT_EQ(0, a0.Perform(std::make_tuple()));
  EXPECT_EQ(1, a1.Perform(std::make_tuple()));
  EXPECT_EQ(3, a2.Perform(std::make_tuple()));
  EXPECT_EQ(6, a3.Perform(std::make_tuple()));
  EXPECT_EQ(12345, a4.Perform(std::make_tuple()));
}

TEST() [28/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksFor10TemplateParameters
	)

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

                                                       {
  using Giant = GiantTemplate<std::shared_ptr<int>, bool, double, 5, true, 6,
                              char, unsigned, int>;
  const Action<Giant()> a = ReturnGiant<int, bool, double, 5, true, 6, char,
                                        unsigned, int, std::shared_ptr>(42);
  Giant giant = a.Perform(std::make_tuple());
  EXPECT_EQ(42, giant.value);
}

TEST() [29/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksFor10ValueParameters
	)

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

                                                    {
  const Action<int()> a = ReturnSum<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  EXPECT_EQ(55, a.Perform(std::make_tuple()));
}

TEST() [30/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksForIntegralTemplateParams
	)

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

                                                         {
  const Action<void(int*, BoolResetter*)> a = MyDeleteArg<1>();
  int n = 0;
  bool b = true;
  auto* resetter = new BoolResetter(&b);
  a.Perform(std::make_tuple(&n, resetter));
  EXPECT_FALSE(b);  // Verifies that resetter is deleted.
}

TEST() [31/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksForTemplateTemplateParameters
	)

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

                                                             {
  const Action<std::shared_ptr<int>()> a =
      ReturnSmartPointer<std::shared_ptr>(42);
  std::shared_ptr<int> p = a.Perform(std::make_tuple());
  EXPECT_EQ(42, *p);
}

TEST() [32/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksWithoutValueParam
	)

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

                                                 {
  const Action<int*()> a = CreateNew<int>();
  int* p = a.Perform(std::make_tuple());
  delete p;
}

TEST() [33/105]

testing::gmock_more_actions_test::TEST	(	ActionTemplateTest	,
		WorksWithValueParams
	)

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

                                               {
  const Action<int*()> a = CreateNew<int>(42);
  int* p = a.Perform(std::make_tuple());
  EXPECT_EQ(42, *p);
  delete p;
}

TEST() [34/105]

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

Definition at line 534 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(std::make_tuple(t));
  EXPECT_TRUE(is_deleted);
}

TEST() [35/105]

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

Definition at line 543 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(std::make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
  EXPECT_TRUE(is_deleted);
}

TEST() [36/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		EightActions
	)

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

                              {
  int m = 0, n = 0;
  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0';
  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
             char*)>
      action =
          DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
                SetArgPointee<3>('b'), SetArgPointee<4>('c'),
                SetArgPointee<5>('d'), SetArgPointee<6>('e'), Return(3));
  EXPECT_EQ(3, action.Perform(std::make_tuple(&m, &n, &a, &b, &c, &d, &e)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
  EXPECT_EQ('c', c);
  EXPECT_EQ('d', d);
  EXPECT_EQ('e', e);
}

TEST() [37/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		FiveActions
	)

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

                             {
  int m = 0, n = 0;
  char a = '\0', b = '\0';
  Action<int(int*, int*, char*, char*)> action =  // NOLINT
      DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
            SetArgPointee<3>('b'), Return(3));
  EXPECT_EQ(3, action.Perform(std::make_tuple(&m, &n, &a, &b)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
}

TEST() [38/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		FourActions
	)

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

                             {
  int m = 0, n = 0;
  char ch = '\0';
  Action<int(int*, int*, char*)> a =  // NOLINT
      DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
            Return(3));
  EXPECT_EQ(3, a.Perform(std::make_tuple(&m, &n, &ch)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', ch);
}

TEST() [39/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		ImplicitlyConvertsActionArguments
	)

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

                                                   {
  bool ran_first = false;
  // Action<void(std::vector<int>)> isn't an
  // Action<void(const std::vector<int>&) but can be converted.
  Action<void(std::vector<int>)> first = [&] { ran_first = true; };
  Action<int(std::vector<int>)> a =
      DoAll(first, [](std::vector<int> arg) { return arg.front(); });
  EXPECT_EQ(7, a.Perform(std::make_tuple(std::vector<int>{7})));
  EXPECT_TRUE(ran_first);
}

TEST() [40/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		MoveOnlyArgs
	)

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

                              {
  bool ran_first = false;
  Action<int(std::unique_ptr<int>)> a =
      DoAll(InvokeWithoutArgs([&] { ran_first = true; }),
            [](std::unique_ptr<int> p) { return *p; });
  EXPECT_EQ(7, a.Perform(std::make_tuple(std::unique_ptr<int>(new int(7)))));
  EXPECT_TRUE(ran_first);
}

TEST() [41/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		NineActions
	)

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

                             {
  int m = 0, n = 0;
  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0', f = '\0';
  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
             char*, char*)>
      action = DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2),
                     SetArgPointee<2>('a'), SetArgPointee<3>('b'),
                     SetArgPointee<4>('c'), SetArgPointee<5>('d'),
                     SetArgPointee<6>('e'), SetArgPointee<7>('f'), Return(3));
  EXPECT_EQ(3, action.Perform(std::make_tuple(&m, &n, &a, &b, &c, &d, &e, &f)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
  EXPECT_EQ('c', c);
  EXPECT_EQ('d', d);
  EXPECT_EQ('e', e);
  EXPECT_EQ('f', f);
}

TEST() [42/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		NoArgs
	)

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

                        {
  bool ran_first = false;
  Action<bool()> a =
      DoAll([&] { ran_first = true; }, [&] { return ran_first; });
  EXPECT_TRUE(a.Perform({}));
}

TEST() [43/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		SevenActions
	)

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

                              {
  int m = 0, n = 0;
  char a = '\0', b = '\0', c = '\0', d = '\0';
  Action<int(int*, int*, char*, char*, char*, char*)> action =  // NOLINT
      DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
            SetArgPointee<3>('b'), SetArgPointee<4>('c'), SetArgPointee<5>('d'),
            Return(3));
  EXPECT_EQ(3, action.Perform(std::make_tuple(&m, &n, &a, &b, &c, &d)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
  EXPECT_EQ('c', c);
  EXPECT_EQ('d', d);
}

TEST() [44/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		SixActions
	)

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

                            {
  int m = 0, n = 0;
  char a = '\0', b = '\0', c = '\0';
  Action<int(int*, int*, char*, char*, char*)> action =  // NOLINT
      DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
            SetArgPointee<3>('b'), SetArgPointee<4>('c'), Return(3));
  EXPECT_EQ(3, action.Perform(std::make_tuple(&m, &n, &a, &b, &c)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
  EXPECT_EQ('c', c);
}

TEST() [45/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		TenActions
	)

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

                            {
  int m = 0, n = 0;
  char a = '\0', b = '\0', c = '\0', d = '\0';
  char e = '\0', f = '\0', g = '\0';
  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
             char*, char*, char*)>
      action =
          DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2), SetArgPointee<2>('a'),
                SetArgPointee<3>('b'), SetArgPointee<4>('c'),
                SetArgPointee<5>('d'), SetArgPointee<6>('e'),
                SetArgPointee<7>('f'), SetArgPointee<8>('g'), Return(3));
  EXPECT_EQ(
      3, action.Perform(std::make_tuple(&m, &n, &a, &b, &c, &d, &e, &f, &g)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
  EXPECT_EQ('c', c);
  EXPECT_EQ('d', d);
  EXPECT_EQ('e', e);
  EXPECT_EQ('f', f);
  EXPECT_EQ('g', g);
}

TEST() [46/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		ThreeActions
	)

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

                              {
  int m = 0, n = 0;
  Action<int(int*, int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
                                    SetArgPointee<1>(2), Return(3));
  EXPECT_EQ(3, a.Perform(std::make_tuple(&m, &n)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
}

TEST() [47/105]

testing::gmock_more_actions_test::TEST	(	DoAllTest	,
		TwoActions
	)

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

                            {
  int n = 0;
  Action<int(int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
                              Return(2));
  EXPECT_EQ(2, a.Perform(std::make_tuple(&n)));
  EXPECT_EQ(1, n);
}

TEST() [48/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		ByConstReferenceFunction
	)

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

                                                   {
  Action<bool(bool (*function)(const std::string& s))> a =  // NOLINT
      InvokeArgument<0>(std::string("Hi"));
  // When action 'a' is constructed, it makes a copy of the temporary
  // string object passed to it, so it's OK to use 'a' later, when the
  // temporary object has already died.
  EXPECT_TRUE(a.Perform(std::make_tuple(&ByConstRef)));
}

TEST() [49/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		ByExplicitConstReferenceFunction
	)

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

                                                           {
  Action<bool(bool (*)(const double& x))> a =  // NOLINT
      InvokeArgument<0>(ByRef(g_double));
  // The above line calls ByRef() on a const value.
  EXPECT_TRUE(a.Perform(std::make_tuple(&ReferencesGlobalDouble)));
 
  double x = 0;
  a = InvokeArgument<0>(ByRef(x));  // This calls ByRef() on a non-const.
  EXPECT_FALSE(a.Perform(std::make_tuple(&ReferencesGlobalDouble)));
}

TEST() [50/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		ByPointerFunction
	)

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

                                            {
  Action<const char*(const char* (*)(const char* input, short n))>  // NOLINT
      a = InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
  EXPECT_STREQ("i", a.Perform(std::make_tuple(&Binary)));
}

TEST() [51/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function0
	)

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

                                    {
  Action<int(int, int (*)())> a = InvokeArgument<1>();  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(2, &Nullary)));
}

TEST() [52/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function10
	)

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

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

TEST() [53/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function5
	)

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

                                    {
  Action<int(int (*)(int, int, int, int, int))> a =  // NOLINT
      InvokeArgument<0>(10000, 2000, 300, 40, 5);
  EXPECT_EQ(12345, a.Perform(std::make_tuple(&SumOf5)));
}

TEST() [54/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function6
	)

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

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

TEST() [55/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function7
	)

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

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

TEST() [56/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function8
	)

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

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

TEST() [57/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Function9
	)

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

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

TEST() [58/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		FunctionWithCStringLiteral
	)

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

                                                     {
  Action<const char*(const char* (*)(const char* input, short n))>  // NOLINT
      a = InvokeArgument<0>("Hi", Short(1));
  EXPECT_STREQ("i", a.Perform(std::make_tuple(&Binary)));
}

TEST() [59/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Functor1
	)

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

                                   {
  Action<int(UnaryFunctor)> a = InvokeArgument<0>(true);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(UnaryFunctor())));
}

TEST() [60/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Functor5
	)

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

                                   {
  Action<int(SumOf5Functor)> a =  // NOLINT
      InvokeArgument<0>(10000, 2000, 300, 40, 5);
  EXPECT_EQ(12345, a.Perform(std::make_tuple(SumOf5Functor())));
}

TEST() [61/105]

testing::gmock_more_actions_test::TEST	(	InvokeArgumentTest	,
		Functor6
	)

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

                                   {
  Action<int(SumOf6Functor)> a =  // NOLINT
      InvokeArgument<0>(100000, 20000, 3000, 400, 50, 6);
  EXPECT_EQ(123456, a.Perform(std::make_tuple(SumOf6Functor())));
}

TEST() [62/105]

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

Definition at line 340 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");
  std::tuple<std::string, char> dummy = std::make_tuple(s, 'o');
  EXPECT_EQ("Hello", a.Perform(dummy));
}

TEST() [63/105]

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

Definition at line 416 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"), CharPtr("8"), CharPtr("9"),
                                      CharPtr("0"))));
}

TEST() [64/105]

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

Definition at line 356 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(std::make_tuple(1000, 200, 30, 4)));
}

TEST() [65/105]

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

Definition at line 363 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(std::make_tuple(10000, 2000, 300, 40, 5)));
}

TEST() [66/105]

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

Definition at line 370 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(std::make_tuple(100000, 20000, 3000, 400, 50, 6)));
}

TEST() [67/105]

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

Definition at line 379 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"))));
}

TEST() [68/105]

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

Definition at line 391 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"), CharPtr("8"))));
}

TEST() [69/105]

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

Definition at line 403 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(std::make_tuple(
                             CharPtr("1"), CharPtr("2"), CharPtr("3"),
                             CharPtr("4"), CharPtr("5"), CharPtr("6"),
                             CharPtr("7"), CharPtr("8"), CharPtr("9"))));
}

TEST() [70/105]

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

Definition at line 430 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(std::make_tuple(4000, Short(300), Char(20), true)));
}

TEST() [71/105]

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

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

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

TEST() [72/105]

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

Definition at line 349 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(std::make_tuple(1000, true, Char(1))));
}

TEST() [73/105]

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

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

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

TEST() [74/105]

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

Definition at line 205 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(std::make_tuple(p, Short(2))));
}

TEST() [75/105]

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

Definition at line 275 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"), CharPtr("8"), CharPtr("9"),
                                      CharPtr("0"))));
}

TEST() [76/105]

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

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

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

TEST() [77/105]

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

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

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

TEST() [78/105]

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

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

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

TEST() [79/105]

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

Definition at line 241 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"))));
}

TEST() [80/105]

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

Definition at line 252 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(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
                                      CharPtr("7"), CharPtr("8"))));
}

TEST() [81/105]

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

Definition at line 263 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(std::make_tuple(
                             CharPtr("1"), CharPtr("2"), CharPtr("3"),
                             CharPtr("4"), CharPtr("5"), CharPtr("6"),
                             CharPtr("7"), CharPtr("8"), CharPtr("9"))));
}

TEST() [82/105]

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

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

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

TEST() [83/105]

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

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

                                               {
  Action<int(int, int, double, const std::string&)> a1 = Invoke(SumOfFirst2);
  std::tuple<int, int, double, std::string> dummy =
      std::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(std::make_tuple(20, 3, true, static_cast<int*>(nullptr))));
}

TEST() [84/105]

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

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

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

TEST() [85/105]

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

Definition at line 301 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(std::make_tuple(CharPtr("hi"), true, 10, 2)));
 
  Action<int(char, double, int, int)> a2 =
      Invoke(&foo, &Foo::SumOfLast2);
  EXPECT_EQ(23, a2.Perform(std::make_tuple('a', 2.5, 20, 3)));
}

TEST() [86/105]

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

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

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

TEST() [87/105]

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

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

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

TEST() [88/105]

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

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

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

TEST() [89/105]

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

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

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

TEST() [90/105]

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

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

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

TEST() [91/105]

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

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

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

TEST() [92/105]

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

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

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

TEST() [93/105]

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

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

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

TEST() [94/105]

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

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

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

TEST() [95/105]

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

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

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

TEST() [96/105]

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

Definition at line 479 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(std::make_tuple(&value));
  EXPECT_EQ(5, result);
}

TEST() [97/105]

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

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

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

TEST() [98/105]

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

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

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

TEST() [99/105]

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

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

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

TEST() [100/105]

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

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

                                            {
  using MyFunction = void(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(std::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(std::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() [101/105]

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

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

                                                               {
  using MyFunction = void(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(std::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() [102/105]

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

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

                                                          {
  using MyFunction = void(bool, int*);
  int numbers[] = { 1, 2, 3 };
  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
 
  int n[4] = {};
  int* pn = n;
  a.Perform(std::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() [103/105]

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

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

                                                                {
  using MyFunction = void(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(std::make_tuple(true, back_inserter(s)));
  EXPECT_EQ(letters, s);
}

TEST() [104/105]

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

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

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

TEST() [105/105]

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

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

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

Unary()

bool testing::gmock_more_actions_test::Unary

(

int

x

)

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

{ return x < 0; }

Variable Documentation

g_done

bool testing::gmock_more_actions_test::g_done = false

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

g_double

const double testing::gmock_more_actions_test::g_double = 0

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