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