testing::gmock_generated_actions_test Namespace Reference

Namespaces
	action_test

Classes
class	BoolResetter
struct	GiantTemplate
class	NullaryConstructorClass
class	NullaryFunctor
class	SubstractAction
struct	SumOf5Functor
struct	SumOf6Functor
class	TenArgConstructorClass
class	UnaryConstructorClass
struct	UnaryFunctor

Functions
short	Short (short n)
char	Char (char ch)
int	Nullary ()
bool	Unary (int x)
const char *	Plus1 (const char *s)
bool	ByConstRef (const string &s)
bool	ReferencesGlobalDouble (const double &x)
string	ByNonConstRef (string &s)
const char *	Binary (const char *input, short n)
void	VoidBinary (int, char)
int	Ternary (int x, char y, short z)
void	VoidTernary (int, char, bool)
int	SumOf4 (int a, int b, int c, int d)
string	Concat4 (const char *s1, const char *s2, const char *s3, const char *s4)
int	SumOf5 (int a, int b, int c, int d, int e)
string	Concat5 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5)
int	SumOf6 (int a, int b, int c, int d, int e, int f)
string	Concat6 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6)
string	Concat7 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7)
string	Concat8 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8)
string	Concat9 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8, const char *s9)
string	Concat10 (const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7, const char *s8, const char *s9, const char *s10)
const char *	CharPtr (const char *s)
	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 (WithArgsTest, OneArg)
	TEST (WithArgsTest, TwoArgs)
	TEST (WithArgsTest, ThreeArgs)
	TEST (WithArgsTest, FourArgs)
	TEST (WithArgsTest, FiveArgs)
	TEST (WithArgsTest, SixArgs)
	TEST (WithArgsTest, SevenArgs)
	TEST (WithArgsTest, EightArgs)
	TEST (WithArgsTest, NineArgs)
	TEST (WithArgsTest, TenArgs)
	TEST (WithArgsTest, NonInvokeAction)
	TEST (WithArgsTest, Identity)
	TEST (WithArgsTest, RepeatedArguments)
	TEST (WithArgsTest, ReversedArgumentOrder)
	TEST (WithArgsTest, ArgsOfCompatibleTypes)
	TEST (WithArgsTest, VoidAction)
	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)
	ACTION (Return5)
	TEST (ActionMacroTest, WorksWhenNotReferencingArguments)
	ACTION (IncrementArg1)
	TEST (ActionMacroTest, WorksWhenReturningVoid)
	ACTION (IncrementArg2)
	TEST (ActionMacroTest, CanReferenceArgumentType)
	ACTION (Sum2)
	TEST (ActionMacroTest, CanReferenceArgumentTuple)
int	Dummy (bool flag)
	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)
	TEST (ReturnNewTest, NoArgs)
	TEST (ReturnNewTest, Unary)
	TEST (ReturnNewTest, UnaryWorksWhenMockMethodHasArgs)
	TEST (ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst)
	TEST (ReturnNewTest, ConstructorThatTakes10Arguments)
	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

testing::gmock_generated_actions_test::ACTION

(

Return5

)

Definition at line 605 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::GiantTemplate< T1, T2, T3, k4, k5, k6, T7, T8, T9 >::GiantTemplate(), and testing::gmock_generated_actions_test::SubstractAction::Perform().

{ return 5; }

testing::gmock_generated_actions_test::ACTION

(

IncrementArg1

)

Definition at line 616 of file gmock-generated-actions_test.cc.

{ (*arg1)++; }

testing::gmock_generated_actions_test::ACTION

(

IncrementArg2

)

Definition at line 627 of file gmock-generated-actions_test.cc.

References shell_builder::temp.

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

testing::gmock_generated_actions_test::ACTION

(

Sum2

)

Definition at line 642 of file gmock-generated-actions_test.cc.

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

testing::gmock_generated_actions_test::ACTION

(

InvokeDummy

)

Definition at line 658 of file gmock-generated-actions_test.cc.

References Dummy().

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

testing::gmock_generated_actions_test::ACTION

(

InvokeDummy2

)

Definition at line 672 of file gmock-generated-actions_test.cc.

References Dummy().

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

testing::gmock_generated_actions_test::ACTION

(

ReturnAddrOfConstBoolReferenceArg

)

Definition at line 685 of file gmock-generated-actions_test.cc.

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

testing::gmock_generated_actions_test::ACTION

(

ReturnAddrOfIntReferenceArg

)

Definition at line 697 of file gmock-generated-actions_test.cc.

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

testing::gmock_generated_actions_test::ACTION

(

PlusTwo

)

Definition at line 720 of file gmock-generated-actions_test.cc.

{ return arg0 + 2; }

testing::gmock_generated_actions_test::ACTION

(

OverloadedAction

)

Definition at line 763 of file gmock-generated-actions_test.cc.

{ return arg0 ? arg1 : "hello"; }

testing::gmock_generated_actions_test::ACTION

(

DoFoo

)

Definition at line 936 of file gmock-generated-actions_test.cc.

{}

testing::gmock_generated_actions_test::ACTION

(

ReturnSum

)

Definition at line 1188 of file gmock-generated-actions_test.cc.

{ return 0; }

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

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

Referenced by testing::gmock_generated_actions_test::GiantTemplate< T1, T2, T3, k4, k5, k6, T7, T8, T9 >::GiantTemplate(), and testing::gmock_generated_actions_test::SubstractAction::Perform().

{ return arg0 + n; }

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

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

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

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

Definition at line 765 of file gmock-generated-actions_test.cc.

                                          {
  return arg0 ? arg1 : default_value;
}

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

Definition at line 937 of file gmock-generated-actions_test.cc.

{}

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

Definition at line 980 of file gmock-generated-actions_test.cc.

References x.

{ return x; }

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

Definition at line 1190 of file gmock-generated-actions_test.cc.

References x.

{ return x; }

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

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

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 983 of file gmock-generated-actions_test.cc.

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

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

Definition at line 769 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

                                                     {
  return arg0 ? true_value : false_value;
}

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

Definition at line 866 of file gmock-generated-actions_test.cc.

References prefix(), string, and suffix.

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

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

Definition at line 938 of file gmock-generated-actions_test.cc.

{}

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

Definition at line 981 of file gmock-generated-actions_test.cc.

{ return x + y; }

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

Definition at line 791 of file gmock-generated-actions_test.cc.

References k, and m.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

{ return arg0 + m + n + k; }

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

Definition at line 887 of file gmock-generated-actions_test.cc.

References a, b, and c.

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

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

Definition at line 982 of file gmock-generated-actions_test.cc.

{ return x + y + z; }

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

Definition at line 802 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 809 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 816 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

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

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 834 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 843 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform().

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

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

Definition at line 1072 of file gmock-generated-actions_test.cc.

References T.

Referenced by testing::gmock_generated_actions_test::GiantTemplate< T1, T2, T3, k4, k5, k6, T7, T8, T9 >::GiantTemplate(), testing::gmock_generated_actions_test::TenArgConstructorClass::TenArgConstructorClass(), and testing::gmock_generated_actions_test::BoolResetter::~BoolResetter().

                                      {
  return new T;
}

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

Definition at line 1085 of file gmock-generated-actions_test.cc.

References T.

                                        {
  return new T(a0);
}

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

Definition at line 1099 of file gmock-generated-actions_test.cc.

                                      {
  delete get<k>(args);
}

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

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

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

testing::gmock_generated_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 1147 of file gmock-generated-actions_test.cc.

References value.

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

testing::gmock_generated_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 1174 of file gmock-generated-actions_test.cc.

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

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

Definition at line 1192 of file gmock-generated-actions_test.cc.

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

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

Definition at line 1198 of file gmock-generated-actions_test.cc.

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

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

Definition at line 1204 of file gmock-generated-actions_test.cc.

References k.

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

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

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

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), testing::internal::ExpectationTester::SetCallCount(), and TEST().

{ return input + n; }  // NOLINT

bool testing::gmock_generated_actions_test::ByConstRef

(

const string &

s

)

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

Referenced by testing::gmock_generated_actions_test::NullaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

{ return s == "Hi"; }

string testing::gmock_generated_actions_test::ByNonConstRef

(

string &

s

)

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

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

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

char testing::gmock_generated_actions_test::Char ( char  ch )

inline

Definition at line 68 of file gmock-generated-actions_test.cc.

References ch.

Referenced by folly::BasicFixedString< Char, N >::append(), folly::BasicFixedString< Char, N >::assign(), folly::BasicFixedString< Char, N >::BasicFixedString(), folly::fbstring_core< char >::c_str(), folly::BasicFixedString< Char, N >::cappend(), folly::BasicFixedString< Char, N >::cerase(), folly::detail::fixedstring::char_at_(), folly::detail::fixedstring::checkNullTerminated(), folly::BasicFixedString< Char, N >::clear(), folly::detail::fixedstring::Helper::concat_(), folly::detail::constexpr_strlen_internal(), folly::fbstring_core< Char >::copyMedium(), folly::fbstring_core< Char >::RefCounted::create(), folly::BasicFixedString< Char, N >::creplace(), folly::BasicFixedString< Char, N >::erase(), folly::fbstring_core< char >::fbstring_core(), folly::fbstring_core< Char >::initMedium(), folly::fbstring_core< Char >::initSmall(), folly::dummy_fbstring_core< Char >::mutableData(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), folly::BasicFixedString< Char, N >::operator=(), testing::gmock_generated_actions_test::SubstractAction::Perform(), folly::BasicFixedString< Char, N >::pop_back(), testing::internal::PrintAsStringLiteralTo(), folly::BasicFixedString< Char, N >::push_back(), folly::fbstring_core< Char >::RefCounted::reallocate(), folly::detail::fixedstring::Helper::replace_(), folly::fbstring_core< char >::reserve(), folly::fbstring_core< Char >::reserveMedium(), folly::fbstring_core< Char >::reserveSmall(), folly::BasicFixedString< Char, N >::resize(), folly::fbstring_core< char >::setSmallSize(), TEST(), and testing::TEST().

{ return ch; }

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

inline

Definition at line 165 of file gmock-generated-actions_test.cc.

References s.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

{ return s; }

template<typename T1 , typename T2 >

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

Definition at line 903 of file gmock-generated-actions_test.cc.

References a, b, c, GTEST_INTENTIONAL_CONST_COND_POP_, and GTEST_INTENTIONAL_CONST_COND_PUSH_.

Referenced by testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

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

template<typename T1 , typename T2 >

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

Definition at line 922 of file gmock-generated-actions_test.cc.

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

string testing::gmock_generated_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 156 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

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

Definition at line 105 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

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

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

References string.

Referenced by testing::gmock_generated_actions_test::SumOf5Functor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

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

Definition at line 133 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

string testing::gmock_generated_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 138 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

string testing::gmock_generated_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 144 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

string testing::gmock_generated_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 150 of file gmock-generated-actions_test.cc.

References string.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

int testing::gmock_generated_actions_test::Dummy

(

bool

flag

)

Definition at line 656 of file gmock-generated-actions_test.cc.

Referenced by ACTION(), testing::internal::UnitTestHelper::GetSortedTests(), and testing::gmock_generated_actions_test::SubstractAction::Perform().

{ return flag? 1 : 0; }

int testing::gmock_generated_actions_test::Nullary

(

)

Definition at line 71 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

{ return 1; }

const char * testing::gmock_generated_actions_test::Plus1

(

const char *

s

)

Definition at line 82 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::NullaryFunctor::operator()(), and testing::gmock_generated_actions_test::SubstractAction::Perform().

{ return s + 1; }

bool testing::gmock_generated_actions_test::ReferencesGlobalDouble

(

const double &

x

)

Definition at line 87 of file gmock-generated-actions_test.cc.

References g_double.

Referenced by testing::gmock_generated_actions_test::NullaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

{ return &x == &g_double; }

short testing::gmock_generated_actions_test::Short ( short  n )

inline

Definition at line 67 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

{ return n; }  // NOLINT

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

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

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

{ return a + b + c + d; }

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

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

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

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

Definition at line 123 of file gmock-generated-actions_test.cc.

References f.

Referenced by testing::gmock_generated_actions_test::SumOf5Functor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), and TEST().

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

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

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

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

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

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

Definition at line 170 of file gmock-generated-actions_test.cc.

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

Referenced by testing::gmock_generated_actions_test::GiantTemplate< T1, T2, T3, k4, k5, k6, T7, T8, T9 >::GiantTemplate(), testing::gmock_generated_actions_test::NullaryConstructorClass::NullaryConstructorClass(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), testing::gmock_generated_actions_test::TenArgConstructorClass::TenArgConstructorClass(), testing::gmock_generated_actions_test::UnaryConstructorClass::UnaryConstructorClass(), and testing::gmock_generated_actions_test::BoolResetter::~BoolResetter().

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

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

Definition at line 176 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 182 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 189 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 196 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 203 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 210 of file gmock-generated-actions_test.cc.

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

                                    {
  Action<string(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(make_tuple(&Concat7)));
}

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

Definition at line 219 of file gmock-generated-actions_test.cc.

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

                                    {
  Action<string(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(make_tuple(&Concat8)));
}

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

Definition at line 228 of file gmock-generated-actions_test.cc.

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

                                    {
  Action<string(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(make_tuple(&Concat9)));
}

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

Definition at line 237 of file gmock-generated-actions_test.cc.

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

                                     {
  Action<string(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(make_tuple(&Concat10)));
}

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

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

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

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

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

Definition at line 255 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 262 of file gmock-generated-actions_test.cc.

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

                                                   {
  Action<bool(bool(*function)(const string& s))> a =  // NOLINT
      InvokeArgument<0>(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(make_tuple(&ByConstRef)));
}

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

Definition at line 273 of file gmock-generated-actions_test.cc.

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

                                                           {
  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(make_tuple(&ReferencesGlobalDouble)));

  double x = 0;
  a = InvokeArgument<0>(ByRef(x));  // This calls ByRef() on a non-const.
  EXPECT_FALSE(a.Perform(make_tuple(&ReferencesGlobalDouble)));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		OneArg
	)

Definition at line 285 of file gmock-generated-actions_test.cc.

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

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

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		TwoArgs
	)

Definition at line 292 of file gmock-generated-actions_test.cc.

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

                            {
  Action<const char*(const char* s, double x, short n)> a =
      WithArgs<0, 2>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		ThreeArgs
	)

Definition at line 300 of file gmock-generated-actions_test.cc.

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

                              {
  Action<int(int, double, char, short)> a =  // NOLINT
      WithArgs<0, 2, 3>(Invoke(Ternary));
  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		FourArgs
	)

Definition at line 307 of file gmock-generated-actions_test.cc.

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

                             {
  Action<string(const char*, const char*, double, const char*, const char*)> a =
      WithArgs<4, 3, 1, 0>(Invoke(Concat4));
  EXPECT_EQ("4310", a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), 2.5,
                                         CharPtr("3"), CharPtr("4"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		FiveArgs
	)

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

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

                             {
  Action<string(const char*, const char*, const char*,
                const char*, const char*)> a =
      WithArgs<4, 3, 2, 1, 0>(Invoke(Concat5));
  EXPECT_EQ("43210",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                 CharPtr("3"), CharPtr("4"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		SixArgs
	)

Definition at line 325 of file gmock-generated-actions_test.cc.

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

                            {
  Action<string(const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 2, 1, 0>(Invoke(Concat6));
  EXPECT_EQ("012210",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		SevenArgs
	)

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

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

                              {
  Action<string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 2, 1, 0>(Invoke(Concat7));
  EXPECT_EQ("0123210",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                 CharPtr("3"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		EightArgs
	)

Definition at line 342 of file gmock-generated-actions_test.cc.

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

                              {
  Action<string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 0, 1, 2, 3>(Invoke(Concat8));
  EXPECT_EQ("01230123",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                 CharPtr("3"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		NineArgs
	)

Definition at line 351 of file gmock-generated-actions_test.cc.

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

                             {
  Action<string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 1, 2, 3, 2, 3>(Invoke(Concat9));
  EXPECT_EQ("012312323",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                 CharPtr("3"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		TenArgs
	)

Definition at line 360 of file gmock-generated-actions_test.cc.

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

                            {
  Action<string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(Concat10));
  EXPECT_EQ("0123210123",
            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                 CharPtr("3"))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		NonInvokeAction
	)

Definition at line 376 of file gmock-generated-actions_test.cc.

References a, EXPECT_EQ, testing::MakeAction(), testing::Action< F >::Perform(), and s.

                                    {
  Action<int(const string&, int, int)> a =  // NOLINT
      WithArgs<2, 1>(MakeAction(new SubstractAction));
  string s("hello");
  EXPECT_EQ(8, a.Perform(tuple<const string&, int, int>(s, 2, 10)));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		Identity
	)

Definition at line 384 of file gmock-generated-actions_test.cc.

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

                             {
  Action<int(int x, char y, short z)> a =  // NOLINT
      WithArgs<0, 1, 2>(Invoke(Ternary));
  EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		RepeatedArguments
	)

Definition at line 391 of file gmock-generated-actions_test.cc.

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

                                      {
  Action<int(bool, int m, int n)> a =  // NOLINT
      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
  EXPECT_EQ(4, a.Perform(make_tuple(false, 1, 10)));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		ReversedArgumentOrder
	)

Definition at line 398 of file gmock-generated-actions_test.cc.

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

                                          {
  Action<const char*(short n, const char* input)> a =  // NOLINT
      WithArgs<1, 0>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		ArgsOfCompatibleTypes
	)

Definition at line 406 of file gmock-generated-actions_test.cc.

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

                                          {
  Action<long(short x, char y, double z, char c)> a =  // NOLINT
      WithArgs<0, 1, 3>(Invoke(Ternary));
  EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
}

testing::gmock_generated_actions_test::TEST	(	WithArgsTest	,
		VoidAction
	)

Definition at line 413 of file gmock-generated-actions_test.cc.

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

                               {
  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
  g_done = false;
  a.Perform(make_tuple(1.5, 'a', 3));
  EXPECT_TRUE(g_done);
}

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

Definition at line 421 of file gmock-generated-actions_test.cc.

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

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

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

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

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

                              {
  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(make_tuple(&m, &n)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
}

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

Definition at line 441 of file gmock-generated-actions_test.cc.

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

                             {
  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(make_tuple(&m, &n, &ch)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', ch);
}

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

Definition at line 456 of file gmock-generated-actions_test.cc.

References a, upload::action, b, testing::DoAll(), EXPECT_EQ, m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

                             {
  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(make_tuple(&m, &n, &a, &b)));
  EXPECT_EQ(1, m);
  EXPECT_EQ(2, n);
  EXPECT_EQ('a', a);
  EXPECT_EQ('b', b);
}

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

Definition at line 473 of file gmock-generated-actions_test.cc.

References a, upload::action, b, c, testing::DoAll(), EXPECT_EQ, m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

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

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

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

References a, upload::action, b, c, testing::DoAll(), EXPECT_EQ, m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

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

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

Definition at line 513 of file gmock-generated-actions_test.cc.

References a, upload::action, b, c, testing::DoAll(), EXPECT_EQ, m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

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

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

Definition at line 537 of file gmock-generated-actions_test.cc.

References a, upload::action, b, c, testing::DoAll(), EXPECT_EQ, f, m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

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

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

Definition at line 563 of file gmock-generated-actions_test.cc.

References a, upload::action, b, c, testing::DoAll(), EXPECT_EQ, f, g(), m, std::tr1::make_tuple(), testing::Action< F >::Perform(), and testing::Return().

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

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

Definition at line 607 of file gmock-generated-actions_test.cc.

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

                                                        {
  Action<double()> a1 = Return5();
  EXPECT_DOUBLE_EQ(5, a1.Perform(make_tuple()));

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

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

Definition at line 618 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 633 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 648 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 664 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 678 of file gmock-generated-actions_test.cc.

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

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

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

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

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

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

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

Definition at line 702 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 713 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 722 of file gmock-generated-actions_test.cc.

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

                                                        {
  Action<int(int)> a1 = PlusTwo();
  EXPECT_EQ(4, a1.Perform(make_tuple(2)));

  Action<double(float, void*)> a2 = PlusTwo();
  int dummy;
  EXPECT_DOUBLE_EQ(6, a2.Perform(make_tuple(4.0f, &dummy)));
}

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

Definition at line 734 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 747 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 754 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 773 of file gmock-generated-actions_test.cc.

References CharPtr(), EXPECT_STREQ, and std::tr1::make_tuple().

                                                  {
  typedef Action<const char*(bool, const char*)> MyAction;

  const MyAction a1 = OverloadedAction();
  EXPECT_STREQ("hello", a1.Perform(make_tuple(false, CharPtr("world"))));
  EXPECT_STREQ("world", a1.Perform(make_tuple(true, CharPtr("world"))));

  const MyAction a2 = OverloadedAction("hi");
  EXPECT_STREQ("hi", a2.Perform(make_tuple(false, CharPtr("world"))));
  EXPECT_STREQ("world", a2.Perform(make_tuple(true, CharPtr("world"))));

  const MyAction a3 = OverloadedAction("hi", "you");
  EXPECT_STREQ("hi", a3.Perform(make_tuple(true, CharPtr("world"))));
  EXPECT_STREQ("you", a3.Perform(make_tuple(false, CharPtr("world"))));
}

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

Definition at line 793 of file gmock-generated-actions_test.cc.

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

                                             {
  Action<double(int m, bool t)> a1 = Plus(100, 20, 3.4);
  EXPECT_DOUBLE_EQ(3123.4, a1.Perform(make_tuple(3000, true)));

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

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

Definition at line 804 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 811 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 820 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 829 of file gmock-generated-actions_test.cc.

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

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

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

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

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

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

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

Definition at line 847 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 858 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 873 of file gmock-generated-actions_test.cc.

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

                                             {
  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(make_tuple(CharPtr("ba"))));
  EXPECT_EQ("foobar", promo.Perform(make_tuple(CharPtr("ba"))));
}

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

Definition at line 926 of file gmock-generated-actions_test.cc.

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

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

  a1 = Concat(1, 2, 3);
  EXPECT_EQ("123", a1.Perform(make_tuple()));
}

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

Definition at line 940 of file gmock-generated-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;
}

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

Definition at line 987 of file gmock-generated-actions_test.cc.

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

                                                                    {
  int x = 1, y = 2, z = 3;
  const tuple<> empty = 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));
}

testing::gmock_generated_actions_test::TEST	(	ReturnNewTest	,
		NoArgs
	)

Definition at line 1014 of file gmock-generated-actions_test.cc.

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

                            {
  Action<NullaryConstructorClass*()> a = ReturnNew<NullaryConstructorClass>();
  NullaryConstructorClass* c = a.Perform(make_tuple());
  EXPECT_EQ(123, c->value_);
  delete c;
}

testing::gmock_generated_actions_test::TEST	(	ReturnNewTest	,
		Unary
	)

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

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

                           {
  Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
  UnaryConstructorClass* c = a.Perform(make_tuple());
  EXPECT_EQ(4000, c->value_);
  delete c;
}

testing::gmock_generated_actions_test::TEST	(	ReturnNewTest	,
		UnaryWorksWhenMockMethodHasArgs
	)

Definition at line 1035 of file gmock-generated-actions_test.cc.

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

                                                     {
  Action<UnaryConstructorClass*(bool, int)> a =
      ReturnNew<UnaryConstructorClass>(4000);
  UnaryConstructorClass* c = a.Perform(make_tuple(false, 5));
  EXPECT_EQ(4000, c->value_);
  delete c;
}

testing::gmock_generated_actions_test::TEST	(	ReturnNewTest	,
		UnaryWorksWhenMockMethodReturnsPointerToConst
	)

Definition at line 1043 of file gmock-generated-actions_test.cc.

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

                                                                   {
  Action<const UnaryConstructorClass*()> a =
      ReturnNew<UnaryConstructorClass>(4000);
  const UnaryConstructorClass* c = a.Perform(make_tuple());
  EXPECT_EQ(4000, c->value_);
  delete c;
}

testing::gmock_generated_actions_test::TEST	(	ReturnNewTest	,
		ConstructorThatTakes10Arguments
	)

Definition at line 1061 of file gmock-generated-actions_test.cc.

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

                                                     {
  Action<TenArgConstructorClass*()> a =
      ReturnNew<TenArgConstructorClass>(1000000000, 200000000, 30000000,
                                        4000000, 500000, 60000,
                                        7000, 800, 90, 0);
  TenArgConstructorClass* c = a.Perform(make_tuple());
  EXPECT_EQ(1234567890, c->value_);
  delete c;
}

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

Definition at line 1078 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 1091 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 1114 of file gmock-generated-actions_test.cc.

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

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

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

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

References a, EXPECT_EQ, and std::tr1::make_tuple().

                                                             {
  using ::testing::internal::linked_ptr;
  const Action<linked_ptr<int>()> a = ReturnSmartPointer<linked_ptr>(42);
  linked_ptr<int> p = a.Perform(make_tuple());
  EXPECT_EQ(42, *p);
}

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

Definition at line 1163 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 1180 of file gmock-generated-actions_test.cc.

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

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

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

Definition at line 1210 of file gmock-generated-actions_test.cc.

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

                                                                   {
  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(make_tuple()));
  EXPECT_EQ(1, a1.Perform(make_tuple()));
  EXPECT_EQ(3, a2.Perform(make_tuple()));
  EXPECT_EQ(6, a3.Perform(make_tuple()));
  EXPECT_EQ(12345, a4.Perform(make_tuple()));
}

bool testing::gmock_generated_actions_test::Unary

(

int

x

)

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

Referenced by testing::gmock_generated_actions_test::NullaryFunctor::operator()(), testing::gmock_generated_actions_test::SumOf6Functor::operator()(), TEST(), and testing::gmock_generated_actions_test::UnaryConstructorClass::UnaryConstructorClass().

{ return x < 0; }

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

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

Referenced by testing::gmock_generated_actions_test::UnaryFunctor::operator()(), testing::gmock_generated_actions_test::SubstractAction::Perform(), and TEST().

{ g_done = true; }

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

Definition at line 101 of file gmock-generated-actions_test.cc.

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

{ g_done = true; }

Variable Documentation

bool testing::gmock_generated_actions_test::g_done = false

Definition at line 78 of file gmock-generated-actions_test.cc.

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

const double testing::gmock_generated_actions_test::g_double = 0

Definition at line 86 of file gmock-generated-actions_test.cc.

Referenced by testing::gmock_generated_actions_test::NullaryFunctor::operator()(), and ReferencesGlobalDouble().