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