aboutsummaryrefslogtreecommitdiffstats
path: root/include/gmock/gmock-generated-actions.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/gmock/gmock-generated-actions.h')
-rw-r--r--include/gmock/gmock-generated-actions.h890
1 files changed, 176 insertions, 714 deletions
diff --git a/include/gmock/gmock-generated-actions.h b/include/gmock/gmock-generated-actions.h
index 6d49c600..fa02faaa 100644
--- a/include/gmock/gmock-generated-actions.h
+++ b/include/gmock/gmock-generated-actions.h
@@ -443,264 +443,6 @@ class CallableHelper {
}; // class CallableHelper
-// Invokes a nullary callable argument.
-template <size_t N>
-class InvokeArgumentAction0 {
- public:
- template <typename Result, typename ArgumentTuple>
- static Result Perform(const ArgumentTuple& args) {
- return CallableHelper<Result>::Call(::std::tr1::get<N>(args));
- }
-};
-
-// Invokes a unary callable argument with the given argument.
-template <size_t N, typename A1>
-class InvokeArgumentAction1 {
- public:
- // We deliberately pass a1 by value instead of const reference here
- // in case it is a C-string literal.
- //
- // Since this function is defined inline, the compiler can get rid
- // of the copying of the arguments. Therefore the performance won't
- // be hurt.
- explicit InvokeArgumentAction1(A1 a1) : arg1_(a1) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_);
- }
- private:
- const A1 arg1_;
-};
-
-// Invokes a binary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2>
-class InvokeArgumentAction2 {
- public:
- InvokeArgumentAction2(A1 a1, A2 a2) :
- arg1_(a1), arg2_(a2) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
-};
-
-// Invokes a ternary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3>
-class InvokeArgumentAction3 {
- public:
- InvokeArgumentAction3(A1 a1, A2 a2, A3 a3) :
- arg1_(a1), arg2_(a2), arg3_(a3) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_,
- arg3_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
-};
-
-// Invokes a 4-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4>
-class InvokeArgumentAction4 {
- public:
- InvokeArgumentAction4(A1 a1, A2 a2, A3 a3, A4 a4) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_,
- arg3_, arg4_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
-};
-
-// Invokes a 5-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5>
-class InvokeArgumentAction5 {
- public:
- InvokeArgumentAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
-};
-
-// Invokes a 6-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6>
-class InvokeArgumentAction6 {
- public:
- InvokeArgumentAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
-};
-
-// Invokes a 7-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7>
-class InvokeArgumentAction7 {
- public:
- InvokeArgumentAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
- arg7_(a7) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
-};
-
-// Invokes a 8-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8>
-class InvokeArgumentAction8 {
- public:
- InvokeArgumentAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
- A8 a8) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
- arg7_(a7), arg8_(a8) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
-};
-
-// Invokes a 9-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9>
-class InvokeArgumentAction9 {
- public:
- InvokeArgumentAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
- A9 a9) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
- arg7_(a7), arg8_(a8), arg9_(a9) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_,
- arg9_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
- const A9 arg9_;
-};
-
-// Invokes a 10-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9,
- typename A10>
-class InvokeArgumentAction10 {
- public:
- InvokeArgumentAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
- A8 a8, A9 a9, A10 a10) :
- arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
- arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& args) {
- // We extract the callable to a variable before invoking it, in
- // case it is a functor passed by value and its operator() is not
- // const.
- typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
- ::std::tr1::get<N>(args);
- return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_,
- arg9_, arg10_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
- const A9 arg9_;
- const A10 arg10_;
-};
-
// An INTERNAL macro for extracting the type of a tuple field. It's
// subject to change without notice - DO NOT USE IN USER CODE!
#define GMOCK_FIELD_(Tuple, N) \
@@ -1140,140 +882,6 @@ inline internal::ReferenceWrapper<T> ByRef(T& l_value) { // NOLINT
return internal::ReferenceWrapper<T>(l_value);
}
-// Various overloads for InvokeArgument<N>().
-//
-// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
-// (0-based) argument, which must be a k-ary callable, of the mock
-// function, with arguments a1, a2, ..., a_k.
-//
-// Notes:
-//
-// 1. The arguments are passed by value by default. If you need to
-// pass an argument by reference, wrap it inside ByRef(). For
-// example,
-//
-// InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-// passes 5 and string("Hello") by value, and passes foo by
-// reference.
-//
-// 2. If the callable takes an argument by reference but ByRef() is
-// not used, it will receive the reference to a copy of the value,
-// instead of the original value. For example, when the 0-th
-// argument of the mock function takes a const string&, the action
-//
-// InvokeArgument<0>(string("Hello"))
-//
-// makes a copy of the temporary string("Hello") object and passes a
-// reference of the copy, instead of the original temporary object,
-// to the callable. This makes it easy for a user to define an
-// InvokeArgument action from temporary values and have it performed
-// later.
-template <size_t N>
-inline PolymorphicAction<internal::InvokeArgumentAction0<N> > InvokeArgument() {
- return MakePolymorphicAction(internal::InvokeArgumentAction0<N>());
-}
-
-// We deliberately pass a1 by value instead of const reference here in
-// case it is a C-string literal. If we had declared the parameter as
-// 'const A1& a1' and write InvokeArgument<0>("Hi"), the compiler
-// would've thought A1 is 'char[3]', which causes trouble as the
-// implementation needs to copy a value of type A1. By declaring the
-// parameter as 'A1 a1', the compiler will correctly infer that A1 is
-// 'const char*' when it sees InvokeArgument<0>("Hi").
-//
-// Since this function is defined inline, the compiler can get rid of
-// the copying of the arguments. Therefore the performance won't be
-// hurt.
-template <size_t N, typename A1>
-inline PolymorphicAction<internal::InvokeArgumentAction1<N, A1> >
-InvokeArgument(A1 a1) {
- return MakePolymorphicAction(internal::InvokeArgumentAction1<N, A1>(a1));
-}
-
-template <size_t N, typename A1, typename A2>
-inline PolymorphicAction<internal::InvokeArgumentAction2<N, A1, A2> >
-InvokeArgument(A1 a1, A2 a2) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction2<N, A1, A2>(a1, a2));
-}
-
-template <size_t N, typename A1, typename A2, typename A3>
-inline PolymorphicAction<internal::InvokeArgumentAction3<N, A1, A2, A3> >
-InvokeArgument(A1 a1, A2 a2, A3 a3) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction3<N, A1, A2, A3>(a1, a2, a3));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4>
-inline PolymorphicAction<internal::InvokeArgumentAction4<N, A1, A2, A3, A4> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction4<N, A1, A2, A3, A4>(a1, a2, a3, a4));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5>
-inline PolymorphicAction<internal::InvokeArgumentAction5<N, A1, A2, A3, A4,
- A5> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction5<N, A1, A2, A3, A4, A5>(a1, a2, a3, a4,
- a5));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6>
-inline PolymorphicAction<internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5,
- A6> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5, A6>(a1, a2, a3,
- a4, a5, a6));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7>
-inline PolymorphicAction<internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5,
- A6, A7> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5, A6, A7>(a1, a2,
- a3, a4, a5, a6, a7));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8>
-inline PolymorphicAction<internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5,
- A6, A7, A8> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5, A6, A7, A8>(a1,
- a2, a3, a4, a5, a6, a7, a8));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9>
-inline PolymorphicAction<internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5,
- A6, A7, A8, A9> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5, A6, A7, A8,
- A9>(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9,
- typename A10>
-inline PolymorphicAction<internal::InvokeArgumentAction10<N, A1, A2, A3, A4,
- A5, A6, A7, A8, A9, A10> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
- A10 a10) {
- return MakePolymorphicAction(
- internal::InvokeArgumentAction10<N, A1, A2, A3, A4, A5, A6, A7, A8, A9,
- A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
// WithoutArgs(inner_action) can be used in a mock function with a
// non-empty argument list to perform inner_action, which takes no
// argument. In other words, it adapts an action accepting no
@@ -2715,271 +2323,153 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
// updated.
namespace testing {
-namespace internal {
-
-// Saves argument #0 to where the pointer points.
-ACTION_P(SaveArg0, pointer) { *pointer = arg0; }
+// Various overloads for InvokeArgument<N>().
+//
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+// 1. The arguments are passed by value by default. If you need to
+// pass an argument by reference, wrap it inside ByRef(). For
+// example,
+//
+// InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+// passes 5 and string("Hello") by value, and passes foo by
+// reference.
+//
+// 2. If the callable takes an argument by reference but ByRef() is
+// not used, it will receive the reference to a copy of the value,
+// instead of the original value. For example, when the 0-th
+// argument of the mock function takes a const string&, the action
+//
+// InvokeArgument<0>(string("Hello"))
+//
+// makes a copy of the temporary string("Hello") object and passes a
+// reference of the copy, instead of the original temporary object,
+// to the callable. This makes it easy for a user to define an
+// InvokeArgument action from temporary values and have it performed
+// later.
-// Assigns 'value' to the variable referenced by argument #0.
-ACTION_P(SetArg0Referee, value) {
- // Ensures that argument #0 is a reference. If you get a compiler
- // error on the next line, you are using SetArgReferee<k>(value) in
- // a mock function whose k-th (0-based) argument is not a reference.
- GMOCK_COMPILE_ASSERT_(internal::is_reference<arg0_type>::value,
- SetArgReferee_must_be_used_with_a_reference_argument);
- arg0 = value;
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_0_VALUE_PARAMS()) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args));
}
-// ReturnNewAction<T> creates and returns a new instance of an object each time
-// it is performed. It is overloaded to work with constructors that take
-// different numbers of arguments.
-// Returns a new instance of T using a nullary constructor with the given
-// arguments.
-template <typename T>
-class ReturnNewAction0 {
- public:
- ReturnNewAction0() {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T();
- }
- private:
-};
-
-// Returns a new instance of T using a unary constructor with the given
-// arguments.
-template <typename T, typename A1>
-class ReturnNewAction1 {
- public:
- explicit ReturnNewAction1(A1 a1) : arg1_(a1) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_);
- }
- private:
- const A1 arg1_;
-};
-
-// Returns a new instance of T using a binary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2>
-class ReturnNewAction2 {
- public:
- ReturnNewAction2(A1 a1, A2 a2) : arg1_(a1), arg2_(a2) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
-};
-
-// Returns a new instance of T using a ternary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3>
-class ReturnNewAction3 {
- public:
- ReturnNewAction3(A1 a1, A2 a2, A3 a3) : arg1_(a1), arg2_(a2), arg3_(a3) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
-};
-
-// Returns a new instance of T using a 4-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4>
-class ReturnNewAction4 {
- public:
- ReturnNewAction4(A1 a1, A2 a2, A3 a3, A4 a4) : arg1_(a1), arg2_(a2),
- arg3_(a3), arg4_(a4) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
-};
-
-// Returns a new instance of T using a 5-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5>
-class ReturnNewAction5 {
- public:
- ReturnNewAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : arg1_(a1), arg2_(a2),
- arg3_(a3), arg4_(a4), arg5_(a5) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
-};
-
-// Returns a new instance of T using a 6-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6>
-class ReturnNewAction6 {
- public:
- ReturnNewAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : arg1_(a1),
- arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {}
-
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
-};
-
-// Returns a new instance of T using a 7-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7>
-class ReturnNewAction7 {
- public:
- ReturnNewAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
- A7 a7) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
- arg6_(a6), arg7_(a7) {}
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_1_VALUE_PARAMS(p0)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0);
+}
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_2_VALUE_PARAMS(p0, p1)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1);
+}
-// Returns a new instance of T using a 8-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8>
-class ReturnNewAction8 {
- public:
- ReturnNewAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
- A8 a8) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
- arg6_(a6), arg7_(a7), arg8_(a8) {}
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_3_VALUE_PARAMS(p0, p1, p2)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2);
+}
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3);
+}
-// Returns a new instance of T using a 9-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9>
-class ReturnNewAction9 {
- public:
- ReturnNewAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
- A9 a9) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
- arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9) {}
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4);
+}
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
- const A9 arg9_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5);
+}
-// Returns a new instance of T using a 10-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9,
- typename A10>
-class ReturnNewAction10 {
- public:
- ReturnNewAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
- A9 a9, A10 a10) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
- arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {}
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
+}
- template <typename Result, typename ArgumentTuple>
- Result Perform(const ArgumentTuple& /* args */) {
- return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_,
- arg10_);
- }
- private:
- const A1 arg1_;
- const A2 arg2_;
- const A3 arg3_;
- const A4 arg4_;
- const A5 arg5_;
- const A6 arg6_;
- const A7 arg7_;
- const A8 arg8_;
- const A9 arg9_;
- const A10 arg10_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
+}
-// Deletes the object pointed to by argument #0.
-ACTION(DeleteArg0) { delete arg0; }
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
-} // namespace internal
+ACTION_TEMPLATE(InvokeArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+ return internal::CallableHelper<return_type>::Call(
+ ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
// mock function to *pointer.
-template <int k, typename Pointer>
-inline internal::WithArgsAction<internal::SaveArg0ActionP<Pointer>, k>
-SaveArg(const Pointer& pointer) {
- return WithArg<k>(internal::SaveArg0(pointer));
+ACTION_TEMPLATE(SaveArg,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_1_VALUE_PARAMS(pointer)) {
+ *pointer = ::std::tr1::get<k>(args);
}
// Action SetArgReferee<k>(value) assigns 'value' to the variable
// referenced by the k-th (0-based) argument of the mock function.
-template <int k, typename Value>
-inline internal::WithArgsAction<internal::SetArg0RefereeActionP<Value>, k>
-SetArgReferee(const Value& value) {
- return WithArg<k>(internal::SetArg0Referee(value));
+ACTION_TEMPLATE(SetArgReferee,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_1_VALUE_PARAMS(value)) {
+ typedef typename ::std::tr1::tuple_element<k, args_type>::type argk_type;
+ // Ensures that argument #k is a reference. If you get a compiler
+ // error on the next line, you are using SetArgReferee<k>(value) in
+ // a mock function whose k-th (0-based) argument is not a reference.
+ GMOCK_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+ SetArgReferee_must_be_used_with_a_reference_argument);
+ ::std::tr1::get<k>(args) = value;
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+ACTION_TEMPLATE(SetArrayArgument,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_2_VALUE_PARAMS(first, last)) {
+ // Microsoft compiler deprecates ::std::copy, so we want to suppress warning
+ // 4996 (Function call with parameters that may be unsafe) there.
+#ifdef _MSC_VER
+#pragma warning(push) // Saves the current warning state.
+#pragma warning(disable:4996) // Temporarily disables warning 4996.
+#endif
+ ::std::copy(first, last, ::std::tr1::get<k>(args));
+#ifdef _MSC_VER
+#pragma warning(pop) // Restores the warning state.
+#endif
}
// Various overloads for ReturnNew<T>().
@@ -2987,106 +2477,78 @@ SetArgReferee(const Value& value) {
// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
// instance of type T, constructed on the heap with constructor arguments
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
-template <typename T>
-inline PolymorphicAction<internal::ReturnNewAction0<T> >
-ReturnNew() {
- return MakePolymorphicAction(
- internal::ReturnNewAction0<T>());
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_0_VALUE_PARAMS()) {
+ return new T();
}
-template <typename T, typename A1>
-inline PolymorphicAction<internal::ReturnNewAction1<T, A1> >
-ReturnNew(A1 a1) {
- return MakePolymorphicAction(
- internal::ReturnNewAction1<T, A1>(a1));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_1_VALUE_PARAMS(p0)) {
+ return new T(p0);
}
-template <typename T, typename A1, typename A2>
-inline PolymorphicAction<internal::ReturnNewAction2<T, A1, A2> >
-ReturnNew(A1 a1, A2 a2) {
- return MakePolymorphicAction(
- internal::ReturnNewAction2<T, A1, A2>(a1, a2));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_2_VALUE_PARAMS(p0, p1)) {
+ return new T(p0, p1);
}
-template <typename T, typename A1, typename A2, typename A3>
-inline PolymorphicAction<internal::ReturnNewAction3<T, A1, A2, A3> >
-ReturnNew(A1 a1, A2 a2, A3 a3) {
- return MakePolymorphicAction(
- internal::ReturnNewAction3<T, A1, A2, A3>(a1, a2, a3));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_3_VALUE_PARAMS(p0, p1, p2)) {
+ return new T(p0, p1, p2);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4>
-inline PolymorphicAction<internal::ReturnNewAction4<T, A1, A2, A3, A4> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4) {
- return MakePolymorphicAction(
- internal::ReturnNewAction4<T, A1, A2, A3, A4>(a1, a2, a3, a4));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+ return new T(p0, p1, p2, p3);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5>
-inline PolymorphicAction<internal::ReturnNewAction5<T, A1, A2, A3, A4, A5> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
- return MakePolymorphicAction(
- internal::ReturnNewAction5<T, A1, A2, A3, A4, A5>(a1, a2, a3, a4, a5));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+ return new T(p0, p1, p2, p3, p4);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6>
-inline PolymorphicAction<internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
- return MakePolymorphicAction(
- internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6>(a1, a2, a3, a4, a5,
- a6));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+ return new T(p0, p1, p2, p3, p4, p5);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7>
-inline PolymorphicAction<internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6,
- A7> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
- return MakePolymorphicAction(
- internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6, A7>(a1, a2, a3, a4,
- a5, a6, a7));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+ return new T(p0, p1, p2, p3, p4, p5, p6);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8>
-inline PolymorphicAction<internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6,
- A7, A8> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
- return MakePolymorphicAction(
- internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6, A7, A8>(a1, a2, a3,
- a4, a5, a6, a7, a8));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+ return new T(p0, p1, p2, p3, p4, p5, p6, p7);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9>
-inline PolymorphicAction<internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6,
- A7, A8, A9> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
- return MakePolymorphicAction(
- internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a1, a2,
- a3, a4, a5, a6, a7, a8, a9));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+ return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
-template <typename T, typename A1, typename A2, typename A3, typename A4,
- typename A5, typename A6, typename A7, typename A8, typename A9,
- typename A10>
-inline PolymorphicAction<internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6,
- A7, A8, A9, A10> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
- A10 a10) {
- return MakePolymorphicAction(
- internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6, A7, A8, A9,
- A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
+ACTION_TEMPLATE(ReturnNew,
+ HAS_1_TEMPLATE_PARAMS(typename, T),
+ AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+ return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}
// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
// function.
-template <int k>
-inline internal::WithArgsAction<internal::DeleteArg0Action, k>
-DeleteArg() {
- return WithArg<k>(internal::DeleteArg0());
+ACTION_TEMPLATE(DeleteArg,
+ HAS_1_TEMPLATE_PARAMS(int, k),
+ AND_0_VALUE_PARAMS()) {
+ delete ::std::tr1::get<k>(args);
}
// Action Throw(exception) can be used in a mock function of any type
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-02 22:46:33 +0000