$$ -*- mode: c++; -*-

$$ This is a Pump source file. Please use Pump to convert it to

$$ gmock-generated-actions.h.

$$

$var n = 10  $$ The maximum arity we support.

$$}} This meta comment fixes auto-indentation in editors.

// 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.

// Google Mock - a framework for writing C++ mock classes.

//

// This file implements some commonly used variadic actions.

// GOOGLETEST_CM0002 DO NOT DELETE

#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, method, or callback with the unpacked values, where F is

// a function type that takes N arguments.

template <typename Result, typename ArgumentTuple>

class InvokeHelper;

$var max_callback_arity = 5

$range i 0..n

$for i [[

$range j 1..i

$var types = [[$for j [[, typename A$j]]]]

$var as = [[$for j, [[A$j]]]]

$var args = [[$if i==0 [[]] $else [[ args]]]]

$var gets = [[$for j, [[get<$(j - 1)>(args)]]]]

template <typename R$types>

class InvokeHelper<R, ::testing::tuple<$as> > {

 public:

  template <typename Function>

  static R Invoke(Function function, const ::testing::tuple<$as>&$args) {

           return function($gets);

  }

  template <class Class, typename MethodPtr>

  static R InvokeMethod(Class* obj_ptr,

                        MethodPtr method_ptr,

                        const ::testing::tuple<$as>&$args) {

           return (obj_ptr->*method_ptr)($gets);

  }

$if i <= max_callback_arity [[

  template <typename CallbackType>

  static R InvokeCallback(CallbackType* callback,

                          const ::testing::tuple<$as>&$args) {

           return callback->Run($gets);

  }

]] $else [[

  // There is no InvokeCallback() for $i-tuples

]]

};

]]

// Implements the Invoke(callback) action.

template <typename CallbackType>

class InvokeCallbackAction {

 public:

  // The c'tor takes ownership of the callback.

  explicit InvokeCallbackAction(CallbackType* callback)

      : callback_(callback) {

    callback->CheckIsRepeatable();  // Makes sure the callback is permanent.

  }

  // This type conversion operator template allows Invoke(callback) to

  // be used wherever the callback's type is compatible with that of

  // the mock function, i.e. if the mock function's arguments can be

  // implicitly converted to the callback's arguments and the

  // callback's result can be implicitly converted to the mock

  // function's result.

  template <typename Result, typename ArgumentTuple>

  Result Perform(const ArgumentTuple& args) const {

    return InvokeHelper<Result, ArgumentTuple>::InvokeCallback(

        callback_.get(), args);

  }

 private:

  const linked_ptr<CallbackType> callback_;

};

// 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 ::testing::tuple_element<N, Tuple>::type

$range i 1..n

// 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, ::testing::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, tuple<bool, char, double>, 2, 0>::Select(

//       ::testing::make_tuple(true, 'a', 2.5))

// returns tuple (2.5, true).

//

// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be

// in the range [0, $n].  Duplicates are allowed and they don't have

// to be in an ascending or descending order.

template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]>

class SelectArgs {

 public:

  typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]);

  typedef typename Function<type>::ArgumentTuple SelectedArgs;

  static SelectedArgs Select(const ArgumentTuple& args) {

    return SelectedArgs($for i, [[get<k$i>(args)]]);

  }

};

$for i [[

$range j 1..n

$range j1 1..i-1

template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]>

class SelectArgs<Result, ArgumentTuple,

                 $for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> {

 public:

  typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]);

  typedef typename Function<type>::ArgumentTuple SelectedArgs;

  static SelectedArgs Select(const ArgumentTuple& [[]]

$if i == 1 [[/* args */]] $else [[args]]) {

    return SelectedArgs($for j1, [[get<k$j1>(args)]]);

  }

};

]]

#undef GMOCK_FIELD_

$var ks = [[$for i, [[k$i]]]]

// Implements the WithArgs action.

template <typename InnerAction, $for i, [[int k$i = -1]]>

class WithArgsAction {

 public:

  explicit WithArgsAction(const InnerAction& action) : action_(action) {}

  template <typename F>

  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }

 private:

  template <typename F>

  class Impl : public ActionInterface<F> {

   public:

    typedef typename Function<F>::Result Result;

    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const InnerAction& action) : action_(action) {}

    virtual Result Perform(const ArgumentTuple& args) {

      return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args));

    }

   private:

    typedef typename SelectArgs<Result, ArgumentTuple,

        $ks>::type InnerFunctionType;

    Action<InnerFunctionType> action_;

  };

  const InnerAction action_;

  GTEST_DISALLOW_ASSIGN_(WithArgsAction);

};

// A macro from the ACTION* family (defined later in this file)

// defines an action that can be used in a mock function.  Typically,

// these actions only care about a subset of the arguments of the mock

// function.  For example, if such an action only uses the second

// argument, it can be used in any mock function that takes >= 2

// arguments where the type of the second argument is compatible.

//

// Therefore, the action implementation must be prepared to take more

// arguments than it needs.  The ExcessiveArg type is used to

// represent those excessive arguments.  In order to keep the compiler

// error messages tractable, we define it in the testing namespace

// instead of testing::internal.  However, this is an INTERNAL TYPE

// and subject to change without notice, so a user MUST NOT USE THIS

// TYPE DIRECTLY.

struct ExcessiveArg {};

// A helper class needed for implementing the ACTION* macros.

template <typename Result, class Impl>

class ActionHelper {

 public:

$range i 0..n

$for i

[[

$var template = [[$if i==0 [[]] $else [[

$range j 0..i-1

  template <$for j, [[typename A$j]]>

]]]]

$range j 0..i-1

$var As = [[$for j, [[A$j]]]]

$var as = [[$for j, [[get<$j>(args)]]]]

$range k 1..n-i

$var eas = [[$for k, [[ExcessiveArg()]]]]

$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]]

$template

  static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) {

    return impl->template gmock_PerformImpl<$As>(args, $arg_list);

  }

]]

};

}  // namespace internal

// Various overloads for Invoke().

// 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.

$range i 1..n

$for i [[

$range j 1..i

template <$for j [[int k$j, ]]typename InnerAction>

inline internal::WithArgsAction<InnerAction$for j [[, k$j]]>

WithArgs(const InnerAction& action) {

  return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action);

}

]]

// Creates an action that does actions a1, a2, ..., sequentially in

// each invocation.

$range i 2..n

$for i [[

$range j 2..i

$var types = [[$for j, [[typename Action$j]]]]

$var Aas = [[$for j [[, Action$j a$j]]]]

template <typename Action1, $types>

$range k 1..i-1

inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k  [[>]]

DoAll(Action1 a1$Aas) {

$if i==2 [[

  return internal::DoBothAction<Action1, Action2>(a1, a2);

]] $else [[

$range j2 2..i

  return DoAll(a1, DoAll($for j2, [[a$j2]]));

]]

}

]]

}  // namespace testing

// The ACTION* family of macros can be used in a namespace scope to

// define custom actions easily.  The syntax:

//

//   ACTION(name) { statements; }

//

// will define an action with the given name that executes the

// statements.  The value returned by the statements will be used as

// the return value of the action.  Inside the statements, you can

// refer to the K-th (0-based) argument of the mock function by

// 'argK', and refer to its type by 'argK_type'.  For example:

//

//   ACTION(IncrementArg1) {

//     arg1_type temp = arg1;

//     return ++(*temp);

//   }

//

// allows you to write

//

//   ...WillOnce(IncrementArg1());

//

// You can also refer to the entire argument tuple and its type by

// 'args' and 'args_type', and refer to the mock function type and its

// return type by 'function_type' and 'return_type'.

//

// Note that you don't need to specify the types of the mock function

// arguments.  However rest assured that your code is still type-safe:

// you'll get a compiler error if *arg1 doesn't support the ++

// operator, or if the type of ++(*arg1) isn't compatible with the

// mock function's return type, for example.

//

// Sometimes you'll want to parameterize the action.   For that you can use

// another macro:

//

//   ACTION_P(name, param_name) { statements; }

//

// For example:

//

//   ACTION_P(Add, n) { return arg0 + n; }

//

// will allow you to write:

//

//   ...WillOnce(Add(5));

//

// Note that you don't need to provide the type of the parameter

// either.  If you need to reference the type of a parameter named

// 'foo', you can write 'foo_type'.  For example, in the body of

// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type

// of 'n'.

//

// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support

// multi-parameter actions.

//

// For the purpose of typing, you can view

//

//   ACTION_Pk(Foo, p1, ..., pk) { ... }

//

// as shorthand for

//

//   template <typename p1_type, ..., typename pk_type>

//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }

//

// In particular, you can provide the template type arguments

// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);

// although usually you can rely on the compiler to infer the types

// for you automatically.  You can assign the result of expression

// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,

// pk_type>.  This can be useful when composing actions.

//

// You can also overload actions with different numbers of parameters:

//

//   ACTION_P(Plus, a) { ... }

//   ACTION_P2(Plus, a, b) { ... }

//

// While it's tempting to always use the ACTION* macros when defining

// a new action, you should also consider implementing ActionInterface

// or using MakePolymorphicAction() instead, especially if you need to

// use the action a lot.  While these approaches require more work,

// they give you more control on the types of the mock function

// arguments and the action parameters, which in general leads to

// better compiler error messages that pay off in the long run.  They

// also allow overloading actions based on parameter types (as opposed

// to just based on the number of parameters).

//

// CAVEAT:

//

// ACTION*() can only be used in a namespace scope.  The reason is

// that C++ doesn't yet allow function-local types to be used to

// instantiate templates.  The up-coming C++0x standard will fix this.

// Once that's done, we'll consider supporting using ACTION*() inside

// a function.

//

// MORE INFORMATION:

//

// To learn more about using these macros, please search for 'ACTION'

// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md

$range i 0..n

$range k 0..n-1

// An internal macro needed for implementing ACTION*().

#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\

    const args_type& args GTEST_ATTRIBUTE_UNUSED_

$for k [[, \

    arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]]

// Sometimes you want to give an action explicit template parameters

// that cannot be inferred from its value parameters.  ACTION() and

// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that

// and can be viewed as an extension to ACTION() and ACTION_P*().

//

// The syntax:

//

//   ACTION_TEMPLATE(ActionName,

//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),

//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }

//

// defines an action template that takes m explicit template

// parameters and n value parameters.  name_i is the name of the i-th

// template parameter, and kind_i specifies whether it's a typename,

// an integral constant, or a template.  p_i is the name of the i-th

// value parameter.

//

// Example:

//

//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock

//   // function to type T and copies it to *output.

//   ACTION_TEMPLATE(DuplicateArg,

//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),

//                   AND_1_VALUE_PARAMS(output)) {

//     *output = T(::testing::get<k>(args));

//   }

//   ...

//     int n;

//     EXPECT_CALL(mock, Foo(_, _))

//         .WillOnce(DuplicateArg<1, unsigned char>(&n));

//

// To create an instance of an action template, write:

//

//   ActionName<t1, ..., t_m>(v1, ..., v_n)

//

// where the ts are the template arguments and the vs are the value

// arguments.  The value argument types are inferred by the compiler.

// If you want to explicitly specify the value argument types, you can

// provide additional template arguments:

//

//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)

//

// where u_i is the desired type of v_i.

//

// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the

// number of value parameters, but not on the number of template

// parameters.  Without the restriction, the meaning of the following

// is unclear:

//

//   OverloadedAction<int, bool>(x);

//

// Are we using a single-template-parameter action where 'bool' refers

// to the type of x, or are we using a two-template-parameter action

// where the compiler is asked to infer the type of x?

//

// Implementation notes:

//

// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and

// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for

// implementing ACTION_TEMPLATE.  The main trick we use is to create

// new macro invocations when expanding a macro.  For example, we have

//

//   #define ACTION_TEMPLATE(name, template_params, value_params)

//       ... GMOCK_INTERNAL_DECL_##template_params ...

//

// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)

// to expand to

//

//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...

//

// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the

// preprocessor will continue to expand it to

//

//       ... typename T ...

//

// This technique conforms to the C++ standard and is portable.  It

// allows us to implement action templates using O(N) code, where N is

// the maximum number of template/value parameters supported.  Without

// using it, we'd have to devote O(N^2) amount of code to implement all

// combinations of m and n.

// Declares the template parameters.

$range j 1..n

$for j [[

$range m 0..j-1

#define GMOCK_INTERNAL_DECL_HAS_$j[[]]

_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]]

]]

// Lists the template parameters.

$for j [[

$range m 0..j-1

#define GMOCK_INTERNAL_LIST_HAS_$j[[]]

_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]]

]]

// Declares the types of value parameters.

$for i [[

$range j 0..i-1

#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]]

_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]]

]]

// Initializes the value parameters.

$for i [[

$range j 0..i-1

#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\

    ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::testing::internal::move(gmock_p$j))]]