Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gmock-generated-actions.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file gmock-generated-actions.h
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"
43 
44 namespace testing {
45 namespace 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.
50 template <typename Result, typename ArgumentTuple>
52 
53 template <typename R>
54 class 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 
69 template <typename R, typename A1>
70 class 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 
85 template <typename R, typename A1, typename A2>
86 class 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 
101 template <typename R, typename A1, typename A2, typename A3>
102 class 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 
118 template <typename R, typename A1, typename A2, typename A3, typename A4>
119 class 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 
137 template <typename R, typename A1, typename A2, typename A3, typename A4,
138  typename A5>
139 class 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 
157 template <typename R, typename A1, typename A2, typename A3, typename A4,
158  typename A5, typename A6>
159 class 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 
177 template <typename R, typename A1, typename A2, typename A3, typename A4,
178  typename A5, typename A6, typename A7>
179 class 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 
199 template <typename R, typename A1, typename A2, typename A3, typename A4,
200  typename A5, typename A6, typename A7, typename A8>
201 class 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 
222 template <typename R, typename A1, typename A2, typename A3, typename A4,
223  typename A5, typename A6, typename A7, typename A8, typename A9>
224 class 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 
245 template <typename R, typename A1, typename A2, typename A3, typename A4,
246  typename A5, typename A6, typename A7, typename A8, typename A9,
247  typename A10>
248 class 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 
293 template <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>
295 class 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));
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 
311 template <typename Result, typename ArgumentTuple>
312 class SelectArgs<Result, ArgumentTuple,
313  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
314  public:
315  typedef Result type();
317  static SelectedArgs Select(const ArgumentTuple& /* args */) {
318  return SelectedArgs();
319  }
320 };
321 
322 template <typename Result, typename ArgumentTuple, int k1>
323 class SelectArgs<Result, ArgumentTuple,
324  k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
325  public:
326  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
328  static SelectedArgs Select(const ArgumentTuple& args) {
329  return SelectedArgs(get<k1>(args));
330  }
331 };
332 
333 template <typename Result, typename ArgumentTuple, int k1, int k2>
334 class 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));
340  static SelectedArgs Select(const ArgumentTuple& args) {
341  return SelectedArgs(get<k1>(args), get<k2>(args));
342  }
343 };
344 
345 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
346 class 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));
352  static SelectedArgs Select(const ArgumentTuple& args) {
353  return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
354  }
355 };
356 
357 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
358  int k4>
359 class 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));
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 
372 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
373  int k4, int k5>
374 class 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));
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 
387 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
388  int k4, int k5, int k6>
389 class 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));
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 
403 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
404  int k4, int k5, int k6, int k7>
405 class 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));
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 
419 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
420  int k4, int k5, int k6, int k7, int k8>
421 class 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));
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 
437 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
438  int k4, int k5, int k6, int k7, int k8, int k9>
439 class 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));
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.
458 template <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>
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;
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 
487  };
488 
489  const InnerAction action_;
490 
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.
508 struct ExcessiveArg {};
509 
510 // A helper class needed for implementing the ACTION* macros.
511 template <typename Result, class Impl>
513  public:
514  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
515  return impl->template gmock_PerformImpl<>(args, 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),
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(),
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(),
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(),
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),
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.
623 template <int k1, typename InnerAction>
624 inline internal::WithArgsAction<InnerAction, k1>
625 WithArgs(const InnerAction& action) {
627 }
628 
629 template <int k1, int k2, typename InnerAction>
630 inline internal::WithArgsAction<InnerAction, k1, k2>
631 WithArgs(const InnerAction& action) {
633 }
634 
635 template <int k1, int k2, int k3, typename InnerAction>
636 inline internal::WithArgsAction<InnerAction, k1, k2, k3>
637 WithArgs(const InnerAction& action) {
639 }
640 
641 template <int k1, int k2, int k3, int k4, typename InnerAction>
642 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
643 WithArgs(const InnerAction& action) {
645 }
646 
647 template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
648 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
649 WithArgs(const InnerAction& action) {
651 }
652 
653 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
654 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
655 WithArgs(const InnerAction& action) {
657 }
658 
659 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
660  typename InnerAction>
661 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
662 WithArgs(const InnerAction& action) {
663  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
664  k7>(action);
665 }
666 
667 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
668  typename InnerAction>
669 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
670 WithArgs(const InnerAction& action) {
671  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
672  k8>(action);
673 }
674 
675 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
676  int k9, typename InnerAction>
677 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
678 WithArgs(const InnerAction& action) {
679  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
680  k9>(action);
681 }
682 
683 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
684  int k9, int k10, typename InnerAction>
685 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
686  k9, k10>
687 WithArgs(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.
694 template <typename Action1, typename Action2>
695 inline internal::DoBothAction<Action1, Action2>
696 DoAll(Action1 a1, Action2 a2) {
698 }
699 
700 template <typename Action1, typename Action2, typename Action3>
701 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
702  Action3> >
703 DoAll(Action1 a1, Action2 a2, Action3 a3) {
704  return DoAll(a1, DoAll(a2, a3));
705 }
706 
707 template <typename Action1, typename Action2, typename Action3,
708  typename Action4>
709 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
710  internal::DoBothAction<Action3, Action4> > >
711 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
712  return DoAll(a1, DoAll(a2, a3, a4));
713 }
714 
715 template <typename Action1, typename Action2, typename Action3,
716  typename Action4, typename Action5>
717 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
718  internal::DoBothAction<Action3, internal::DoBothAction<Action4,
719  Action5> > > >
720 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
721  return DoAll(a1, DoAll(a2, a3, a4, a5));
722 }
723 
724 template <typename Action1, typename Action2, typename Action3,
725  typename Action4, typename Action5, typename Action6>
726 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
727  internal::DoBothAction<Action3, internal::DoBothAction<Action4,
728  internal::DoBothAction<Action5, Action6> > > > >
729 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
730  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
731 }
732 
733 template <typename Action1, typename Action2, typename Action3,
734  typename Action4, typename Action5, typename Action6, typename Action7>
735 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
736  internal::DoBothAction<Action3, internal::DoBothAction<Action4,
737  internal::DoBothAction<Action5, internal::DoBothAction<Action6,
738  Action7> > > > > >
739 DoAll(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 
744 template <typename Action1, typename Action2, typename Action3,
745  typename Action4, typename Action5, typename Action6, typename Action7,
746  typename Action8>
747 inline 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> > > > > > >
751 DoAll(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 
756 template <typename Action1, typename Action2, typename Action3,
757  typename Action4, typename Action5, typename Action6, typename Action7,
758  typename Action8, typename Action9>
759 inline 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> > > > > > > >
764 DoAll(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 
769 template <typename Action1, typename Action2, typename Action3,
770  typename Action4, typename Action5, typename Action6, typename Action7,
771  typename Action8, typename Action9, typename Action10>
772 inline 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> > > > > > > > >
777 DoAll(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 
2081 namespace 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 
2124 namespace internal {
2125 namespace invoke_argument {
2126 
2127 // Appears in InvokeArgumentAdl's argument list to help avoid
2128 // accidental calls to user functions of the same name.
2129 struct 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 
2136 template <typename R, typename F>
2138  return f();
2139 }
2140 template <typename R, typename F, typename A1>
2142  return f(a1);
2143 }
2144 template <typename R, typename F, typename A1, typename A2>
2145 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
2146  return f(a1, a2);
2147 }
2148 template <typename R, typename F, typename A1, typename A2, typename A3>
2149 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
2150  return f(a1, a2, a3);
2151 }
2152 template <typename R, typename F, typename A1, typename A2, typename A3,
2153  typename A4>
2154 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
2155  return f(a1, a2, a3, a4);
2156 }
2157 template <typename R, typename F, typename A1, typename A2, typename A3,
2158  typename A4, typename A5>
2159 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
2160  return f(a1, a2, a3, a4, a5);
2161 }
2162 template <typename R, typename F, typename A1, typename A2, typename A3,
2163  typename A4, typename A5, typename A6>
2164 R 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 }
2167 template <typename R, typename F, typename A1, typename A2, typename A3,
2168  typename A4, typename A5, typename A6, typename A7>
2169 R 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 }
2173 template <typename R, typename F, typename A1, typename A2, typename A3,
2174  typename A4, typename A5, typename A6, typename A7, typename A8>
2175 R 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 }
2179 template <typename R, typename F, typename A1, typename A2, typename A3,
2180  typename A4, typename A5, typename A6, typename A7, typename A8,
2181  typename A9>
2182 R 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 }
2186 template <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>
2189 R 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 
2196 ACTION_TEMPLATE(InvokeArgument,
2197  HAS_1_TEMPLATE_PARAMS(int, k),
2198  AND_0_VALUE_PARAMS()) {
2200  return InvokeArgumentAdl<return_type>(
2202  ::testing::get<k>(args));
2203 }
2204 
2205 ACTION_TEMPLATE(InvokeArgument,
2206  HAS_1_TEMPLATE_PARAMS(int, k),
2207  AND_1_VALUE_PARAMS(p0)) {
2209  return InvokeArgumentAdl<return_type>(
2211  ::testing::get<k>(args), p0);
2212 }
2213 
2214 ACTION_TEMPLATE(InvokeArgument,
2215  HAS_1_TEMPLATE_PARAMS(int, k),
2216  AND_2_VALUE_PARAMS(p0, p1)) {
2218  return InvokeArgumentAdl<return_type>(
2220  ::testing::get<k>(args), p0, p1);
2221 }
2222 
2223 ACTION_TEMPLATE(InvokeArgument,
2224  HAS_1_TEMPLATE_PARAMS(int, k),
2225  AND_3_VALUE_PARAMS(p0, p1, p2)) {
2227  return InvokeArgumentAdl<return_type>(
2229  ::testing::get<k>(args), p0, p1, p2);
2230 }
2231 
2232 ACTION_TEMPLATE(InvokeArgument,
2233  HAS_1_TEMPLATE_PARAMS(int, k),
2234  AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2236  return InvokeArgumentAdl<return_type>(
2238  ::testing::get<k>(args), p0, p1, p2, p3);
2239 }
2240 
2241 ACTION_TEMPLATE(InvokeArgument,
2242  HAS_1_TEMPLATE_PARAMS(int, k),
2243  AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2245  return InvokeArgumentAdl<return_type>(
2247  ::testing::get<k>(args), p0, p1, p2, p3, p4);
2248 }
2249 
2250 ACTION_TEMPLATE(InvokeArgument,
2251  HAS_1_TEMPLATE_PARAMS(int, k),
2252  AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2254  return InvokeArgumentAdl<return_type>(
2256  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
2257 }
2258 
2259 ACTION_TEMPLATE(InvokeArgument,
2260  HAS_1_TEMPLATE_PARAMS(int, k),
2261  AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2263  return InvokeArgumentAdl<return_type>(
2265  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
2266 }
2267 
2268 ACTION_TEMPLATE(InvokeArgument,
2269  HAS_1_TEMPLATE_PARAMS(int, k),
2270  AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2272  return InvokeArgumentAdl<return_type>(
2274  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
2275 }
2276 
2277 ACTION_TEMPLATE(InvokeArgument,
2278  HAS_1_TEMPLATE_PARAMS(int, k),
2279  AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2281  return InvokeArgumentAdl<return_type>(
2283  ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
2284 }
2285 
2286 ACTION_TEMPLATE(InvokeArgument,
2287  HAS_1_TEMPLATE_PARAMS(int, k),
2288  AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2290  return InvokeArgumentAdl<return_type>(
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.
2301  HAS_1_TEMPLATE_PARAMS(typename, T),
2302  AND_0_VALUE_PARAMS()) {
2303  return new T();
2304 }
2305 
2307  HAS_1_TEMPLATE_PARAMS(typename, T),
2308  AND_1_VALUE_PARAMS(p0)) {
2309  return new T(p0);
2310 }
2311 
2313  HAS_1_TEMPLATE_PARAMS(typename, T),
2314  AND_2_VALUE_PARAMS(p0, p1)) {
2315  return new T(p0, p1);
2316 }
2317 
2319  HAS_1_TEMPLATE_PARAMS(typename, T),
2320  AND_3_VALUE_PARAMS(p0, p1, p2)) {
2321  return new T(p0, p1, p2);
2322 }
2323 
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 
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 
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 
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 
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 
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 
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.
2376 
2377 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_