1// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
2
3// Copyright 2007, Google Inc.
4// All rights reserved.
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met:
9//
10//     * Redistributions of source code must retain the above copyright
11// notice, this list of conditions and the following disclaimer.
12//     * Redistributions in binary form must reproduce the above
13// copyright notice, this list of conditions and the following disclaimer
14// in the documentation and/or other materials provided with the
15// distribution.
16//     * Neither the name of Google Inc. nor the names of its
17// contributors may be used to endorse or promote products derived from
18// this software without specific prior written permission.
19//
20// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31//
32// Author: wan@google.com (Zhanyong Wan)
33
34// Google Mock - a framework for writing C++ mock classes.
35//
36// This file implements some commonly used variadic actions.
37
38#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
39#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
40
41#include "gmock/gmock-actions.h"
42#include "gmock/internal/gmock-port.h"
43
44namespace testing {
45namespace internal {
46
47// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
48// function or method with the unpacked values, where F is a function
49// type that takes N arguments.
50template <typename Result, typename ArgumentTuple>
51class InvokeHelper;
52
53template <typename R>
54class InvokeHelper<R, ::testing::tuple<> > {
55 public:
56  template <typename Function>
57  static R Invoke(Function function, const ::testing::tuple<>&) {
58           return function();
59  }
60
61  template <class Class, typename MethodPtr>
62  static R InvokeMethod(Class* obj_ptr,
63                        MethodPtr method_ptr,
64                        const ::testing::tuple<>&) {
65           return (obj_ptr->*method_ptr)();
66  }
67};
68
69template <typename R, typename A1>
70class InvokeHelper<R, ::testing::tuple<A1> > {
71 public:
72  template <typename Function>
73  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
74           return function(get<0>(args));
75  }
76
77  template <class Class, typename MethodPtr>
78  static R InvokeMethod(Class* obj_ptr,
79                        MethodPtr method_ptr,
80                        const ::testing::tuple<A1>& args) {
81           return (obj_ptr->*method_ptr)(get<0>(args));
82  }
83};
84
85template <typename R, typename A1, typename A2>
86class InvokeHelper<R, ::testing::tuple<A1, A2> > {
87 public:
88  template <typename Function>
89  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
90           return function(get<0>(args), get<1>(args));
91  }
92
93  template <class Class, typename MethodPtr>
94  static R InvokeMethod(Class* obj_ptr,
95                        MethodPtr method_ptr,
96                        const ::testing::tuple<A1, A2>& args) {
97           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
98  }
99};
100
101template <typename R, typename A1, typename A2, typename A3>
102class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
103 public:
104  template <typename Function>
105  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
106           return function(get<0>(args), get<1>(args), get<2>(args));
107  }
108
109  template <class Class, typename MethodPtr>
110  static R InvokeMethod(Class* obj_ptr,
111                        MethodPtr method_ptr,
112                        const ::testing::tuple<A1, A2, A3>& args) {
113           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
114               get<2>(args));
115  }
116};
117
118template <typename R, typename A1, typename A2, typename A3, typename A4>
119class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
120 public:
121  template <typename Function>
122  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
123      A4>& args) {
124           return function(get<0>(args), get<1>(args), get<2>(args),
125               get<3>(args));
126  }
127
128  template <class Class, typename MethodPtr>
129  static R InvokeMethod(Class* obj_ptr,
130                        MethodPtr method_ptr,
131                        const ::testing::tuple<A1, A2, A3, A4>& args) {
132           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
133               get<2>(args), get<3>(args));
134  }
135};
136
137template <typename R, typename A1, typename A2, typename A3, typename A4,
138    typename A5>
139class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
140 public:
141  template <typename Function>
142  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
143      A5>& args) {
144           return function(get<0>(args), get<1>(args), get<2>(args),
145               get<3>(args), get<4>(args));
146  }
147
148  template <class Class, typename MethodPtr>
149  static R InvokeMethod(Class* obj_ptr,
150                        MethodPtr method_ptr,
151                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
152           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
153               get<2>(args), get<3>(args), get<4>(args));
154  }
155};
156
157template <typename R, typename A1, typename A2, typename A3, typename A4,
158    typename A5, typename A6>
159class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
160 public:
161  template <typename Function>
162  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
163      A6>& args) {
164           return function(get<0>(args), get<1>(args), get<2>(args),
165               get<3>(args), get<4>(args), get<5>(args));
166  }
167
168  template <class Class, typename MethodPtr>
169  static R InvokeMethod(Class* obj_ptr,
170                        MethodPtr method_ptr,
171                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
172           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
173               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
174  }
175};
176
177template <typename R, typename A1, typename A2, typename A3, typename A4,
178    typename A5, typename A6, typename A7>
179class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
180 public:
181  template <typename Function>
182  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
183      A6, A7>& args) {
184           return function(get<0>(args), get<1>(args), get<2>(args),
185               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
186  }
187
188  template <class Class, typename MethodPtr>
189  static R InvokeMethod(Class* obj_ptr,
190                        MethodPtr method_ptr,
191                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
192                            A7>& args) {
193           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
194               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
195               get<6>(args));
196  }
197};
198
199template <typename R, typename A1, typename A2, typename A3, typename A4,
200    typename A5, typename A6, typename A7, typename A8>
201class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
202 public:
203  template <typename Function>
204  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
205      A6, A7, A8>& args) {
206           return function(get<0>(args), get<1>(args), get<2>(args),
207               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
208               get<7>(args));
209  }
210
211  template <class Class, typename MethodPtr>
212  static R InvokeMethod(Class* obj_ptr,
213                        MethodPtr method_ptr,
214                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
215                            A8>& args) {
216           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
217               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
218               get<6>(args), get<7>(args));
219  }
220};
221
222template <typename R, typename A1, typename A2, typename A3, typename A4,
223    typename A5, typename A6, typename A7, typename A8, typename A9>
224class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
225 public:
226  template <typename Function>
227  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
228      A6, A7, A8, A9>& args) {
229           return function(get<0>(args), get<1>(args), get<2>(args),
230               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
231               get<7>(args), get<8>(args));
232  }
233
234  template <class Class, typename MethodPtr>
235  static R InvokeMethod(Class* obj_ptr,
236                        MethodPtr method_ptr,
237                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
238                            A9>& args) {
239           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
240               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
241               get<6>(args), get<7>(args), get<8>(args));
242  }
243};
244
245template <typename R, typename A1, typename A2, typename A3, typename A4,
246    typename A5, typename A6, typename A7, typename A8, typename A9,
247    typename A10>
248class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
249    A10> > {
250 public:
251  template <typename Function>
252  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
253      A6, A7, A8, A9, A10>& args) {
254           return function(get<0>(args), get<1>(args), get<2>(args),
255               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
256               get<7>(args), get<8>(args), get<9>(args));
257  }
258
259  template <class Class, typename MethodPtr>
260  static R InvokeMethod(Class* obj_ptr,
261                        MethodPtr method_ptr,
262                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
263                            A9, A10>& args) {
264           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
265               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
266               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
267  }
268};
269
270// An INTERNAL macro for extracting the type of a tuple field.  It's
271// subject to change without notice - DO NOT USE IN USER CODE!
272#define GMOCK_FIELD_(Tuple, N) \
273    typename ::testing::tuple_element<N, Tuple>::type
274
275// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
276// type of an n-ary function whose i-th (1-based) argument type is the
277// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
278// type, and whose return type is Result.  For example,
279//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
280// is int(bool, long).
281//
282// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
283// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
284// For example,
285//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
286//       ::testing::make_tuple(true, 'a', 2.5))
287// returns tuple (2.5, true).
288//
289// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
290// in the range [0, 10].  Duplicates are allowed and they don't have
291// to be in an ascending or descending order.
292
293template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
294    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
295class SelectArgs {
296 public:
297  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
298      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
299      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
300      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
301      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
302      GMOCK_FIELD_(ArgumentTuple, k10));
303  typedef typename Function<type>::ArgumentTuple SelectedArgs;
304  static SelectedArgs Select(const ArgumentTuple& args) {
305    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
306        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
307        get<k8>(args), get<k9>(args), get<k10>(args));
308  }
309};
310
311template <typename Result, typename ArgumentTuple>
312class SelectArgs<Result, ArgumentTuple,
313                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
314 public:
315  typedef Result type();
316  typedef typename Function<type>::ArgumentTuple SelectedArgs;
317  static SelectedArgs Select(const ArgumentTuple& /* args */) {
318    return SelectedArgs();
319  }
320};
321
322template <typename Result, typename ArgumentTuple, int k1>
323class SelectArgs<Result, ArgumentTuple,
324                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
325 public:
326  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
327  typedef typename Function<type>::ArgumentTuple SelectedArgs;
328  static SelectedArgs Select(const ArgumentTuple& args) {
329    return SelectedArgs(get<k1>(args));
330  }
331};
332
333template <typename Result, typename ArgumentTuple, int k1, int k2>
334class SelectArgs<Result, ArgumentTuple,
335                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
336 public:
337  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
338      GMOCK_FIELD_(ArgumentTuple, k2));
339  typedef typename Function<type>::ArgumentTuple SelectedArgs;
340  static SelectedArgs Select(const ArgumentTuple& args) {
341    return SelectedArgs(get<k1>(args), get<k2>(args));
342  }
343};
344
345template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
346class SelectArgs<Result, ArgumentTuple,
347                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
348 public:
349  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
350      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
351  typedef typename Function<type>::ArgumentTuple SelectedArgs;
352  static SelectedArgs Select(const ArgumentTuple& args) {
353    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
354  }
355};
356
357template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
358    int k4>
359class SelectArgs<Result, ArgumentTuple,
360                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
361 public:
362  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
363      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
364      GMOCK_FIELD_(ArgumentTuple, k4));
365  typedef typename Function<type>::ArgumentTuple SelectedArgs;
366  static SelectedArgs Select(const ArgumentTuple& args) {
367    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
368        get<k4>(args));
369  }
370};
371
372template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
373    int k4, int k5>
374class SelectArgs<Result, ArgumentTuple,
375                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
376 public:
377  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
378      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
379      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
380  typedef typename Function<type>::ArgumentTuple SelectedArgs;
381  static SelectedArgs Select(const ArgumentTuple& args) {
382    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
383        get<k4>(args), get<k5>(args));
384  }
385};
386
387template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
388    int k4, int k5, int k6>
389class SelectArgs<Result, ArgumentTuple,
390                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
391 public:
392  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
393      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
394      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
395      GMOCK_FIELD_(ArgumentTuple, k6));
396  typedef typename Function<type>::ArgumentTuple SelectedArgs;
397  static SelectedArgs Select(const ArgumentTuple& args) {
398    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
399        get<k4>(args), get<k5>(args), get<k6>(args));
400  }
401};
402
403template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
404    int k4, int k5, int k6, int k7>
405class SelectArgs<Result, ArgumentTuple,
406                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
407 public:
408  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
409      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
410      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
411      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
412  typedef typename Function<type>::ArgumentTuple SelectedArgs;
413  static SelectedArgs Select(const ArgumentTuple& args) {
414    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
415        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
416  }
417};
418
419template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
420    int k4, int k5, int k6, int k7, int k8>
421class SelectArgs<Result, ArgumentTuple,
422                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
423 public:
424  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
425      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
426      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
427      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
428      GMOCK_FIELD_(ArgumentTuple, k8));
429  typedef typename Function<type>::ArgumentTuple SelectedArgs;
430  static SelectedArgs Select(const ArgumentTuple& args) {
431    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
432        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
433        get<k8>(args));
434  }
435};
436
437template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
438    int k4, int k5, int k6, int k7, int k8, int k9>
439class SelectArgs<Result, ArgumentTuple,
440                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
441 public:
442  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
443      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
444      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
445      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
446      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
447  typedef typename Function<type>::ArgumentTuple SelectedArgs;
448  static SelectedArgs Select(const ArgumentTuple& args) {
449    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
450        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
451        get<k8>(args), get<k9>(args));
452  }
453};
454
455#undef GMOCK_FIELD_
456
457// Implements the WithArgs action.
458template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
459    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
460    int k9 = -1, int k10 = -1>
461class WithArgsAction {
462 public:
463  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
464
465  template <typename F>
466  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
467
468 private:
469  template <typename F>
470  class Impl : public ActionInterface<F> {
471   public:
472    typedef typename Function<F>::Result Result;
473    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
474
475    explicit Impl(const InnerAction& action) : action_(action) {}
476
477    virtual Result Perform(const ArgumentTuple& args) {
478      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
479          k5, k6, k7, k8, k9, k10>::Select(args));
480    }
481
482   private:
483    typedef typename SelectArgs<Result, ArgumentTuple,
484        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
485
486    Action<InnerFunctionType> action_;
487  };
488
489  const InnerAction action_;
490
491  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
492};
493
494// A macro from the ACTION* family (defined later in this file)
495// defines an action that can be used in a mock function.  Typically,
496// these actions only care about a subset of the arguments of the mock
497// function.  For example, if such an action only uses the second
498// argument, it can be used in any mock function that takes >= 2
499// arguments where the type of the second argument is compatible.
500//
501// Therefore, the action implementation must be prepared to take more
502// arguments than it needs.  The ExcessiveArg type is used to
503// represent those excessive arguments.  In order to keep the compiler
504// error messages tractable, we define it in the testing namespace
505// instead of testing::internal.  However, this is an INTERNAL TYPE
506// and subject to change without notice, so a user MUST NOT USE THIS
507// TYPE DIRECTLY.
508struct ExcessiveArg {};
509
510// A helper class needed for implementing the ACTION* macros.
511template <typename Result, class Impl>
512class ActionHelper {
513 public:
514  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
515    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
516        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
517        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
518        ExcessiveArg());
519  }
520
521  template <typename A0>
522  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
523    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
524        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
525        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
526        ExcessiveArg());
527  }
528
529  template <typename A0, typename A1>
530  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
531    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
532        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
533        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
534        ExcessiveArg());
535  }
536
537  template <typename A0, typename A1, typename A2>
538  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
539    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
540        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
541        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
542        ExcessiveArg());
543  }
544
545  template <typename A0, typename A1, typename A2, typename A3>
546  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
547      A3>& args) {
548    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
549        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
550        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
551        ExcessiveArg());
552  }
553
554  template <typename A0, typename A1, typename A2, typename A3, typename A4>
555  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
556      A4>& args) {
557    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
558        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
559        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
560        ExcessiveArg());
561  }
562
563  template <typename A0, typename A1, typename A2, typename A3, typename A4,
564      typename A5>
565  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
566      A5>& args) {
567    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
568        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
569        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
570        ExcessiveArg());
571  }
572
573  template <typename A0, typename A1, typename A2, typename A3, typename A4,
574      typename A5, typename A6>
575  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
576      A5, A6>& args) {
577    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
578        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
579        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
580        ExcessiveArg());
581  }
582
583  template <typename A0, typename A1, typename A2, typename A3, typename A4,
584      typename A5, typename A6, typename A7>
585  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
586      A5, A6, A7>& args) {
587    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
588        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
589        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
590        ExcessiveArg());
591  }
592
593  template <typename A0, typename A1, typename A2, typename A3, typename A4,
594      typename A5, typename A6, typename A7, typename A8>
595  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
596      A5, A6, A7, A8>& args) {
597    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
598        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
599        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
600        ExcessiveArg());
601  }
602
603  template <typename A0, typename A1, typename A2, typename A3, typename A4,
604      typename A5, typename A6, typename A7, typename A8, typename A9>
605  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
606      A5, A6, A7, A8, A9>& args) {
607    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
608        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
609        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
610        get<9>(args));
611  }
612};
613
614}  // namespace internal
615
616// Various overloads for Invoke().
617
618// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
619// the selected arguments of the mock function to an_action and
620// performs it.  It serves as an adaptor between actions with
621// different argument lists.  C++ doesn't support default arguments for
622// function templates, so we have to overload it.
623template <int k1, typename InnerAction>
624inline internal::WithArgsAction<InnerAction, k1>
625WithArgs(const InnerAction& action) {
626  return internal::WithArgsAction<InnerAction, k1>(action);
627}
628
629template <int k1, int k2, typename InnerAction>
630inline internal::WithArgsAction<InnerAction, k1, k2>
631WithArgs(const InnerAction& action) {
632  return internal::WithArgsAction<InnerAction, k1, k2>(action);
633}
634
635template <int k1, int k2, int k3, typename InnerAction>
636inline internal::WithArgsAction<InnerAction, k1, k2, k3>
637WithArgs(const InnerAction& action) {
638  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
639}
640
641template <int k1, int k2, int k3, int k4, typename InnerAction>
642inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
643WithArgs(const InnerAction& action) {
644  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
645}
646
647template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
648inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
649WithArgs(const InnerAction& action) {
650  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
651}
652
653template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
654inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
655WithArgs(const InnerAction& action) {
656  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
657}
658
659template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
660    typename InnerAction>
661inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
662WithArgs(const InnerAction& action) {
663  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
664      k7>(action);
665}
666
667template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
668    typename InnerAction>
669inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
670WithArgs(const InnerAction& action) {
671  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
672      k8>(action);
673}
674
675template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
676    int k9, typename InnerAction>
677inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
678WithArgs(const InnerAction& action) {
679  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
680      k9>(action);
681}
682
683template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
684    int k9, int k10, typename InnerAction>
685inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
686    k9, k10>
687WithArgs(const InnerAction& action) {
688  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
689      k9, k10>(action);
690}
691
692// Creates an action that does actions a1, a2, ..., sequentially in
693// each invocation.
694template <typename Action1, typename Action2>
695inline internal::DoBothAction<Action1, Action2>
696DoAll(Action1 a1, Action2 a2) {
697  return internal::DoBothAction<Action1, Action2>(a1, a2);
698}
699
700template <typename Action1, typename Action2, typename Action3>
701inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
702    Action3> >
703DoAll(Action1 a1, Action2 a2, Action3 a3) {
704  return DoAll(a1, DoAll(a2, a3));
705}
706
707template <typename Action1, typename Action2, typename Action3,
708    typename Action4>
709inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
710    internal::DoBothAction<Action3, Action4> > >
711DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
712  return DoAll(a1, DoAll(a2, a3, a4));
713}
714
715template <typename Action1, typename Action2, typename Action3,
716    typename Action4, typename Action5>
717inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
718    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
719    Action5> > > >
720DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
721  return DoAll(a1, DoAll(a2, a3, a4, a5));
722}
723
724template <typename Action1, typename Action2, typename Action3,
725    typename Action4, typename Action5, typename Action6>
726inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
727    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
728    internal::DoBothAction<Action5, Action6> > > > >
729DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
730  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
731}
732
733template <typename Action1, typename Action2, typename Action3,
734    typename Action4, typename Action5, typename Action6, typename Action7>
735inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
736    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
737    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
738    Action7> > > > > >
739DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
740    Action7 a7) {
741  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
742}
743
744template <typename Action1, typename Action2, typename Action3,
745    typename Action4, typename Action5, typename Action6, typename Action7,
746    typename Action8>
747inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
748    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
749    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
750    internal::DoBothAction<Action7, Action8> > > > > > >
751DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
752    Action7 a7, Action8 a8) {
753  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
754}
755
756template <typename Action1, typename Action2, typename Action3,
757    typename Action4, typename Action5, typename Action6, typename Action7,
758    typename Action8, typename Action9>
759inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
760    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
761    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
762    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
763    Action9> > > > > > > >
764DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
765    Action7 a7, Action8 a8, Action9 a9) {
766  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
767}
768
769template <typename Action1, typename Action2, typename Action3,
770    typename Action4, typename Action5, typename Action6, typename Action7,
771    typename Action8, typename Action9, typename Action10>
772inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
773    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
774    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
775    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
776    internal::DoBothAction<Action9, Action10> > > > > > > > >
777DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
778    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
779  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
780}
781
782}  // namespace testing
783
784// The ACTION* family of macros can be used in a namespace scope to
785// define custom actions easily.  The syntax:
786//
787//   ACTION(name) { statements; }
788//
789// will define an action with the given name that executes the
790// statements.  The value returned by the statements will be used as
791// the return value of the action.  Inside the statements, you can
792// refer to the K-th (0-based) argument of the mock function by
793// 'argK', and refer to its type by 'argK_type'.  For example:
794//
795//   ACTION(IncrementArg1) {
796//     arg1_type temp = arg1;
797//     return ++(*temp);
798//   }
799//
800// allows you to write
801//
802//   ...WillOnce(IncrementArg1());
803//
804// You can also refer to the entire argument tuple and its type by
805// 'args' and 'args_type', and refer to the mock function type and its
806// return type by 'function_type' and 'return_type'.
807//
808// Note that you don't need to specify the types of the mock function
809// arguments.  However rest assured that your code is still type-safe:
810// you'll get a compiler error if *arg1 doesn't support the ++
811// operator, or if the type of ++(*arg1) isn't compatible with the
812// mock function's return type, for example.
813//
814// Sometimes you'll want to parameterize the action.   For that you can use
815// another macro:
816//
817//   ACTION_P(name, param_name) { statements; }
818//
819// For example:
820//
821//   ACTION_P(Add, n) { return arg0 + n; }
822//
823// will allow you to write:
824//
825//   ...WillOnce(Add(5));
826//
827// Note that you don't need to provide the type of the parameter
828// either.  If you need to reference the type of a parameter named
829// 'foo', you can write 'foo_type'.  For example, in the body of
830// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
831// of 'n'.
832//
833// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
834// multi-parameter actions.
835//
836// For the purpose of typing, you can view
837//
838//   ACTION_Pk(Foo, p1, ..., pk) { ... }
839//
840// as shorthand for
841//
842//   template <typename p1_type, ..., typename pk_type>
843//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
844//
845// In particular, you can provide the template type arguments
846// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
847// although usually you can rely on the compiler to infer the types
848// for you automatically.  You can assign the result of expression
849// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
850// pk_type>.  This can be useful when composing actions.
851//
852// You can also overload actions with different numbers of parameters:
853//
854//   ACTION_P(Plus, a) { ... }
855//   ACTION_P2(Plus, a, b) { ... }
856//
857// While it's tempting to always use the ACTION* macros when defining
858// a new action, you should also consider implementing ActionInterface
859// or using MakePolymorphicAction() instead, especially if you need to
860// use the action a lot.  While these approaches require more work,
861// they give you more control on the types of the mock function
862// arguments and the action parameters, which in general leads to
863// better compiler error messages that pay off in the long run.  They
864// also allow overloading actions based on parameter types (as opposed
865// to just based on the number of parameters).
866//
867// CAVEAT:
868//
869// ACTION*() can only be used in a namespace scope.  The reason is
870// that C++ doesn't yet allow function-local types to be used to
871// instantiate templates.  The up-coming C++0x standard will fix this.
872// Once that's done, we'll consider supporting using ACTION*() inside
873// a function.
874//
875// MORE INFORMATION:
876//
877// To learn more about using these macros, please search for 'ACTION'
878// on http://code.google.com/p/googlemock/wiki/CookBook.
879
880// An internal macro needed for implementing ACTION*().
881#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
882    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
883    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
884    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
885    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
886    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
887    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
888    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
889    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
890    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
891    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
892    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
893
894// Sometimes you want to give an action explicit template parameters
895// that cannot be inferred from its value parameters.  ACTION() and
896// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
897// and can be viewed as an extension to ACTION() and ACTION_P*().
898//
899// The syntax:
900//
901//   ACTION_TEMPLATE(ActionName,
902//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
903//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
904//
905// defines an action template that takes m explicit template
906// parameters and n value parameters.  name_i is the name of the i-th
907// template parameter, and kind_i specifies whether it's a typename,
908// an integral constant, or a template.  p_i is the name of the i-th
909// value parameter.
910//
911// Example:
912//
913//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
914//   // function to type T and copies it to *output.
915//   ACTION_TEMPLATE(DuplicateArg,
916//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
917//                   AND_1_VALUE_PARAMS(output)) {
918//     *output = T(::testing::get<k>(args));
919//   }
920//   ...
921//     int n;
922//     EXPECT_CALL(mock, Foo(_, _))
923//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
924//
925// To create an instance of an action template, write:
926//
927//   ActionName<t1, ..., t_m>(v1, ..., v_n)
928//
929// where the ts are the template arguments and the vs are the value
930// arguments.  The value argument types are inferred by the compiler.
931// If you want to explicitly specify the value argument types, you can
932// provide additional template arguments:
933//
934//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
935//
936// where u_i is the desired type of v_i.
937//
938// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
939// number of value parameters, but not on the number of template
940// parameters.  Without the restriction, the meaning of the following
941// is unclear:
942//
943//   OverloadedAction<int, bool>(x);
944//
945// Are we using a single-template-parameter action where 'bool' refers
946// to the type of x, or are we using a two-template-parameter action
947// where the compiler is asked to infer the type of x?
948//
949// Implementation notes:
950//
951// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
952// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
953// implementing ACTION_TEMPLATE.  The main trick we use is to create
954// new macro invocations when expanding a macro.  For example, we have
955//
956//   #define ACTION_TEMPLATE(name, template_params, value_params)
957//       ... GMOCK_INTERNAL_DECL_##template_params ...
958//
959// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
960// to expand to
961//
962//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
963//
964// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
965// preprocessor will continue to expand it to
966//
967//       ... typename T ...
968//
969// This technique conforms to the C++ standard and is portable.  It
970// allows us to implement action templates using O(N) code, where N is
971// the maximum number of template/value parameters supported.  Without
972// using it, we'd have to devote O(N^2) amount of code to implement all
973// combinations of m and n.
974
975// Declares the template parameters.
976#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
977#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
978    name1) kind0 name0, kind1 name1
979#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
980    kind2, name2) kind0 name0, kind1 name1, kind2 name2
981#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
982    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
983    kind3 name3
984#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
985    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
986    kind2 name2, kind3 name3, kind4 name4
987#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
988    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
989    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
990#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
991    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
992    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
993    kind5 name5, kind6 name6
994#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
995    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
996    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
997    kind4 name4, kind5 name5, kind6 name6, kind7 name7
998#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
999    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1000    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
1001    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
1002    kind8 name8
1003#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1004    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1005    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
1006    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
1007    kind6 name6, kind7 name7, kind8 name8, kind9 name9
1008
1009// Lists the template parameters.
1010#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
1011#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
1012    name1) name0, name1
1013#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1014    kind2, name2) name0, name1, name2
1015#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1016    kind2, name2, kind3, name3) name0, name1, name2, name3
1017#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1018    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
1019    name4
1020#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1021    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
1022    name2, name3, name4, name5
1023#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1024    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1025    name6) name0, name1, name2, name3, name4, name5, name6
1026#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1027    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1028    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
1029#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1030    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1031    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
1032    name6, name7, name8
1033#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1034    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1035    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
1036    name3, name4, name5, name6, name7, name8, name9
1037
1038// Declares the types of value parameters.
1039#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
1040#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
1041#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
1042    typename p0##_type, typename p1##_type
1043#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
1044    typename p0##_type, typename p1##_type, typename p2##_type
1045#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1046    typename p0##_type, typename p1##_type, typename p2##_type, \
1047    typename p3##_type
1048#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1049    typename p0##_type, typename p1##_type, typename p2##_type, \
1050    typename p3##_type, typename p4##_type
1051#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1052    typename p0##_type, typename p1##_type, typename p2##_type, \
1053    typename p3##_type, typename p4##_type, typename p5##_type
1054#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1055    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
1056    typename p3##_type, typename p4##_type, typename p5##_type, \
1057    typename p6##_type
1058#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1059    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
1060    typename p3##_type, typename p4##_type, typename p5##_type, \
1061    typename p6##_type, typename p7##_type
1062#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1063    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
1064    typename p3##_type, typename p4##_type, typename p5##_type, \
1065    typename p6##_type, typename p7##_type, typename p8##_type
1066#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1067    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
1068    typename p2##_type, typename p3##_type, typename p4##_type, \
1069    typename p5##_type, typename p6##_type, typename p7##_type, \
1070    typename p8##_type, typename p9##_type
1071
1072// Initializes the value parameters.
1073#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
1074    ()
1075#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
1076    (p0##_type gmock_p0) : p0(gmock_p0)
1077#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
1078    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1)
1079#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
1080    (p0##_type gmock_p0, p1##_type gmock_p1, \
1081        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2)
1082#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
1083    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1084        p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1085        p3(gmock_p3)
1086#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
1087    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1088        p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \
1089        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4)
1090#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
1091    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1092        p3##_type gmock_p3, p4##_type gmock_p4, \
1093        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1094        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5)
1095#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
1096    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1097        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1098        p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1099        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6)
1100#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
1101    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1102        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1103        p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \
1104        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1105        p7(gmock_p7)
1106#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1107    p7, p8)\
1108    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1109        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1110        p6##_type gmock_p6, p7##_type gmock_p7, \
1111        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1112        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1113        p8(gmock_p8)
1114#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1115    p7, p8, p9)\
1116    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1117        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1118        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
1119        p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1120        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1121        p8(gmock_p8), p9(gmock_p9)
1122
1123// Declares the fields for storing the value parameters.
1124#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
1125#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
1126#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
1127    p1##_type p1;
1128#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
1129    p1##_type p1; p2##_type p2;
1130#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
1131    p1##_type p1; p2##_type p2; p3##_type p3;
1132#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1133    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
1134#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1135    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1136    p5##_type p5;
1137#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1138    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1139    p5##_type p5; p6##_type p6;
1140#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1141    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1142    p5##_type p5; p6##_type p6; p7##_type p7;
1143#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1144    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1145    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
1146#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1147    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1148    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
1149    p9##_type p9;
1150
1151// Lists the value parameters.
1152#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
1153#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
1154#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
1155#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
1156#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
1157#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
1158    p2, p3, p4
1159#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
1160    p1, p2, p3, p4, p5
1161#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1162    p6) p0, p1, p2, p3, p4, p5, p6
1163#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1164    p7) p0, p1, p2, p3, p4, p5, p6, p7
1165#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1166    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
1167#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1168    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
1169
1170// Lists the value parameter types.
1171#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
1172#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
1173#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
1174    p1##_type
1175#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
1176    p1##_type, p2##_type
1177#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1178    p0##_type, p1##_type, p2##_type, p3##_type
1179#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1180    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
1181#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1182    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
1183#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1184    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
1185    p6##_type
1186#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1187    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1188    p5##_type, p6##_type, p7##_type
1189#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1190    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1191    p5##_type, p6##_type, p7##_type, p8##_type
1192#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1193    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1194    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
1195
1196// Declares the value parameters.
1197#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
1198#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
1199#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
1200    p1##_type p1
1201#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
1202    p1##_type p1, p2##_type p2
1203#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
1204    p1##_type p1, p2##_type p2, p3##_type p3
1205#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1206    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
1207#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1208    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1209    p5##_type p5
1210#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1211    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1212    p5##_type p5, p6##_type p6
1213#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1214    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1215    p5##_type p5, p6##_type p6, p7##_type p7
1216#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1217    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1218    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
1219#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1220    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1221    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
1222    p9##_type p9
1223
1224// The suffix of the class template implementing the action template.
1225#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
1226#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
1227#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
1228#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
1229#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
1230#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
1231#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
1232#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
1233#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1234    p7) P8
1235#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1236    p7, p8) P9
1237#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1238    p7, p8, p9) P10
1239
1240// The name of the class template implementing the action template.
1241#define GMOCK_ACTION_CLASS_(name, value_params)\
1242    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
1243
1244#define ACTION_TEMPLATE(name, template_params, value_params)\
1245  template <GMOCK_INTERNAL_DECL_##template_params\
1246            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1247  class GMOCK_ACTION_CLASS_(name, value_params) {\
1248   public:\
1249    explicit GMOCK_ACTION_CLASS_(name, value_params)\
1250        GMOCK_INTERNAL_INIT_##value_params {}\
1251    template <typename F>\
1252    class gmock_Impl : public ::testing::ActionInterface<F> {\
1253     public:\
1254      typedef F function_type;\
1255      typedef typename ::testing::internal::Function<F>::Result return_type;\
1256      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1257          args_type;\
1258      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
1259      virtual return_type Perform(const args_type& args) {\
1260        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1261            Perform(this, args);\
1262      }\
1263      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1264          typename arg3_type, typename arg4_type, typename arg5_type, \
1265          typename arg6_type, typename arg7_type, typename arg8_type, \
1266          typename arg9_type>\
1267      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1268          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1269          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1270          arg9_type arg9) const;\
1271      GMOCK_INTERNAL_DEFN_##value_params\
1272     private:\
1273      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1274    };\
1275    template <typename F> operator ::testing::Action<F>() const {\
1276      return ::testing::Action<F>(\
1277          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
1278    }\
1279    GMOCK_INTERNAL_DEFN_##value_params\
1280   private:\
1281    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
1282  };\
1283  template <GMOCK_INTERNAL_DECL_##template_params\
1284            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1285  inline GMOCK_ACTION_CLASS_(name, value_params)<\
1286      GMOCK_INTERNAL_LIST_##template_params\
1287      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
1288          GMOCK_INTERNAL_DECL_##value_params) {\
1289    return GMOCK_ACTION_CLASS_(name, value_params)<\
1290        GMOCK_INTERNAL_LIST_##template_params\
1291        GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
1292            GMOCK_INTERNAL_LIST_##value_params);\
1293  }\
1294  template <GMOCK_INTERNAL_DECL_##template_params\
1295            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1296  template <typename F>\
1297  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1298      typename arg3_type, typename arg4_type, typename arg5_type, \
1299      typename arg6_type, typename arg7_type, typename arg8_type, \
1300      typename arg9_type>\
1301  typename ::testing::internal::Function<F>::Result\
1302      GMOCK_ACTION_CLASS_(name, value_params)<\
1303          GMOCK_INTERNAL_LIST_##template_params\
1304          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
1305              gmock_PerformImpl(\
1306          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1307
1308#define ACTION(name)\
1309  class name##Action {\
1310   public:\
1311    name##Action() {}\
1312    template <typename F>\
1313    class gmock_Impl : public ::testing::ActionInterface<F> {\
1314     public:\
1315      typedef F function_type;\
1316      typedef typename ::testing::internal::Function<F>::Result return_type;\
1317      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1318          args_type;\
1319      gmock_Impl() {}\
1320      virtual return_type Perform(const args_type& args) {\
1321        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1322            Perform(this, args);\
1323      }\
1324      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1325          typename arg3_type, typename arg4_type, typename arg5_type, \
1326          typename arg6_type, typename arg7_type, typename arg8_type, \
1327          typename arg9_type>\
1328      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1329          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1330          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1331          arg9_type arg9) const;\
1332     private:\
1333      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1334    };\
1335    template <typename F> operator ::testing::Action<F>() const {\
1336      return ::testing::Action<F>(new gmock_Impl<F>());\
1337    }\
1338   private:\
1339    GTEST_DISALLOW_ASSIGN_(name##Action);\
1340  };\
1341  inline name##Action name() {\
1342    return name##Action();\
1343  }\
1344  template <typename F>\
1345  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1346      typename arg3_type, typename arg4_type, typename arg5_type, \
1347      typename arg6_type, typename arg7_type, typename arg8_type, \
1348      typename arg9_type>\
1349  typename ::testing::internal::Function<F>::Result\
1350      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
1351          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1352
1353#define ACTION_P(name, p0)\
1354  template <typename p0##_type>\
1355  class name##ActionP {\
1356   public:\
1357    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
1358    template <typename F>\
1359    class gmock_Impl : public ::testing::ActionInterface<F> {\
1360     public:\
1361      typedef F function_type;\
1362      typedef typename ::testing::internal::Function<F>::Result return_type;\
1363      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1364          args_type;\
1365      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
1366      virtual return_type Perform(const args_type& args) {\
1367        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1368            Perform(this, args);\
1369      }\
1370      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1371          typename arg3_type, typename arg4_type, typename arg5_type, \
1372          typename arg6_type, typename arg7_type, typename arg8_type, \
1373          typename arg9_type>\
1374      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1375          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1376          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1377          arg9_type arg9) const;\
1378      p0##_type p0;\
1379     private:\
1380      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1381    };\
1382    template <typename F> operator ::testing::Action<F>() const {\
1383      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
1384    }\
1385    p0##_type p0;\
1386   private:\
1387    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
1388  };\
1389  template <typename p0##_type>\
1390  inline name##ActionP<p0##_type> name(p0##_type p0) {\
1391    return name##ActionP<p0##_type>(p0);\
1392  }\
1393  template <typename p0##_type>\
1394  template <typename F>\
1395  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1396      typename arg3_type, typename arg4_type, typename arg5_type, \
1397      typename arg6_type, typename arg7_type, typename arg8_type, \
1398      typename arg9_type>\
1399  typename ::testing::internal::Function<F>::Result\
1400      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1401          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1402
1403#define ACTION_P2(name, p0, p1)\
1404  template <typename p0##_type, typename p1##_type>\
1405  class name##ActionP2 {\
1406   public:\
1407    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1408        p1(gmock_p1) {}\
1409    template <typename F>\
1410    class gmock_Impl : public ::testing::ActionInterface<F> {\
1411     public:\
1412      typedef F function_type;\
1413      typedef typename ::testing::internal::Function<F>::Result return_type;\
1414      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1415          args_type;\
1416      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1417          p1(gmock_p1) {}\
1418      virtual return_type Perform(const args_type& args) {\
1419        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1420            Perform(this, args);\
1421      }\
1422      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1423          typename arg3_type, typename arg4_type, typename arg5_type, \
1424          typename arg6_type, typename arg7_type, typename arg8_type, \
1425          typename arg9_type>\
1426      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1427          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1428          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1429          arg9_type arg9) const;\
1430      p0##_type p0;\
1431      p1##_type p1;\
1432     private:\
1433      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1434    };\
1435    template <typename F> operator ::testing::Action<F>() const {\
1436      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
1437    }\
1438    p0##_type p0;\
1439    p1##_type p1;\
1440   private:\
1441    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
1442  };\
1443  template <typename p0##_type, typename p1##_type>\
1444  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
1445      p1##_type p1) {\
1446    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
1447  }\
1448  template <typename p0##_type, typename p1##_type>\
1449  template <typename F>\
1450  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1451      typename arg3_type, typename arg4_type, typename arg5_type, \
1452      typename arg6_type, typename arg7_type, typename arg8_type, \
1453      typename arg9_type>\
1454  typename ::testing::internal::Function<F>::Result\
1455      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1456          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1457
1458#define ACTION_P3(name, p0, p1, p2)\
1459  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1460  class name##ActionP3 {\
1461   public:\
1462    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1463        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1464    template <typename F>\
1465    class gmock_Impl : public ::testing::ActionInterface<F> {\
1466     public:\
1467      typedef F function_type;\
1468      typedef typename ::testing::internal::Function<F>::Result return_type;\
1469      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1470          args_type;\
1471      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
1472          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1473      virtual return_type Perform(const args_type& args) {\
1474        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1475            Perform(this, args);\
1476      }\
1477      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1478          typename arg3_type, typename arg4_type, typename arg5_type, \
1479          typename arg6_type, typename arg7_type, typename arg8_type, \
1480          typename arg9_type>\
1481      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1482          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1483          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1484          arg9_type arg9) const;\
1485      p0##_type p0;\
1486      p1##_type p1;\
1487      p2##_type p2;\
1488     private:\
1489      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1490    };\
1491    template <typename F> operator ::testing::Action<F>() const {\
1492      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
1493    }\
1494    p0##_type p0;\
1495    p1##_type p1;\
1496    p2##_type p2;\
1497   private:\
1498    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
1499  };\
1500  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1501  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1502      p1##_type p1, p2##_type p2) {\
1503    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1504  }\
1505  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1506  template <typename F>\
1507  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1508      typename arg3_type, typename arg4_type, typename arg5_type, \
1509      typename arg6_type, typename arg7_type, typename arg8_type, \
1510      typename arg9_type>\
1511  typename ::testing::internal::Function<F>::Result\
1512      name##ActionP3<p0##_type, p1##_type, \
1513          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1514          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1515
1516#define ACTION_P4(name, p0, p1, p2, p3)\
1517  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1518      typename p3##_type>\
1519  class name##ActionP4 {\
1520   public:\
1521    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1522        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
1523        p2(gmock_p2), p3(gmock_p3) {}\
1524    template <typename F>\
1525    class gmock_Impl : public ::testing::ActionInterface<F> {\
1526     public:\
1527      typedef F function_type;\
1528      typedef typename ::testing::internal::Function<F>::Result return_type;\
1529      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1530          args_type;\
1531      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1532          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1533          p3(gmock_p3) {}\
1534      virtual return_type Perform(const args_type& args) {\
1535        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1536            Perform(this, args);\
1537      }\
1538      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1539          typename arg3_type, typename arg4_type, typename arg5_type, \
1540          typename arg6_type, typename arg7_type, typename arg8_type, \
1541          typename arg9_type>\
1542      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1543          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1544          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1545          arg9_type arg9) const;\
1546      p0##_type p0;\
1547      p1##_type p1;\
1548      p2##_type p2;\
1549      p3##_type p3;\
1550     private:\
1551      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1552    };\
1553    template <typename F> operator ::testing::Action<F>() const {\
1554      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
1555    }\
1556    p0##_type p0;\
1557    p1##_type p1;\
1558    p2##_type p2;\
1559    p3##_type p3;\
1560   private:\
1561    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
1562  };\
1563  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1564      typename p3##_type>\
1565  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
1566      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1567      p3##_type p3) {\
1568    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
1569        p2, p3);\
1570  }\
1571  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1572      typename p3##_type>\
1573  template <typename F>\
1574  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1575      typename arg3_type, typename arg4_type, typename arg5_type, \
1576      typename arg6_type, typename arg7_type, typename arg8_type, \
1577      typename arg9_type>\
1578  typename ::testing::internal::Function<F>::Result\
1579      name##ActionP4<p0##_type, p1##_type, p2##_type, \
1580          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1581          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1582
1583#define ACTION_P5(name, p0, p1, p2, p3, p4)\
1584  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1585      typename p3##_type, typename p4##_type>\
1586  class name##ActionP5 {\
1587   public:\
1588    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1589        p2##_type gmock_p2, p3##_type gmock_p3, \
1590        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1591        p3(gmock_p3), p4(gmock_p4) {}\
1592    template <typename F>\
1593    class gmock_Impl : public ::testing::ActionInterface<F> {\
1594     public:\
1595      typedef F function_type;\
1596      typedef typename ::testing::internal::Function<F>::Result return_type;\
1597      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1598          args_type;\
1599      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1600          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
1601          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
1602      virtual return_type Perform(const args_type& args) {\
1603        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1604            Perform(this, args);\
1605      }\
1606      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1607          typename arg3_type, typename arg4_type, typename arg5_type, \
1608          typename arg6_type, typename arg7_type, typename arg8_type, \
1609          typename arg9_type>\
1610      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1611          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1612          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1613          arg9_type arg9) const;\
1614      p0##_type p0;\
1615      p1##_type p1;\
1616      p2##_type p2;\
1617      p3##_type p3;\
1618      p4##_type p4;\
1619     private:\
1620      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1621    };\
1622    template <typename F> operator ::testing::Action<F>() const {\
1623      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
1624    }\
1625    p0##_type p0;\
1626    p1##_type p1;\
1627    p2##_type p2;\
1628    p3##_type p3;\
1629    p4##_type p4;\
1630   private:\
1631    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
1632  };\
1633  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1634      typename p3##_type, typename p4##_type>\
1635  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1636      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1637      p4##_type p4) {\
1638    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1639        p4##_type>(p0, p1, p2, p3, p4);\
1640  }\
1641  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1642      typename p3##_type, typename p4##_type>\
1643  template <typename F>\
1644  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1645      typename arg3_type, typename arg4_type, typename arg5_type, \
1646      typename arg6_type, typename arg7_type, typename arg8_type, \
1647      typename arg9_type>\
1648  typename ::testing::internal::Function<F>::Result\
1649      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1650          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1651          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1652
1653#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
1654  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1655      typename p3##_type, typename p4##_type, typename p5##_type>\
1656  class name##ActionP6 {\
1657   public:\
1658    name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1659        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1660        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1661        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1662    template <typename F>\
1663    class gmock_Impl : public ::testing::ActionInterface<F> {\
1664     public:\
1665      typedef F function_type;\
1666      typedef typename ::testing::internal::Function<F>::Result return_type;\
1667      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1668          args_type;\
1669      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1670          p3##_type gmock_p3, p4##_type gmock_p4, \
1671          p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1672          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1673      virtual return_type Perform(const args_type& args) {\
1674        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1675            Perform(this, args);\
1676      }\
1677      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1678          typename arg3_type, typename arg4_type, typename arg5_type, \
1679          typename arg6_type, typename arg7_type, typename arg8_type, \
1680          typename arg9_type>\
1681      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1682          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1683          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1684          arg9_type arg9) const;\
1685      p0##_type p0;\
1686      p1##_type p1;\
1687      p2##_type p2;\
1688      p3##_type p3;\
1689      p4##_type p4;\
1690      p5##_type p5;\
1691     private:\
1692      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1693    };\
1694    template <typename F> operator ::testing::Action<F>() const {\
1695      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
1696    }\
1697    p0##_type p0;\
1698    p1##_type p1;\
1699    p2##_type p2;\
1700    p3##_type p3;\
1701    p4##_type p4;\
1702    p5##_type p5;\
1703   private:\
1704    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
1705  };\
1706  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1707      typename p3##_type, typename p4##_type, typename p5##_type>\
1708  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1709      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1710      p3##_type p3, p4##_type p4, p5##_type p5) {\
1711    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1712        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1713  }\
1714  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1715      typename p3##_type, typename p4##_type, typename p5##_type>\
1716  template <typename F>\
1717  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1718      typename arg3_type, typename arg4_type, typename arg5_type, \
1719      typename arg6_type, typename arg7_type, typename arg8_type, \
1720      typename arg9_type>\
1721  typename ::testing::internal::Function<F>::Result\
1722      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1723          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1724          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1725
1726#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
1727  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1728      typename p3##_type, typename p4##_type, typename p5##_type, \
1729      typename p6##_type>\
1730  class name##ActionP7 {\
1731   public:\
1732    name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1733        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1734        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
1735        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
1736        p6(gmock_p6) {}\
1737    template <typename F>\
1738    class gmock_Impl : public ::testing::ActionInterface<F> {\
1739     public:\
1740      typedef F function_type;\
1741      typedef typename ::testing::internal::Function<F>::Result return_type;\
1742      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1743          args_type;\
1744      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1745          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1746          p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1747          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
1748      virtual return_type Perform(const args_type& args) {\
1749        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1750            Perform(this, args);\
1751      }\
1752      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1753          typename arg3_type, typename arg4_type, typename arg5_type, \
1754          typename arg6_type, typename arg7_type, typename arg8_type, \
1755          typename arg9_type>\
1756      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1757          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1758          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1759          arg9_type arg9) const;\
1760      p0##_type p0;\
1761      p1##_type p1;\
1762      p2##_type p2;\
1763      p3##_type p3;\
1764      p4##_type p4;\
1765      p5##_type p5;\
1766      p6##_type p6;\
1767     private:\
1768      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1769    };\
1770    template <typename F> operator ::testing::Action<F>() const {\
1771      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1772          p6));\
1773    }\
1774    p0##_type p0;\
1775    p1##_type p1;\
1776    p2##_type p2;\
1777    p3##_type p3;\
1778    p4##_type p4;\
1779    p5##_type p5;\
1780    p6##_type p6;\
1781   private:\
1782    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
1783  };\
1784  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1785      typename p3##_type, typename p4##_type, typename p5##_type, \
1786      typename p6##_type>\
1787  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1788      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1789      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1790      p6##_type p6) {\
1791    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1792        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1793  }\
1794  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1795      typename p3##_type, typename p4##_type, typename p5##_type, \
1796      typename p6##_type>\
1797  template <typename F>\
1798  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1799      typename arg3_type, typename arg4_type, typename arg5_type, \
1800      typename arg6_type, typename arg7_type, typename arg8_type, \
1801      typename arg9_type>\
1802  typename ::testing::internal::Function<F>::Result\
1803      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1804          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1805          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1806
1807#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
1808  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1809      typename p3##_type, typename p4##_type, typename p5##_type, \
1810      typename p6##_type, typename p7##_type>\
1811  class name##ActionP8 {\
1812   public:\
1813    name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1814        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1815        p5##_type gmock_p5, p6##_type gmock_p6, \
1816        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1817        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1818        p7(gmock_p7) {}\
1819    template <typename F>\
1820    class gmock_Impl : public ::testing::ActionInterface<F> {\
1821     public:\
1822      typedef F function_type;\
1823      typedef typename ::testing::internal::Function<F>::Result return_type;\
1824      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1825          args_type;\
1826      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1827          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1828          p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \
1829          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
1830          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
1831      virtual return_type Perform(const args_type& args) {\
1832        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1833            Perform(this, args);\
1834      }\
1835      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1836          typename arg3_type, typename arg4_type, typename arg5_type, \
1837          typename arg6_type, typename arg7_type, typename arg8_type, \
1838          typename arg9_type>\
1839      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1840          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1841          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1842          arg9_type arg9) const;\
1843      p0##_type p0;\
1844      p1##_type p1;\
1845      p2##_type p2;\
1846      p3##_type p3;\
1847      p4##_type p4;\
1848      p5##_type p5;\
1849      p6##_type p6;\
1850      p7##_type p7;\
1851     private:\
1852      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1853    };\
1854    template <typename F> operator ::testing::Action<F>() const {\
1855      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1856          p6, p7));\
1857    }\
1858    p0##_type p0;\
1859    p1##_type p1;\
1860    p2##_type p2;\
1861    p3##_type p3;\
1862    p4##_type p4;\
1863    p5##_type p5;\
1864    p6##_type p6;\
1865    p7##_type p7;\
1866   private:\
1867    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
1868  };\
1869  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1870      typename p3##_type, typename p4##_type, typename p5##_type, \
1871      typename p6##_type, typename p7##_type>\
1872  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1873      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
1874      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1875      p6##_type p6, p7##_type p7) {\
1876    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1877        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
1878        p6, p7);\
1879  }\
1880  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1881      typename p3##_type, typename p4##_type, typename p5##_type, \
1882      typename p6##_type, typename p7##_type>\
1883  template <typename F>\
1884  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1885      typename arg3_type, typename arg4_type, typename arg5_type, \
1886      typename arg6_type, typename arg7_type, typename arg8_type, \
1887      typename arg9_type>\
1888  typename ::testing::internal::Function<F>::Result\
1889      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1890          p5##_type, p6##_type, \
1891          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1892          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1893
1894#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
1895  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1896      typename p3##_type, typename p4##_type, typename p5##_type, \
1897      typename p6##_type, typename p7##_type, typename p8##_type>\
1898  class name##ActionP9 {\
1899   public:\
1900    name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
1901        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1902        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1903        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1904        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1905        p8(gmock_p8) {}\
1906    template <typename F>\
1907    class gmock_Impl : public ::testing::ActionInterface<F> {\
1908     public:\
1909      typedef F function_type;\
1910      typedef typename ::testing::internal::Function<F>::Result return_type;\
1911      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1912          args_type;\
1913      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1914          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1915          p6##_type gmock_p6, p7##_type gmock_p7, \
1916          p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1917          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1918          p7(gmock_p7), p8(gmock_p8) {}\
1919      virtual return_type Perform(const args_type& args) {\
1920        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1921            Perform(this, args);\
1922      }\
1923      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1924          typename arg3_type, typename arg4_type, typename arg5_type, \
1925          typename arg6_type, typename arg7_type, typename arg8_type, \
1926          typename arg9_type>\
1927      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1928          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1929          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1930          arg9_type arg9) const;\
1931      p0##_type p0;\
1932      p1##_type p1;\
1933      p2##_type p2;\
1934      p3##_type p3;\
1935      p4##_type p4;\
1936      p5##_type p5;\
1937      p6##_type p6;\
1938      p7##_type p7;\
1939      p8##_type p8;\
1940     private:\
1941      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1942    };\
1943    template <typename F> operator ::testing::Action<F>() const {\
1944      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1945          p6, p7, p8));\
1946    }\
1947    p0##_type p0;\
1948    p1##_type p1;\
1949    p2##_type p2;\
1950    p3##_type p3;\
1951    p4##_type p4;\
1952    p5##_type p5;\
1953    p6##_type p6;\
1954    p7##_type p7;\
1955    p8##_type p8;\
1956   private:\
1957    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
1958  };\
1959  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1960      typename p3##_type, typename p4##_type, typename p5##_type, \
1961      typename p6##_type, typename p7##_type, typename p8##_type>\
1962  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1963      p4##_type, p5##_type, p6##_type, p7##_type, \
1964      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1965      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
1966      p8##_type p8) {\
1967    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1968        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
1969        p3, p4, p5, p6, p7, p8);\
1970  }\
1971  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1972      typename p3##_type, typename p4##_type, typename p5##_type, \
1973      typename p6##_type, typename p7##_type, typename p8##_type>\
1974  template <typename F>\
1975  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1976      typename arg3_type, typename arg4_type, typename arg5_type, \
1977      typename arg6_type, typename arg7_type, typename arg8_type, \
1978      typename arg9_type>\
1979  typename ::testing::internal::Function<F>::Result\
1980      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1981          p5##_type, p6##_type, p7##_type, \
1982          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1983          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1984
1985#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
1986  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1987      typename p3##_type, typename p4##_type, typename p5##_type, \
1988      typename p6##_type, typename p7##_type, typename p8##_type, \
1989      typename p9##_type>\
1990  class name##ActionP10 {\
1991   public:\
1992    name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \
1993        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1994        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1995        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
1996        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1997        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
1998    template <typename F>\
1999    class gmock_Impl : public ::testing::ActionInterface<F> {\
2000     public:\
2001      typedef F function_type;\
2002      typedef typename ::testing::internal::Function<F>::Result return_type;\
2003      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
2004          args_type;\
2005      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2006          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2007          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2008          p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
2009          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
2010          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
2011      virtual return_type Perform(const args_type& args) {\
2012        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
2013            Perform(this, args);\
2014      }\
2015      template <typename arg0_type, typename arg1_type, typename arg2_type, \
2016          typename arg3_type, typename arg4_type, typename arg5_type, \
2017          typename arg6_type, typename arg7_type, typename arg8_type, \
2018          typename arg9_type>\
2019      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
2020          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
2021          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
2022          arg9_type arg9) const;\
2023      p0##_type p0;\
2024      p1##_type p1;\
2025      p2##_type p2;\
2026      p3##_type p3;\
2027      p4##_type p4;\
2028      p5##_type p5;\
2029      p6##_type p6;\
2030      p7##_type p7;\
2031      p8##_type p8;\
2032      p9##_type p9;\
2033     private:\
2034      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2035    };\
2036    template <typename F> operator ::testing::Action<F>() const {\
2037      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
2038          p6, p7, p8, p9));\
2039    }\
2040    p0##_type p0;\
2041    p1##_type p1;\
2042    p2##_type p2;\
2043    p3##_type p3;\
2044    p4##_type p4;\
2045    p5##_type p5;\
2046    p6##_type p6;\
2047    p7##_type p7;\
2048    p8##_type p8;\
2049    p9##_type p9;\
2050   private:\
2051    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
2052  };\
2053  template <typename p0##_type, typename p1##_type, typename p2##_type, \
2054      typename p3##_type, typename p4##_type, typename p5##_type, \
2055      typename p6##_type, typename p7##_type, typename p8##_type, \
2056      typename p9##_type>\
2057  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2058      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2059      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2060      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2061      p9##_type p9) {\
2062    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2063        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2064        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2065  }\
2066  template <typename p0##_type, typename p1##_type, typename p2##_type, \
2067      typename p3##_type, typename p4##_type, typename p5##_type, \
2068      typename p6##_type, typename p7##_type, typename p8##_type, \
2069      typename p9##_type>\
2070  template <typename F>\
2071  template <typename arg0_type, typename arg1_type, typename arg2_type, \
2072      typename arg3_type, typename arg4_type, typename arg5_type, \
2073      typename arg6_type, typename arg7_type, typename arg8_type, \
2074      typename arg9_type>\
2075  typename ::testing::internal::Function<F>::Result\
2076      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2077          p5##_type, p6##_type, p7##_type, p8##_type, \
2078          p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\
2079          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
2080
2081namespace testing {
2082
2083
2084// The ACTION*() macros trigger warning C4100 (unreferenced formal
2085// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
2086// the macro definition, as the warnings are generated when the macro
2087// is expanded and macro expansion cannot contain #pragma.  Therefore
2088// we suppress them here.
2089#ifdef _MSC_VER
2090# pragma warning(push)
2091# pragma warning(disable:4100)
2092#endif
2093
2094// Various overloads for InvokeArgument<N>().
2095//
2096// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
2097// (0-based) argument, which must be a k-ary callable, of the mock
2098// function, with arguments a1, a2, ..., a_k.
2099//
2100// Notes:
2101//
2102//   1. The arguments are passed by value by default.  If you need to
2103//   pass an argument by reference, wrap it inside ByRef().  For
2104//   example,
2105//
2106//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
2107//
2108//   passes 5 and string("Hello") by value, and passes foo by
2109//   reference.
2110//
2111//   2. If the callable takes an argument by reference but ByRef() is
2112//   not used, it will receive the reference to a copy of the value,
2113//   instead of the original value.  For example, when the 0-th
2114//   argument of the mock function takes a const string&, the action
2115//
2116//     InvokeArgument<0>(string("Hello"))
2117//
2118//   makes a copy of the temporary string("Hello") object and passes a
2119//   reference of the copy, instead of the original temporary object,
2120//   to the callable.  This makes it easy for a user to define an
2121//   InvokeArgument action from temporary values and have it performed
2122//   later.
2123
2124namespace internal {
2125namespace invoke_argument {
2126
2127// Appears in InvokeArgumentAdl's argument list to help avoid
2128// accidental calls to user functions of the same name.
2129struct AdlTag {};
2130
2131// InvokeArgumentAdl - a helper for InvokeArgument.
2132// The basic overloads are provided here for generic functors.
2133// Overloads for other custom-callables are provided in the
2134// internal/custom/callback-actions.h header.
2135
2136template <typename R, typename F>
2137R InvokeArgumentAdl(AdlTag, F f) {
2138  return f();
2139}
2140template <typename R, typename F, typename A1>
2141R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
2142  return f(a1);
2143}
2144template <typename R, typename F, typename A1, typename A2>
2145R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
2146  return f(a1, a2);
2147}
2148template <typename R, typename F, typename A1, typename A2, typename A3>
2149R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
2150  return f(a1, a2, a3);
2151}
2152template <typename R, typename F, typename A1, typename A2, typename A3,
2153    typename A4>
2154R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
2155  return f(a1, a2, a3, a4);
2156}
2157template <typename R, typename F, typename A1, typename A2, typename A3,
2158    typename A4, typename A5>
2159R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
2160  return f(a1, a2, a3, a4, a5);
2161}
2162template <typename R, typename F, typename A1, typename A2, typename A3,
2163    typename A4, typename A5, typename A6>
2164R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
2165  return f(a1, a2, a3, a4, a5, a6);
2166}
2167template <typename R, typename F, typename A1, typename A2, typename A3,
2168    typename A4, typename A5, typename A6, typename A7>
2169R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2170    A7 a7) {
2171  return f(a1, a2, a3, a4, a5, a6, a7);
2172}
2173template <typename R, typename F, typename A1, typename A2, typename A3,
2174    typename A4, typename A5, typename A6, typename A7, typename A8>
2175R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2176    A7 a7, A8 a8) {
2177  return f(a1, a2, a3, a4, a5, a6, a7, a8);
2178}
2179template <typename R, typename F, typename A1, typename A2, typename A3,
2180    typename A4, typename A5, typename A6, typename A7, typename A8,
2181    typename A9>
2182R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2183    A7 a7, A8 a8, A9 a9) {
2184  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2185}
2186template <typename R, typename F, typename A1, typename A2, typename A3,
2187    typename A4, typename A5, typename A6, typename A7, typename A8,
2188    typename A9, typename A10>
2189R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2190    A7 a7, A8 a8, A9 a9, A10 a10) {
2191  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2192}
2193}  // namespace invoke_argument
2194}  // namespace internal
2195
2196ACTION_TEMPLATE(InvokeArgument,
2197                HAS_1_TEMPLATE_PARAMS(int, k),
2198                AND_0_VALUE_PARAMS()) {
2199  using internal::invoke_argument::InvokeArgumentAdl;
2200  return InvokeArgumentAdl<return_type>(
2201      internal::invoke_argument::AdlTag(),
2202      ::testing::get<k>(args));
2203}
2204
2205ACTION_TEMPLATE(InvokeArgument,
2206                HAS_1_TEMPLATE_PARAMS(int, k),
2207                AND_1_VALUE_PARAMS(p0)) {
2208  using internal::invoke_argument::InvokeArgumentAdl;
2209  return InvokeArgumentAdl<return_type>(
2210      internal::invoke_argument::AdlTag(),
2211      ::testing::get<k>(args), p0);
2212}
2213
2214ACTION_TEMPLATE(InvokeArgument,
2215                HAS_1_TEMPLATE_PARAMS(int, k),
2216                AND_2_VALUE_PARAMS(p0, p1)) {
2217  using internal::invoke_argument::InvokeArgumentAdl;
2218  return InvokeArgumentAdl<return_type>(
2219      internal::invoke_argument::AdlTag(),
2220      ::testing::get<k>(args), p0, p1);
2221}
2222
2223ACTION_TEMPLATE(InvokeArgument,
2224                HAS_1_TEMPLATE_PARAMS(int, k),
2225                AND_3_VALUE_PARAMS(p0, p1, p2)) {
2226  using internal::invoke_argument::InvokeArgumentAdl;
2227  return InvokeArgumentAdl<return_type>(
2228      internal::invoke_argument::AdlTag(),
2229      ::testing::get<k>(args), p0, p1, p2);
2230}
2231
2232ACTION_TEMPLATE(InvokeArgument,
2233                HAS_1_TEMPLATE_PARAMS(int, k),
2234                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2235  using internal::invoke_argument::InvokeArgumentAdl;
2236  return InvokeArgumentAdl<return_type>(
2237      internal::invoke_argument::AdlTag(),
2238      ::testing::get<k>(args), p0, p1, p2, p3);
2239}
2240
2241ACTION_TEMPLATE(InvokeArgument,
2242                HAS_1_TEMPLATE_PARAMS(int, k),
2243                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2244  using internal::invoke_argument::InvokeArgumentAdl;
2245  return InvokeArgumentAdl<return_type>(
2246      internal::invoke_argument::AdlTag(),
2247      ::testing::get<k>(args), p0, p1, p2, p3, p4);
2248}
2249
2250ACTION_TEMPLATE(InvokeArgument,
2251                HAS_1_TEMPLATE_PARAMS(int, k),
2252                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2253  using internal::invoke_argument::InvokeArgumentAdl;
2254  return InvokeArgumentAdl<return_type>(
2255      internal::invoke_argument::AdlTag(),
2256      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
2257}
2258
2259ACTION_TEMPLATE(InvokeArgument,
2260                HAS_1_TEMPLATE_PARAMS(int, k),
2261                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2262  using internal::invoke_argument::InvokeArgumentAdl;
2263  return InvokeArgumentAdl<return_type>(
2264      internal::invoke_argument::AdlTag(),
2265      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
2266}
2267
2268ACTION_TEMPLATE(InvokeArgument,
2269                HAS_1_TEMPLATE_PARAMS(int, k),
2270                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2271  using internal::invoke_argument::InvokeArgumentAdl;
2272  return InvokeArgumentAdl<return_type>(
2273      internal::invoke_argument::AdlTag(),
2274      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
2275}
2276
2277ACTION_TEMPLATE(InvokeArgument,
2278                HAS_1_TEMPLATE_PARAMS(int, k),
2279                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2280  using internal::invoke_argument::InvokeArgumentAdl;
2281  return InvokeArgumentAdl<return_type>(
2282      internal::invoke_argument::AdlTag(),
2283      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
2284}
2285
2286ACTION_TEMPLATE(InvokeArgument,
2287                HAS_1_TEMPLATE_PARAMS(int, k),
2288                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2289  using internal::invoke_argument::InvokeArgumentAdl;
2290  return InvokeArgumentAdl<return_type>(
2291      internal::invoke_argument::AdlTag(),
2292      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2293}
2294
2295// Various overloads for ReturnNew<T>().
2296//
2297// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
2298// instance of type T, constructed on the heap with constructor arguments
2299// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
2300ACTION_TEMPLATE(ReturnNew,
2301                HAS_1_TEMPLATE_PARAMS(typename, T),
2302                AND_0_VALUE_PARAMS()) {
2303  return new T();
2304}
2305
2306ACTION_TEMPLATE(ReturnNew,
2307                HAS_1_TEMPLATE_PARAMS(typename, T),
2308                AND_1_VALUE_PARAMS(p0)) {
2309  return new T(p0);
2310}
2311
2312ACTION_TEMPLATE(ReturnNew,
2313                HAS_1_TEMPLATE_PARAMS(typename, T),
2314                AND_2_VALUE_PARAMS(p0, p1)) {
2315  return new T(p0, p1);
2316}
2317
2318ACTION_TEMPLATE(ReturnNew,
2319                HAS_1_TEMPLATE_PARAMS(typename, T),
2320                AND_3_VALUE_PARAMS(p0, p1, p2)) {
2321  return new T(p0, p1, p2);
2322}
2323
2324ACTION_TEMPLATE(ReturnNew,
2325                HAS_1_TEMPLATE_PARAMS(typename, T),
2326                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2327  return new T(p0, p1, p2, p3);
2328}
2329
2330ACTION_TEMPLATE(ReturnNew,
2331                HAS_1_TEMPLATE_PARAMS(typename, T),
2332                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2333  return new T(p0, p1, p2, p3, p4);
2334}
2335
2336ACTION_TEMPLATE(ReturnNew,
2337                HAS_1_TEMPLATE_PARAMS(typename, T),
2338                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2339  return new T(p0, p1, p2, p3, p4, p5);
2340}
2341
2342ACTION_TEMPLATE(ReturnNew,
2343                HAS_1_TEMPLATE_PARAMS(typename, T),
2344                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2345  return new T(p0, p1, p2, p3, p4, p5, p6);
2346}
2347
2348ACTION_TEMPLATE(ReturnNew,
2349                HAS_1_TEMPLATE_PARAMS(typename, T),
2350                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2351  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
2352}
2353
2354ACTION_TEMPLATE(ReturnNew,
2355                HAS_1_TEMPLATE_PARAMS(typename, T),
2356                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2357  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
2358}
2359
2360ACTION_TEMPLATE(ReturnNew,
2361                HAS_1_TEMPLATE_PARAMS(typename, T),
2362                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2363  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2364}
2365
2366#ifdef _MSC_VER
2367# pragma warning(pop)
2368#endif
2369
2370}  // namespace testing
2371
2372// Include any custom actions added by the local installation.
2373// We must include this header at the end to make sure it can use the
2374// declarations from this file.
2375#include "gmock/internal/custom/gmock-generated-actions.h"
2376
2377#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
2378