diff options
Diffstat (limited to 'include/gmock/gmock-generated-actions.h')
| -rw-r--r-- | include/gmock/gmock-generated-actions.h | 1329 |
1 files changed, 1329 insertions, 0 deletions
diff --git a/include/gmock/gmock-generated-actions.h b/include/gmock/gmock-generated-actions.h new file mode 100644 index 00000000..ec696b30 --- /dev/null +++ b/include/gmock/gmock-generated-actions.h @@ -0,0 +1,1329 @@ +// This file was GENERATED by a script. DO NOT EDIT BY HAND!!! + +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Google Mock - a framework for writing C++ mock classes. +// +// This file implements some commonly used variadic actions. + +#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ +#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ + +#include <gmock/gmock-actions.h> +#include <gmock/internal/gmock-port.h> + +namespace testing { +namespace internal { + +// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary +// function or method with the unpacked values, where F is a function +// type that takes N arguments. +template <typename Result, typename ArgumentTuple> +class InvokeHelper; + +template <typename R> +class InvokeHelper<R, ::std::tr1::tuple<> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<>&) { + return function(); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<>&) { + return (obj_ptr->*method_ptr)(); + } +}; + +template <typename R, typename A1> +class InvokeHelper<R, ::std::tr1::tuple<A1> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1>& args) { + using ::std::tr1::get; + return function(get<0>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args)); + } +}; + +template <typename R, typename A1, typename A2> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, + A3>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, + A4>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5, typename A6> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5, A6>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args), get<5>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args), get<5>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5, typename A6, typename A7> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5, A6, A7>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args), get<5>(args), get<6>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, + A7>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args), get<5>(args), get<6>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5, typename A6, typename A7, typename A8> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5, A6, A7, A8>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args), get<5>(args), get<6>(args), get<7>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, + A8>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5, typename A6, typename A7, typename A8, typename A9> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5, A6, A7, A8, A9>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, + A9>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args), + get<8>(args)); + } +}; + +template <typename R, typename A1, typename A2, typename A3, typename A4, + typename A5, typename A6, typename A7, typename A8, typename A9, + typename A10> +class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9, + A10> > { + public: + template <typename Function> + static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, + A5, A6, A7, A8, A9, A10>& args) { + using ::std::tr1::get; + return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), + get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), + get<9>(args)); + } + + template <class Class, typename MethodPtr> + static R InvokeMethod(Class* obj_ptr, + MethodPtr method_ptr, + const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, + A9, A10>& args) { + using ::std::tr1::get; + return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), + get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args), + get<8>(args), get<9>(args)); + } +}; + + +// Implements the Invoke(f) action. The template argument +// FunctionImpl is the implementation type of f, which can be either a +// function pointer or a functor. Invoke(f) can be used as an +// Action<F> as long as f's type is compatible with F (i.e. f can be +// assigned to a tr1::function<F>). +template <typename FunctionImpl> +class InvokeAction { + public: + // The c'tor makes a copy of function_impl (either a function + // pointer or a functor). + explicit InvokeAction(FunctionImpl function_impl) + : function_impl_(function_impl) {} + + template <typename Result, typename ArgumentTuple> + Result Perform(const ArgumentTuple& args) { + return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args); + } + private: + FunctionImpl function_impl_; +}; + +// Implements the Invoke(object_ptr, &Class::Method) action. +template <class Class, typename MethodPtr> +class InvokeMethodAction { + public: + InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr) + : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {} + + template <typename Result, typename ArgumentTuple> + Result Perform(const ArgumentTuple& args) const { + return InvokeHelper<Result, ArgumentTuple>::InvokeMethod( + obj_ptr_, method_ptr_, args); + } + private: + Class* const obj_ptr_; + const MethodPtr method_ptr_; +}; + +// A ReferenceWrapper<T> object represents a reference to type T, +// which can be either const or not. It can be explicitly converted +// from, and implicitly converted to, a T&. Unlike a reference, +// ReferenceWrapper<T> can be copied and can survive template type +// inference. This is used to support by-reference arguments in the +// InvokeArgument<N>(...) action. The idea was from "reference +// wrappers" in tr1, which we don't have in our source tree yet. +template <typename T> +class ReferenceWrapper { + public: + // Constructs a ReferenceWrapper<T> object from a T&. + explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {} // NOLINT + + // Allows a ReferenceWrapper<T> object to be implicitly converted to + // a T&. + operator T&() const { return *pointer_; } + private: + T* pointer_; +}; + +// CallableHelper has static methods for invoking "callables", +// i.e. function pointers and functors. It uses overloading to +// provide a uniform interface for invoking different kinds of +// callables. In particular, you can use: +// +// CallableHelper<R>::Call(callable, a1, a2, ..., an) +// +// to invoke an n-ary callable, where R is its return type. If an +// argument, say a2, needs to be passed by reference, you should write +// ByRef(a2) instead of a2 in the above expression. +template <typename R> +class CallableHelper { + public: + // Calls a nullary callable. + template <typename Function> + static R Call(Function function) { return function(); } + + // Calls a unary callable. + + // 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 Call(function, "Hi"), the + // compiler would've thought A1 is 'char[3]', which causes trouble + // when you need 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 Call(function, "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 <typename Function, typename A1> + static R Call(Function function, A1 a1) { return function(a1); } + + // Calls a binary callable. + template <typename Function, typename A1, typename A2> + static R Call(Function function, A1 a1, A2 a2) { + return function(a1, a2); + } + + // Calls a ternary callable. + template <typename Function, typename A1, typename A2, typename A3> + static R Call(Function function, A1 a1, A2 a2, A3 a3) { + return function(a1, a2, a3); + } + + // Calls a 4-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4) { + return function(a1, a2, a3, a4); + } + + // Calls a 5-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { + return function(a1, a2, a3, a4, a5); + } + + // Calls a 6-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5, typename A6> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { + return function(a1, a2, a3, a4, a5, a6); + } + + // Calls a 7-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5, typename A6, typename A7> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, + A7 a7) { + return function(a1, a2, a3, a4, a5, a6, a7); + } + + // Calls a 8-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5, typename A6, typename A7, typename A8> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, + A7 a7, A8 a8) { + return function(a1, a2, a3, a4, a5, a6, a7, a8); + } + + // Calls a 9-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5, typename A6, typename A7, typename A8, + typename A9> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, + A7 a7, A8 a8, A9 a9) { + return function(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } + + // Calls a 10-ary callable. + template <typename Function, typename A1, typename A2, typename A3, + typename A4, typename A5, typename A6, typename A7, typename A8, + typename A9, typename A10> + static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, + A7 a7, A8 a8, A9 a9, A10 a10) { + return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } + +}; // 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) \ + typename ::std::tr1::tuple_element<N, Tuple>::type + +// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the +// type of an n-ary function whose i-th (1-based) argument type is the +// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple +// type, and whose return type is Result. For example, +// SelectArgs<int, ::std::tr1::tuple<bool, char, double, long>, 0, 3>::type +// is int(bool, long). +// +// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args) +// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. +// For example, +// SelectArgs<int, ::std::tr1::tuple<bool, char, double>, 2, 0>::Select( +// ::std::tr1::make_tuple(true, 'a', 2.5)) +// returns ::std::tr1::tuple (2.5, true). +// +// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be +// in the range [0, 10]. Duplicates are allowed and they don't have +// to be in an ascending or descending order. + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5, int k6, int k7, int k8, int k9, int k10> +class SelectArgs { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5), + GMOCK_FIELD(ArgumentTuple, k6), GMOCK_FIELD(ArgumentTuple, k7), + GMOCK_FIELD(ArgumentTuple, k8), GMOCK_FIELD(ArgumentTuple, k9), + GMOCK_FIELD(ArgumentTuple, k10)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), + get<k8>(args), get<k9>(args), get<k10>(args)); + } +}; + +template <typename Result, typename ArgumentTuple> +class SelectArgs<Result, ArgumentTuple, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { + public: + typedef Result type(); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(); + } +}; + +template <typename Result, typename ArgumentTuple, int k1> +class SelectArgs<Result, ArgumentTuple, + k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2> +class SelectArgs<Result, ArgumentTuple, + k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5, int k6> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5), + GMOCK_FIELD(ArgumentTuple, k6)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args), get<k6>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5, int k6, int k7> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5), + GMOCK_FIELD(ArgumentTuple, k6), GMOCK_FIELD(ArgumentTuple, k7)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5, int k6, int k7, int k8> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5), + GMOCK_FIELD(ArgumentTuple, k6), GMOCK_FIELD(ArgumentTuple, k7), + GMOCK_FIELD(ArgumentTuple, k8)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), + get<k8>(args)); + } +}; + +template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, + int k4, int k5, int k6, int k7, int k8, int k9> +class SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> { + public: + typedef Result type(GMOCK_FIELD(ArgumentTuple, k1), + GMOCK_FIELD(ArgumentTuple, k2), GMOCK_FIELD(ArgumentTuple, k3), + GMOCK_FIELD(ArgumentTuple, k4), GMOCK_FIELD(ArgumentTuple, k5), + GMOCK_FIELD(ArgumentTuple, k6), GMOCK_FIELD(ArgumentTuple, k7), + GMOCK_FIELD(ArgumentTuple, k8), GMOCK_FIELD(ArgumentTuple, k9)); + typedef typename Function<type>::ArgumentTuple SelectedArgs; + static SelectedArgs Select(const ArgumentTuple& args) { + using ::std::tr1::get; + return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), + get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), + get<k8>(args), get<k9>(args)); + } +}; + +#undef GMOCK_FIELD + +// Implements the WithArgs action. +template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1, + int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1, + int k9 = -1, int k10 = -1> +class WithArgsAction { + public: + explicit WithArgsAction(const InnerAction& action) : action_(action) {} + + template <typename F> + operator Action<F>() const { + typedef typename Function<F>::Result Result; + typedef typename Function<F>::ArgumentTuple ArgumentTuple; + typedef typename SelectArgs<Result, ArgumentTuple, + k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type + InnerFunctionType; + + class Impl : public ActionInterface<F> { + public: + explicit Impl(const InnerAction& action) : action_(action) {} + + virtual Result Perform(const ArgumentTuple& args) { + return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, + k4, k5, k6, k7, k8, k9, k10>::Select(args)); + } + private: + Action<InnerFunctionType> action_; + }; + + return MakeAction(new Impl(action_)); + } + private: + const InnerAction action_; +}; + +// Does two actions sequentially. Used for implementing the DoAll(a1, +// a2, ...) action. +template <typename Action1, typename Action2> +class DoBothAction { + public: + DoBothAction(Action1 action1, Action2 action2) + : action1_(action1), action2_(action2) {} + + // This template type conversion operator allows DoAll(a1, ..., a_n) + // to be used in ANY function of compatible type. + template <typename F> + operator Action<F>() const { + typedef typename Function<F>::Result Result; + typedef typename Function<F>::ArgumentTuple ArgumentTuple; + typedef typename Function<F>::MakeResultVoid VoidResult; + + // Implements the DoAll(...) action for a particular function type F. + class Impl : public ActionInterface<F> { + public: + Impl(const Action<VoidResult>& action1, const Action<F>& action2) + : action1_(action1), action2_(action2) {} + + virtual Result Perform(const ArgumentTuple& args) { + action1_.Perform(args); + return action2_.Perform(args); + } + private: + const Action<VoidResult> action1_; + const Action<F> action2_; + }; + + return Action<F>(new Impl(action1_, action2_)); + } + private: + Action1 action1_; + Action2 action2_; +}; + +} // namespace internal + +// Various overloads for Invoke(). + +// Creates an action that invokes 'function_impl' with the mock +// function's arguments. +template <typename FunctionImpl> +PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke( + FunctionImpl function_impl) { + return MakePolymorphicAction( + internal::InvokeAction<FunctionImpl>(function_impl)); +} + +// Creates an action that invokes the given method on the given object +// with the mock function's arguments. +template <class Class, typename MethodPtr> +PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke( + Class* obj_ptr, MethodPtr method_ptr) { + return MakePolymorphicAction( + internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr)); +} + +// Creates a reference wrapper for the given L-value. If necessary, +// you can explicitly specify the type of the reference. For example, +// suppose 'derived' is an object of type Derived, ByRef(derived) +// would wrap a Derived&. If you want to wrap a const Base& instead, +// where Base is a base class of Derived, just write: +// +// ByRef<const Base>(derived) +template <typename T> +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 +// argument to one that accepts (and ignores) arguments. +template <typename InnerAction> +inline internal::WithArgsAction<InnerAction> +WithoutArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction>(action); +} + +// WithArg<k>(an_action) creates an action that passes the k-th +// (0-based) argument of the mock function to an_action and performs +// it. It adapts an action accepting one argument to one that accepts +// multiple arguments. For convenience, we also provide +// WithArgs<k>(an_action) (defined below) as a synonym. +template <int k, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k> +WithArg(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k>(action); +} + +// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes +// the selected arguments of the mock function to an_action and +// performs it. It serves as an adaptor between actions with +// different argument lists. C++ doesn't support default arguments for +// function templates, so we have to overload it. +template <int k1, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1>(action); +} + +template <int k1, int k2, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2>(action); +} + +template <int k1, int k2, int k3, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3>(action); +} + +template <int k1, int k2, int k3, int k4, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, + typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, + k7>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, + typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, + k8>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, + int k9, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, + k9>(action); +} + +template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, + int k9, int k10, typename InnerAction> +inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, + k9, k10> +WithArgs(const InnerAction& action) { + return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, + k9, k10>(action); +} + +// Creates an action that does actions a1, a2, ..., sequentially in +// each invocation. +template <typename Action1, typename Action2> +inline internal::DoBothAction<Action1, Action2> +DoAll(Action1 a1, Action2 a2) { + return internal::DoBothAction<Action1, Action2>(a1, a2); +} + +template <typename Action1, typename Action2, typename Action3> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + Action3> > +DoAll(Action1 a1, Action2 a2, Action3 a3) { + return DoAll(a1, DoAll(a2, a3)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, Action4> > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) { + return DoAll(a1, DoAll(a2, a3, a4)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + Action5> > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) { + return DoAll(a1, DoAll(a2, a3, a4, a5)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5, typename Action6> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + internal::DoBothAction<Action5, Action6> > > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) { + return DoAll(a1, DoAll(a2, a3, a4, a5, a6)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5, typename Action6, typename Action7> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + internal::DoBothAction<Action5, internal::DoBothAction<Action6, + Action7> > > > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, + Action7 a7) { + return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5, typename Action6, typename Action7, + typename Action8> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + internal::DoBothAction<Action5, internal::DoBothAction<Action6, + internal::DoBothAction<Action7, Action8> > > > > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, + Action7 a7, Action8 a8) { + return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5, typename Action6, typename Action7, + typename Action8, typename Action9> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + internal::DoBothAction<Action5, internal::DoBothAction<Action6, + internal::DoBothAction<Action7, internal::DoBothAction<Action8, + Action9> > > > > > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, + Action7 a7, Action8 a8, Action9 a9) { + return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9)); +} + +template <typename Action1, typename Action2, typename Action3, + typename Action4, typename Action5, typename Action6, typename Action7, + typename Action8, typename Action9, typename Action10> +inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, + internal::DoBothAction<Action3, internal::DoBothAction<Action4, + internal::DoBothAction<Action5, internal::DoBothAction<Action6, + internal::DoBothAction<Action7, internal::DoBothAction<Action8, + internal::DoBothAction<Action9, Action10> > > > > > > > > +DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, + Action7 a7, Action8 a8, Action9 a9, Action10 a10) { + return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10)); +} + +} // namespace testing + +#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ |