1 // This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
3 // Copyright 2007, Google Inc.
4 // All rights reserved.
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // * Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following disclaimer
14 // in the documentation and/or other materials provided with the
16 // * Neither the name of Google Inc. nor the names of its
17 // contributors may be used to endorse or promote products derived from
18 // this software without specific prior written permission.
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 // Author: wan@google.com (Zhanyong Wan)
34 // Google Mock - a framework for writing C++ mock classes.
36 // This file implements some commonly used variadic actions.
38 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
39 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
41 #include "gmock/gmock-actions.h"
42 #include "gmock/internal/gmock-port.h"
47 // InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
48 // function or method with the unpacked values, where F is a function
49 // type that takes N arguments.
50 template <typename Result, typename ArgumentTuple>
54 class InvokeHelper<R, ::testing::tuple<> > {
56 template <typename Function>
57 static R Invoke(Function function, const ::testing::tuple<>&) {
61 template <class Class, typename MethodPtr>
62 static R InvokeMethod(Class* obj_ptr,
64 const ::testing::tuple<>&) {
65 return (obj_ptr->*method_ptr)();
69 template <typename R, typename A1>
70 class InvokeHelper<R, ::testing::tuple<A1> > {
72 template <typename Function>
73 static R Invoke(Function function, const ::testing::tuple<A1>& args) {
74 return function(get<0>(args));
77 template <class Class, typename MethodPtr>
78 static R InvokeMethod(Class* obj_ptr,
80 const ::testing::tuple<A1>& args) {
81 return (obj_ptr->*method_ptr)(get<0>(args));
85 template <typename R, typename A1, typename A2>
86 class InvokeHelper<R, ::testing::tuple<A1, A2> > {
88 template <typename Function>
89 static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
90 return function(get<0>(args), get<1>(args));
93 template <class Class, typename MethodPtr>
94 static R InvokeMethod(Class* obj_ptr,
96 const ::testing::tuple<A1, A2>& args) {
97 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
101 template <typename R, typename A1, typename A2, typename A3>
102 class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
104 template <typename Function>
105 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
106 return function(get<0>(args), get<1>(args), get<2>(args));
109 template <class Class, typename MethodPtr>
110 static R InvokeMethod(Class* obj_ptr,
111 MethodPtr method_ptr,
112 const ::testing::tuple<A1, A2, A3>& args) {
113 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
118 template <typename R, typename A1, typename A2, typename A3, typename A4>
119 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
121 template <typename Function>
122 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
124 return function(get<0>(args), get<1>(args), get<2>(args),
128 template <class Class, typename MethodPtr>
129 static R InvokeMethod(Class* obj_ptr,
130 MethodPtr method_ptr,
131 const ::testing::tuple<A1, A2, A3, A4>& args) {
132 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
133 get<2>(args), get<3>(args));
137 template <typename R, typename A1, typename A2, typename A3, typename A4,
139 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
141 template <typename Function>
142 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
144 return function(get<0>(args), get<1>(args), get<2>(args),
145 get<3>(args), get<4>(args));
148 template <class Class, typename MethodPtr>
149 static R InvokeMethod(Class* obj_ptr,
150 MethodPtr method_ptr,
151 const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
152 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
153 get<2>(args), get<3>(args), get<4>(args));
157 template <typename R, typename A1, typename A2, typename A3, typename A4,
158 typename A5, typename A6>
159 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
161 template <typename Function>
162 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
164 return function(get<0>(args), get<1>(args), get<2>(args),
165 get<3>(args), get<4>(args), get<5>(args));
168 template <class Class, typename MethodPtr>
169 static R InvokeMethod(Class* obj_ptr,
170 MethodPtr method_ptr,
171 const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
172 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
173 get<2>(args), get<3>(args), get<4>(args), get<5>(args));
177 template <typename R, typename A1, typename A2, typename A3, typename A4,
178 typename A5, typename A6, typename A7>
179 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
181 template <typename Function>
182 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
184 return function(get<0>(args), get<1>(args), get<2>(args),
185 get<3>(args), get<4>(args), get<5>(args), get<6>(args));
188 template <class Class, typename MethodPtr>
189 static R InvokeMethod(Class* obj_ptr,
190 MethodPtr method_ptr,
191 const ::testing::tuple<A1, A2, A3, A4, A5, A6,
193 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
194 get<2>(args), get<3>(args), get<4>(args), get<5>(args),
199 template <typename R, typename A1, typename A2, typename A3, typename A4,
200 typename A5, typename A6, typename A7, typename A8>
201 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
203 template <typename Function>
204 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
206 return function(get<0>(args), get<1>(args), get<2>(args),
207 get<3>(args), get<4>(args), get<5>(args), get<6>(args),
211 template <class Class, typename MethodPtr>
212 static R InvokeMethod(Class* obj_ptr,
213 MethodPtr method_ptr,
214 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
216 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
217 get<2>(args), get<3>(args), get<4>(args), get<5>(args),
218 get<6>(args), get<7>(args));
222 template <typename R, typename A1, typename A2, typename A3, typename A4,
223 typename A5, typename A6, typename A7, typename A8, typename A9>
224 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
226 template <typename Function>
227 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
228 A6, A7, A8, A9>& args) {
229 return function(get<0>(args), get<1>(args), get<2>(args),
230 get<3>(args), get<4>(args), get<5>(args), get<6>(args),
231 get<7>(args), get<8>(args));
234 template <class Class, typename MethodPtr>
235 static R InvokeMethod(Class* obj_ptr,
236 MethodPtr method_ptr,
237 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
239 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
240 get<2>(args), get<3>(args), get<4>(args), get<5>(args),
241 get<6>(args), get<7>(args), get<8>(args));
245 template <typename R, typename A1, typename A2, typename A3, typename A4,
246 typename A5, typename A6, typename A7, typename A8, typename A9,
248 class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
251 template <typename Function>
252 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
253 A6, A7, A8, A9, A10>& args) {
254 return function(get<0>(args), get<1>(args), get<2>(args),
255 get<3>(args), get<4>(args), get<5>(args), get<6>(args),
256 get<7>(args), get<8>(args), get<9>(args));
259 template <class Class, typename MethodPtr>
260 static R InvokeMethod(Class* obj_ptr,
261 MethodPtr method_ptr,
262 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
264 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
265 get<2>(args), get<3>(args), get<4>(args), get<5>(args),
266 get<6>(args), get<7>(args), get<8>(args), get<9>(args));
270 // An INTERNAL macro for extracting the type of a tuple field. It's
271 // subject to change without notice - DO NOT USE IN USER CODE!
272 #define GMOCK_FIELD_(Tuple, N) \
273 typename ::testing::tuple_element<N, Tuple>::type
275 // SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
276 // type of an n-ary function whose i-th (1-based) argument type is the
277 // k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
278 // type, and whose return type is Result. For example,
279 // SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
280 // is int(bool, long).
282 // SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
283 // returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
285 // SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
286 // ::testing::make_tuple(true, 'a', 2.5))
287 // returns tuple (2.5, true).
289 // The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
290 // in the range [0, 10]. Duplicates are allowed and they don't have
291 // to be in an ascending or descending order.
293 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
294 int k4, int k5, int k6, int k7, int k8, int k9, int k10>
297 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
298 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
299 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
300 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
301 GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
302 GMOCK_FIELD_(ArgumentTuple, k10));
303 typedef typename Function<type>::ArgumentTuple SelectedArgs;
304 static SelectedArgs Select(const ArgumentTuple& args) {
305 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
306 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
307 get<k8>(args), get<k9>(args), get<k10>(args));
311 template <typename Result, typename ArgumentTuple>
312 class SelectArgs<Result, ArgumentTuple,
313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
315 typedef Result type();
316 typedef typename Function<type>::ArgumentTuple SelectedArgs;
317 static SelectedArgs Select(const ArgumentTuple& /* args */) {
318 return SelectedArgs();
322 template <typename Result, typename ArgumentTuple, int k1>
323 class SelectArgs<Result, ArgumentTuple,
324 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
326 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
327 typedef typename Function<type>::ArgumentTuple SelectedArgs;
328 static SelectedArgs Select(const ArgumentTuple& args) {
329 return SelectedArgs(get<k1>(args));
333 template <typename Result, typename ArgumentTuple, int k1, int k2>
334 class SelectArgs<Result, ArgumentTuple,
335 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
337 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
338 GMOCK_FIELD_(ArgumentTuple, k2));
339 typedef typename Function<type>::ArgumentTuple SelectedArgs;
340 static SelectedArgs Select(const ArgumentTuple& args) {
341 return SelectedArgs(get<k1>(args), get<k2>(args));
345 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
346 class SelectArgs<Result, ArgumentTuple,
347 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
349 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
350 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
351 typedef typename Function<type>::ArgumentTuple SelectedArgs;
352 static SelectedArgs Select(const ArgumentTuple& args) {
353 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
357 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
359 class SelectArgs<Result, ArgumentTuple,
360 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
362 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
363 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
364 GMOCK_FIELD_(ArgumentTuple, k4));
365 typedef typename Function<type>::ArgumentTuple SelectedArgs;
366 static SelectedArgs Select(const ArgumentTuple& args) {
367 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
372 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
374 class SelectArgs<Result, ArgumentTuple,
375 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
377 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
378 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
379 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
380 typedef typename Function<type>::ArgumentTuple SelectedArgs;
381 static SelectedArgs Select(const ArgumentTuple& args) {
382 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
383 get<k4>(args), get<k5>(args));
387 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
388 int k4, int k5, int k6>
389 class SelectArgs<Result, ArgumentTuple,
390 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
392 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
393 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
394 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
395 GMOCK_FIELD_(ArgumentTuple, k6));
396 typedef typename Function<type>::ArgumentTuple SelectedArgs;
397 static SelectedArgs Select(const ArgumentTuple& args) {
398 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
399 get<k4>(args), get<k5>(args), get<k6>(args));
403 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
404 int k4, int k5, int k6, int k7>
405 class SelectArgs<Result, ArgumentTuple,
406 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
408 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
409 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
410 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
411 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
412 typedef typename Function<type>::ArgumentTuple SelectedArgs;
413 static SelectedArgs Select(const ArgumentTuple& args) {
414 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
415 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
419 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
420 int k4, int k5, int k6, int k7, int k8>
421 class SelectArgs<Result, ArgumentTuple,
422 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
424 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
425 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
426 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
427 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
428 GMOCK_FIELD_(ArgumentTuple, k8));
429 typedef typename Function<type>::ArgumentTuple SelectedArgs;
430 static SelectedArgs Select(const ArgumentTuple& args) {
431 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
432 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
437 template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
438 int k4, int k5, int k6, int k7, int k8, int k9>
439 class SelectArgs<Result, ArgumentTuple,
440 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
442 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
443 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
444 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
445 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
446 GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
447 typedef typename Function<type>::ArgumentTuple SelectedArgs;
448 static SelectedArgs Select(const ArgumentTuple& args) {
449 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
450 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
451 get<k8>(args), get<k9>(args));
457 // Implements the WithArgs action.
458 template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
459 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
460 int k9 = -1, int k10 = -1>
461 class WithArgsAction {
463 explicit WithArgsAction(const InnerAction& action) : action_(action) {}
465 template <typename F>
466 operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
469 template <typename F>
470 class Impl : public ActionInterface<F> {
472 typedef typename Function<F>::Result Result;
473 typedef typename Function<F>::ArgumentTuple ArgumentTuple;
475 explicit Impl(const InnerAction& action) : action_(action) {}
477 virtual Result Perform(const ArgumentTuple& args) {
478 return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
479 k5, k6, k7, k8, k9, k10>::Select(args));
483 typedef typename SelectArgs<Result, ArgumentTuple,
484 k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
486 Action<InnerFunctionType> action_;
489 const InnerAction action_;
491 GTEST_DISALLOW_ASSIGN_(WithArgsAction);
494 // A macro from the ACTION* family (defined later in this file)
495 // defines an action that can be used in a mock function. Typically,
496 // these actions only care about a subset of the arguments of the mock
497 // function. For example, if such an action only uses the second
498 // argument, it can be used in any mock function that takes >= 2
499 // arguments where the type of the second argument is compatible.
501 // Therefore, the action implementation must be prepared to take more
502 // arguments than it needs. The ExcessiveArg type is used to
503 // represent those excessive arguments. In order to keep the compiler
504 // error messages tractable, we define it in the testing namespace
505 // instead of testing::internal. However, this is an INTERNAL TYPE
506 // and subject to change without notice, so a user MUST NOT USE THIS
508 struct ExcessiveArg {};
510 // A helper class needed for implementing the ACTION* macros.
511 template <typename Result, class Impl>
514 static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
515 return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
516 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
517 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
521 template <typename A0>
522 static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
523 return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
524 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
525 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
529 template <typename A0, typename A1>
530 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
531 return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
532 get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
533 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
537 template <typename A0, typename A1, typename A2>
538 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
539 return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
540 get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
541 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
545 template <typename A0, typename A1, typename A2, typename A3>
546 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
548 return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
549 get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
550 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
554 template <typename A0, typename A1, typename A2, typename A3, typename A4>
555 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
557 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
558 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
559 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
563 template <typename A0, typename A1, typename A2, typename A3, typename A4,
565 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
567 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
568 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
569 get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
573 template <typename A0, typename A1, typename A2, typename A3, typename A4,
574 typename A5, typename A6>
575 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
577 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
578 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
579 get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
583 template <typename A0, typename A1, typename A2, typename A3, typename A4,
584 typename A5, typename A6, typename A7>
585 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
587 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
588 A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
589 get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
593 template <typename A0, typename A1, typename A2, typename A3, typename A4,
594 typename A5, typename A6, typename A7, typename A8>
595 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
596 A5, A6, A7, A8>& args) {
597 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
598 A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
599 get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
603 template <typename A0, typename A1, typename A2, typename A3, typename A4,
604 typename A5, typename A6, typename A7, typename A8, typename A9>
605 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
606 A5, A6, A7, A8, A9>& args) {
607 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
608 A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
609 get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
614 } // namespace internal
616 // Various overloads for Invoke().
618 // WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
619 // the selected arguments of the mock function to an_action and
620 // performs it. It serves as an adaptor between actions with
621 // different argument lists. C++ doesn't support default arguments for
622 // function templates, so we have to overload it.
623 template <int k1, typename InnerAction>
624 inline internal::WithArgsAction<InnerAction, k1>
625 WithArgs(const InnerAction& action) {
626 return internal::WithArgsAction<InnerAction, k1>(action);
629 template <int k1, int k2, typename InnerAction>
630 inline internal::WithArgsAction<InnerAction, k1, k2>
631 WithArgs(const InnerAction& action) {
632 return internal::WithArgsAction<InnerAction, k1, k2>(action);
635 template <int k1, int k2, int k3, typename InnerAction>
636 inline internal::WithArgsAction<InnerAction, k1, k2, k3>
637 WithArgs(const InnerAction& action) {
638 return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
641 template <int k1, int k2, int k3, int k4, typename InnerAction>
642 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
643 WithArgs(const InnerAction& action) {
644 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
647 template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
648 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
649 WithArgs(const InnerAction& action) {
650 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
653 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
654 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
655 WithArgs(const InnerAction& action) {
656 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
659 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
660 typename InnerAction>
661 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
662 WithArgs(const InnerAction& action) {
663 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
667 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
668 typename InnerAction>
669 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
670 WithArgs(const InnerAction& action) {
671 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
675 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
676 int k9, typename InnerAction>
677 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
678 WithArgs(const InnerAction& action) {
679 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
683 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
684 int k9, int k10, typename InnerAction>
685 inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
687 WithArgs(const InnerAction& action) {
688 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
692 // Creates an action that does actions a1, a2, ..., sequentially in
694 template <typename Action1, typename Action2>
695 inline internal::DoBothAction<Action1, Action2>
696 DoAll(Action1 a1, Action2 a2) {
697 return internal::DoBothAction<Action1, Action2>(a1, a2);
700 template <typename Action1, typename Action2, typename Action3>
701 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
703 DoAll(Action1 a1, Action2 a2, Action3 a3) {
704 return DoAll(a1, DoAll(a2, a3));
707 template <typename Action1, typename Action2, typename Action3,
709 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
710 internal::DoBothAction<Action3, Action4> > >
711 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
712 return DoAll(a1, DoAll(a2, a3, a4));
715 template <typename Action1, typename Action2, typename Action3,
716 typename Action4, typename Action5>
717 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
718 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
720 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
721 return DoAll(a1, DoAll(a2, a3, a4, a5));
724 template <typename Action1, typename Action2, typename Action3,
725 typename Action4, typename Action5, typename Action6>
726 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
727 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
728 internal::DoBothAction<Action5, Action6> > > > >
729 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
730 return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
733 template <typename Action1, typename Action2, typename Action3,
734 typename Action4, typename Action5, typename Action6, typename Action7>
735 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
736 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
737 internal::DoBothAction<Action5, internal::DoBothAction<Action6,
739 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
741 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
744 template <typename Action1, typename Action2, typename Action3,
745 typename Action4, typename Action5, typename Action6, typename Action7,
747 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
748 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
749 internal::DoBothAction<Action5, internal::DoBothAction<Action6,
750 internal::DoBothAction<Action7, Action8> > > > > > >
751 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
752 Action7 a7, Action8 a8) {
753 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
756 template <typename Action1, typename Action2, typename Action3,
757 typename Action4, typename Action5, typename Action6, typename Action7,
758 typename Action8, typename Action9>
759 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
760 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
761 internal::DoBothAction<Action5, internal::DoBothAction<Action6,
762 internal::DoBothAction<Action7, internal::DoBothAction<Action8,
763 Action9> > > > > > > >
764 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
765 Action7 a7, Action8 a8, Action9 a9) {
766 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
769 template <typename Action1, typename Action2, typename Action3,
770 typename Action4, typename Action5, typename Action6, typename Action7,
771 typename Action8, typename Action9, typename Action10>
772 inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
773 internal::DoBothAction<Action3, internal::DoBothAction<Action4,
774 internal::DoBothAction<Action5, internal::DoBothAction<Action6,
775 internal::DoBothAction<Action7, internal::DoBothAction<Action8,
776 internal::DoBothAction<Action9, Action10> > > > > > > > >
777 DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
778 Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
779 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
782 } // namespace testing
784 // The ACTION* family of macros can be used in a namespace scope to
785 // define custom actions easily. The syntax:
787 // ACTION(name) { statements; }
789 // will define an action with the given name that executes the
790 // statements. The value returned by the statements will be used as
791 // the return value of the action. Inside the statements, you can
792 // refer to the K-th (0-based) argument of the mock function by
793 // 'argK', and refer to its type by 'argK_type'. For example:
795 // ACTION(IncrementArg1) {
796 // arg1_type temp = arg1;
800 // allows you to write
802 // ...WillOnce(IncrementArg1());
804 // You can also refer to the entire argument tuple and its type by
805 // 'args' and 'args_type', and refer to the mock function type and its
806 // return type by 'function_type' and 'return_type'.
808 // Note that you don't need to specify the types of the mock function
809 // arguments. However rest assured that your code is still type-safe:
810 // you'll get a compiler error if *arg1 doesn't support the ++
811 // operator, or if the type of ++(*arg1) isn't compatible with the
812 // mock function's return type, for example.
814 // Sometimes you'll want to parameterize the action. For that you can use
817 // ACTION_P(name, param_name) { statements; }
821 // ACTION_P(Add, n) { return arg0 + n; }
823 // will allow you to write:
825 // ...WillOnce(Add(5));
827 // Note that you don't need to provide the type of the parameter
828 // either. If you need to reference the type of a parameter named
829 // 'foo', you can write 'foo_type'. For example, in the body of
830 // ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
833 // We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
834 // multi-parameter actions.
836 // For the purpose of typing, you can view
838 // ACTION_Pk(Foo, p1, ..., pk) { ... }
842 // template <typename p1_type, ..., typename pk_type>
843 // FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
845 // In particular, you can provide the template type arguments
846 // explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
847 // although usually you can rely on the compiler to infer the types
848 // for you automatically. You can assign the result of expression
849 // Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
850 // pk_type>. This can be useful when composing actions.
852 // You can also overload actions with different numbers of parameters:
854 // ACTION_P(Plus, a) { ... }
855 // ACTION_P2(Plus, a, b) { ... }
857 // While it's tempting to always use the ACTION* macros when defining
858 // a new action, you should also consider implementing ActionInterface
859 // or using MakePolymorphicAction() instead, especially if you need to
860 // use the action a lot. While these approaches require more work,
861 // they give you more control on the types of the mock function
862 // arguments and the action parameters, which in general leads to
863 // better compiler error messages that pay off in the long run. They
864 // also allow overloading actions based on parameter types (as opposed
865 // to just based on the number of parameters).
869 // ACTION*() can only be used in a namespace scope. The reason is
870 // that C++ doesn't yet allow function-local types to be used to
871 // instantiate templates. The up-coming C++0x standard will fix this.
872 // Once that's done, we'll consider supporting using ACTION*() inside
877 // To learn more about using these macros, please search for 'ACTION'
878 // on http://code.google.com/p/googlemock/wiki/CookBook.
880 // An internal macro needed for implementing ACTION*().
881 #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
882 const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
883 arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
884 arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
885 arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
886 arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
887 arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
888 arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
889 arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
890 arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
891 arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
892 arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
894 // Sometimes you want to give an action explicit template parameters
895 // that cannot be inferred from its value parameters. ACTION() and
896 // ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that
897 // and can be viewed as an extension to ACTION() and ACTION_P*().
901 // ACTION_TEMPLATE(ActionName,
902 // HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
903 // AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
905 // defines an action template that takes m explicit template
906 // parameters and n value parameters. name_i is the name of the i-th
907 // template parameter, and kind_i specifies whether it's a typename,
908 // an integral constant, or a template. p_i is the name of the i-th
913 // // DuplicateArg<k, T>(output) converts the k-th argument of the mock
914 // // function to type T and copies it to *output.
915 // ACTION_TEMPLATE(DuplicateArg,
916 // HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
917 // AND_1_VALUE_PARAMS(output)) {
918 // *output = T(::testing::get<k>(args));
922 // EXPECT_CALL(mock, Foo(_, _))
923 // .WillOnce(DuplicateArg<1, unsigned char>(&n));
925 // To create an instance of an action template, write:
927 // ActionName<t1, ..., t_m>(v1, ..., v_n)
929 // where the ts are the template arguments and the vs are the value
930 // arguments. The value argument types are inferred by the compiler.
931 // If you want to explicitly specify the value argument types, you can
932 // provide additional template arguments:
934 // ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
936 // where u_i is the desired type of v_i.
938 // ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
939 // number of value parameters, but not on the number of template
940 // parameters. Without the restriction, the meaning of the following
943 // OverloadedAction<int, bool>(x);
945 // Are we using a single-template-parameter action where 'bool' refers
946 // to the type of x, or are we using a two-template-parameter action
947 // where the compiler is asked to infer the type of x?
949 // Implementation notes:
951 // GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
952 // GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
953 // implementing ACTION_TEMPLATE. The main trick we use is to create
954 // new macro invocations when expanding a macro. For example, we have
956 // #define ACTION_TEMPLATE(name, template_params, value_params)
957 // ... GMOCK_INTERNAL_DECL_##template_params ...
959 // which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
962 // ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
964 // Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
965 // preprocessor will continue to expand it to
967 // ... typename T ...
969 // This technique conforms to the C++ standard and is portable. It
970 // allows us to implement action templates using O(N) code, where N is
971 // the maximum number of template/value parameters supported. Without
972 // using it, we'd have to devote O(N^2) amount of code to implement all
973 // combinations of m and n.
975 // Declares the template parameters.
976 #define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
977 #define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
978 name1) kind0 name0, kind1 name1
979 #define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
980 kind2, name2) kind0 name0, kind1 name1, kind2 name2
981 #define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
982 kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
984 #define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
985 kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
986 kind2 name2, kind3 name3, kind4 name4
987 #define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
988 kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
989 kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
990 #define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
991 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
992 name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
993 kind5 name5, kind6 name6
994 #define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
995 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
996 kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
997 kind4 name4, kind5 name5, kind6 name6, kind7 name7
998 #define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
999 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1000 kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
1001 kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
1003 #define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1004 name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1005 name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
1006 kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
1007 kind6 name6, kind7 name7, kind8 name8, kind9 name9
1009 // Lists the template parameters.
1010 #define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
1011 #define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
1013 #define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1014 kind2, name2) name0, name1, name2
1015 #define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1016 kind2, name2, kind3, name3) name0, name1, name2, name3
1017 #define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1018 kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
1020 #define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1021 kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
1022 name2, name3, name4, name5
1023 #define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1024 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1025 name6) name0, name1, name2, name3, name4, name5, name6
1026 #define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1027 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1028 kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
1029 #define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1030 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1031 kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
1033 #define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1034 name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1035 name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
1036 name3, name4, name5, name6, name7, name8, name9
1038 // Declares the types of value parameters.
1039 #define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
1040 #define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
1041 #define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
1042 typename p0##_type, typename p1##_type
1043 #define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
1044 typename p0##_type, typename p1##_type, typename p2##_type
1045 #define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1046 typename p0##_type, typename p1##_type, typename p2##_type, \
1048 #define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1049 typename p0##_type, typename p1##_type, typename p2##_type, \
1050 typename p3##_type, typename p4##_type
1051 #define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1052 typename p0##_type, typename p1##_type, typename p2##_type, \
1053 typename p3##_type, typename p4##_type, typename p5##_type
1054 #define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1055 p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
1056 typename p3##_type, typename p4##_type, typename p5##_type, \
1058 #define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1059 p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
1060 typename p3##_type, typename p4##_type, typename p5##_type, \
1061 typename p6##_type, typename p7##_type
1062 #define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1063 p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
1064 typename p3##_type, typename p4##_type, typename p5##_type, \
1065 typename p6##_type, typename p7##_type, typename p8##_type
1066 #define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1067 p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
1068 typename p2##_type, typename p3##_type, typename p4##_type, \
1069 typename p5##_type, typename p6##_type, typename p7##_type, \
1070 typename p8##_type, typename p9##_type
1072 // Initializes the value parameters.
1073 #define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
1075 #define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
1076 (p0##_type gmock_p0) : p0(gmock_p0)
1077 #define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
1078 (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1)
1079 #define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
1080 (p0##_type gmock_p0, p1##_type gmock_p1, \
1081 p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2)
1082 #define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
1083 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1084 p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1086 #define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
1087 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1088 p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \
1089 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4)
1090 #define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
1091 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1092 p3##_type gmock_p3, p4##_type gmock_p4, \
1093 p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1094 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5)
1095 #define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
1096 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1097 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1098 p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1099 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6)
1100 #define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
1101 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1102 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1103 p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \
1104 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1106 #define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1108 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1109 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1110 p6##_type gmock_p6, p7##_type gmock_p7, \
1111 p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1112 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1114 #define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1116 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1117 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1118 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
1119 p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1120 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1121 p8(gmock_p8), p9(gmock_p9)
1123 // Declares the fields for storing the value parameters.
1124 #define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
1125 #define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
1126 #define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
1128 #define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
1129 p1##_type p1; p2##_type p2;
1130 #define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
1131 p1##_type p1; p2##_type p2; p3##_type p3;
1132 #define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1133 p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
1134 #define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1135 p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1137 #define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1138 p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1139 p5##_type p5; p6##_type p6;
1140 #define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1141 p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1142 p5##_type p5; p6##_type p6; p7##_type p7;
1143 #define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1144 p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1145 p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
1146 #define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1147 p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1148 p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
1151 // Lists the value parameters.
1152 #define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
1153 #define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
1154 #define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
1155 #define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
1156 #define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
1157 #define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
1159 #define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
1161 #define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1162 p6) p0, p1, p2, p3, p4, p5, p6
1163 #define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1164 p7) p0, p1, p2, p3, p4, p5, p6, p7
1165 #define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1166 p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
1167 #define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1168 p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
1170 // Lists the value parameter types.
1171 #define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
1172 #define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
1173 #define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
1175 #define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
1176 p1##_type, p2##_type
1177 #define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1178 p0##_type, p1##_type, p2##_type, p3##_type
1179 #define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1180 p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
1181 #define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1182 p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
1183 #define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1184 p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
1186 #define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1187 p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1188 p5##_type, p6##_type, p7##_type
1189 #define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1190 p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1191 p5##_type, p6##_type, p7##_type, p8##_type
1192 #define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1193 p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1194 p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
1196 // Declares the value parameters.
1197 #define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
1198 #define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
1199 #define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
1201 #define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
1202 p1##_type p1, p2##_type p2
1203 #define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
1204 p1##_type p1, p2##_type p2, p3##_type p3
1205 #define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1206 p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
1207 #define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1208 p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1210 #define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1211 p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1212 p5##_type p5, p6##_type p6
1213 #define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1214 p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1215 p5##_type p5, p6##_type p6, p7##_type p7
1216 #define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1217 p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1218 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
1219 #define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1220 p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1221 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
1224 // The suffix of the class template implementing the action template.
1225 #define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
1226 #define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
1227 #define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
1228 #define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
1229 #define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
1230 #define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
1231 #define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
1232 #define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
1233 #define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1235 #define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1237 #define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1240 // The name of the class template implementing the action template.
1241 #define GMOCK_ACTION_CLASS_(name, value_params)\
1242 GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
1244 #define ACTION_TEMPLATE(name, template_params, value_params)\
1245 template <GMOCK_INTERNAL_DECL_##template_params\
1246 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1247 class GMOCK_ACTION_CLASS_(name, value_params) {\
1249 explicit GMOCK_ACTION_CLASS_(name, value_params)\
1250 GMOCK_INTERNAL_INIT_##value_params {}\
1251 template <typename F>\
1252 class gmock_Impl : public ::testing::ActionInterface<F> {\
1254 typedef F function_type;\
1255 typedef typename ::testing::internal::Function<F>::Result return_type;\
1256 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1258 explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
1259 virtual return_type Perform(const args_type& args) {\
1260 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1261 Perform(this, args);\
1263 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1264 typename arg3_type, typename arg4_type, typename arg5_type, \
1265 typename arg6_type, typename arg7_type, typename arg8_type, \
1266 typename arg9_type>\
1267 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1268 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1269 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1270 arg9_type arg9) const;\
1271 GMOCK_INTERNAL_DEFN_##value_params\
1273 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1275 template <typename F> operator ::testing::Action<F>() const {\
1276 return ::testing::Action<F>(\
1277 new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
1279 GMOCK_INTERNAL_DEFN_##value_params\
1281 GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
1283 template <GMOCK_INTERNAL_DECL_##template_params\
1284 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1285 inline GMOCK_ACTION_CLASS_(name, value_params)<\
1286 GMOCK_INTERNAL_LIST_##template_params\
1287 GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
1288 GMOCK_INTERNAL_DECL_##value_params) {\
1289 return GMOCK_ACTION_CLASS_(name, value_params)<\
1290 GMOCK_INTERNAL_LIST_##template_params\
1291 GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
1292 GMOCK_INTERNAL_LIST_##value_params);\
1294 template <GMOCK_INTERNAL_DECL_##template_params\
1295 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1296 template <typename F>\
1297 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1298 typename arg3_type, typename arg4_type, typename arg5_type, \
1299 typename arg6_type, typename arg7_type, typename arg8_type, \
1300 typename arg9_type>\
1301 typename ::testing::internal::Function<F>::Result\
1302 GMOCK_ACTION_CLASS_(name, value_params)<\
1303 GMOCK_INTERNAL_LIST_##template_params\
1304 GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
1306 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1308 #define ACTION(name)\
1309 class name##Action {\
1312 template <typename F>\
1313 class gmock_Impl : public ::testing::ActionInterface<F> {\
1315 typedef F function_type;\
1316 typedef typename ::testing::internal::Function<F>::Result return_type;\
1317 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1320 virtual return_type Perform(const args_type& args) {\
1321 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1322 Perform(this, args);\
1324 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1325 typename arg3_type, typename arg4_type, typename arg5_type, \
1326 typename arg6_type, typename arg7_type, typename arg8_type, \
1327 typename arg9_type>\
1328 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1329 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1330 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1331 arg9_type arg9) const;\
1333 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1335 template <typename F> operator ::testing::Action<F>() const {\
1336 return ::testing::Action<F>(new gmock_Impl<F>());\
1339 GTEST_DISALLOW_ASSIGN_(name##Action);\
1341 inline name##Action name() {\
1342 return name##Action();\
1344 template <typename F>\
1345 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1346 typename arg3_type, typename arg4_type, typename arg5_type, \
1347 typename arg6_type, typename arg7_type, typename arg8_type, \
1348 typename arg9_type>\
1349 typename ::testing::internal::Function<F>::Result\
1350 name##Action::gmock_Impl<F>::gmock_PerformImpl(\
1351 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1353 #define ACTION_P(name, p0)\
1354 template <typename p0##_type>\
1355 class name##ActionP {\
1357 explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
1358 template <typename F>\
1359 class gmock_Impl : public ::testing::ActionInterface<F> {\
1361 typedef F function_type;\
1362 typedef typename ::testing::internal::Function<F>::Result return_type;\
1363 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1365 explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
1366 virtual return_type Perform(const args_type& args) {\
1367 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1368 Perform(this, args);\
1370 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1371 typename arg3_type, typename arg4_type, typename arg5_type, \
1372 typename arg6_type, typename arg7_type, typename arg8_type, \
1373 typename arg9_type>\
1374 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1375 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1376 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1377 arg9_type arg9) const;\
1380 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1382 template <typename F> operator ::testing::Action<F>() const {\
1383 return ::testing::Action<F>(new gmock_Impl<F>(p0));\
1387 GTEST_DISALLOW_ASSIGN_(name##ActionP);\
1389 template <typename p0##_type>\
1390 inline name##ActionP<p0##_type> name(p0##_type p0) {\
1391 return name##ActionP<p0##_type>(p0);\
1393 template <typename p0##_type>\
1394 template <typename F>\
1395 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1396 typename arg3_type, typename arg4_type, typename arg5_type, \
1397 typename arg6_type, typename arg7_type, typename arg8_type, \
1398 typename arg9_type>\
1399 typename ::testing::internal::Function<F>::Result\
1400 name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1401 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1403 #define ACTION_P2(name, p0, p1)\
1404 template <typename p0##_type, typename p1##_type>\
1405 class name##ActionP2 {\
1407 name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1409 template <typename F>\
1410 class gmock_Impl : public ::testing::ActionInterface<F> {\
1412 typedef F function_type;\
1413 typedef typename ::testing::internal::Function<F>::Result return_type;\
1414 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1416 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1418 virtual return_type Perform(const args_type& args) {\
1419 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1420 Perform(this, args);\
1422 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1423 typename arg3_type, typename arg4_type, typename arg5_type, \
1424 typename arg6_type, typename arg7_type, typename arg8_type, \
1425 typename arg9_type>\
1426 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1427 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1428 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1429 arg9_type arg9) const;\
1433 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1435 template <typename F> operator ::testing::Action<F>() const {\
1436 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
1441 GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
1443 template <typename p0##_type, typename p1##_type>\
1444 inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
1446 return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
1448 template <typename p0##_type, typename p1##_type>\
1449 template <typename F>\
1450 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1451 typename arg3_type, typename arg4_type, typename arg5_type, \
1452 typename arg6_type, typename arg7_type, typename arg8_type, \
1453 typename arg9_type>\
1454 typename ::testing::internal::Function<F>::Result\
1455 name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1456 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1458 #define ACTION_P3(name, p0, p1, p2)\
1459 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1460 class name##ActionP3 {\
1462 name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1463 p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1464 template <typename F>\
1465 class gmock_Impl : public ::testing::ActionInterface<F> {\
1467 typedef F function_type;\
1468 typedef typename ::testing::internal::Function<F>::Result return_type;\
1469 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1471 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
1472 p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1473 virtual return_type Perform(const args_type& args) {\
1474 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1475 Perform(this, args);\
1477 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1478 typename arg3_type, typename arg4_type, typename arg5_type, \
1479 typename arg6_type, typename arg7_type, typename arg8_type, \
1480 typename arg9_type>\
1481 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1482 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1483 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1484 arg9_type arg9) const;\
1489 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1491 template <typename F> operator ::testing::Action<F>() const {\
1492 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
1498 GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
1500 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1501 inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1502 p1##_type p1, p2##_type p2) {\
1503 return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1505 template <typename p0##_type, typename p1##_type, typename p2##_type>\
1506 template <typename F>\
1507 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1508 typename arg3_type, typename arg4_type, typename arg5_type, \
1509 typename arg6_type, typename arg7_type, typename arg8_type, \
1510 typename arg9_type>\
1511 typename ::testing::internal::Function<F>::Result\
1512 name##ActionP3<p0##_type, p1##_type, \
1513 p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1514 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1516 #define ACTION_P4(name, p0, p1, p2, p3)\
1517 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1518 typename p3##_type>\
1519 class name##ActionP4 {\
1521 name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1522 p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
1523 p2(gmock_p2), p3(gmock_p3) {}\
1524 template <typename F>\
1525 class gmock_Impl : public ::testing::ActionInterface<F> {\
1527 typedef F function_type;\
1528 typedef typename ::testing::internal::Function<F>::Result return_type;\
1529 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1531 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1532 p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1534 virtual return_type Perform(const args_type& args) {\
1535 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1536 Perform(this, args);\
1538 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1539 typename arg3_type, typename arg4_type, typename arg5_type, \
1540 typename arg6_type, typename arg7_type, typename arg8_type, \
1541 typename arg9_type>\
1542 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1543 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1544 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1545 arg9_type arg9) const;\
1551 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1553 template <typename F> operator ::testing::Action<F>() const {\
1554 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
1561 GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
1563 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1564 typename p3##_type>\
1565 inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
1566 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1568 return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
1571 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1572 typename p3##_type>\
1573 template <typename F>\
1574 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1575 typename arg3_type, typename arg4_type, typename arg5_type, \
1576 typename arg6_type, typename arg7_type, typename arg8_type, \
1577 typename arg9_type>\
1578 typename ::testing::internal::Function<F>::Result\
1579 name##ActionP4<p0##_type, p1##_type, p2##_type, \
1580 p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1581 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1583 #define ACTION_P5(name, p0, p1, p2, p3, p4)\
1584 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1585 typename p3##_type, typename p4##_type>\
1586 class name##ActionP5 {\
1588 name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1589 p2##_type gmock_p2, p3##_type gmock_p3, \
1590 p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1591 p3(gmock_p3), p4(gmock_p4) {}\
1592 template <typename F>\
1593 class gmock_Impl : public ::testing::ActionInterface<F> {\
1595 typedef F function_type;\
1596 typedef typename ::testing::internal::Function<F>::Result return_type;\
1597 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1599 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1600 p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
1601 p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
1602 virtual return_type Perform(const args_type& args) {\
1603 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1604 Perform(this, args);\
1606 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1607 typename arg3_type, typename arg4_type, typename arg5_type, \
1608 typename arg6_type, typename arg7_type, typename arg8_type, \
1609 typename arg9_type>\
1610 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1611 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1612 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1613 arg9_type arg9) const;\
1620 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1622 template <typename F> operator ::testing::Action<F>() const {\
1623 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
1631 GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
1633 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1634 typename p3##_type, typename p4##_type>\
1635 inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1636 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1638 return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1639 p4##_type>(p0, p1, p2, p3, p4);\
1641 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1642 typename p3##_type, typename p4##_type>\
1643 template <typename F>\
1644 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1645 typename arg3_type, typename arg4_type, typename arg5_type, \
1646 typename arg6_type, typename arg7_type, typename arg8_type, \
1647 typename arg9_type>\
1648 typename ::testing::internal::Function<F>::Result\
1649 name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1650 p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1651 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1653 #define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
1654 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1655 typename p3##_type, typename p4##_type, typename p5##_type>\
1656 class name##ActionP6 {\
1658 name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1659 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1660 p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1661 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1662 template <typename F>\
1663 class gmock_Impl : public ::testing::ActionInterface<F> {\
1665 typedef F function_type;\
1666 typedef typename ::testing::internal::Function<F>::Result return_type;\
1667 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1669 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1670 p3##_type gmock_p3, p4##_type gmock_p4, \
1671 p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1672 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1673 virtual return_type Perform(const args_type& args) {\
1674 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1675 Perform(this, args);\
1677 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1678 typename arg3_type, typename arg4_type, typename arg5_type, \
1679 typename arg6_type, typename arg7_type, typename arg8_type, \
1680 typename arg9_type>\
1681 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1682 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1683 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1684 arg9_type arg9) const;\
1692 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1694 template <typename F> operator ::testing::Action<F>() const {\
1695 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
1704 GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
1706 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1707 typename p3##_type, typename p4##_type, typename p5##_type>\
1708 inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1709 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1710 p3##_type p3, p4##_type p4, p5##_type p5) {\
1711 return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1712 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1714 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1715 typename p3##_type, typename p4##_type, typename p5##_type>\
1716 template <typename F>\
1717 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1718 typename arg3_type, typename arg4_type, typename arg5_type, \
1719 typename arg6_type, typename arg7_type, typename arg8_type, \
1720 typename arg9_type>\
1721 typename ::testing::internal::Function<F>::Result\
1722 name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1723 p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1724 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1726 #define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
1727 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1728 typename p3##_type, typename p4##_type, typename p5##_type, \
1729 typename p6##_type>\
1730 class name##ActionP7 {\
1732 name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1733 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1734 p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
1735 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
1737 template <typename F>\
1738 class gmock_Impl : public ::testing::ActionInterface<F> {\
1740 typedef F function_type;\
1741 typedef typename ::testing::internal::Function<F>::Result return_type;\
1742 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1744 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1745 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1746 p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1747 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
1748 virtual return_type Perform(const args_type& args) {\
1749 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1750 Perform(this, args);\
1752 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1753 typename arg3_type, typename arg4_type, typename arg5_type, \
1754 typename arg6_type, typename arg7_type, typename arg8_type, \
1755 typename arg9_type>\
1756 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1757 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1758 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1759 arg9_type arg9) const;\
1768 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1770 template <typename F> operator ::testing::Action<F>() const {\
1771 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1782 GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
1784 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1785 typename p3##_type, typename p4##_type, typename p5##_type, \
1786 typename p6##_type>\
1787 inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1788 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1789 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1791 return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1792 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1794 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1795 typename p3##_type, typename p4##_type, typename p5##_type, \
1796 typename p6##_type>\
1797 template <typename F>\
1798 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1799 typename arg3_type, typename arg4_type, typename arg5_type, \
1800 typename arg6_type, typename arg7_type, typename arg8_type, \
1801 typename arg9_type>\
1802 typename ::testing::internal::Function<F>::Result\
1803 name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1804 p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1805 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1807 #define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
1808 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1809 typename p3##_type, typename p4##_type, typename p5##_type, \
1810 typename p6##_type, typename p7##_type>\
1811 class name##ActionP8 {\
1813 name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1814 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1815 p5##_type gmock_p5, p6##_type gmock_p6, \
1816 p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1817 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1819 template <typename F>\
1820 class gmock_Impl : public ::testing::ActionInterface<F> {\
1822 typedef F function_type;\
1823 typedef typename ::testing::internal::Function<F>::Result return_type;\
1824 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1826 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1827 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1828 p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \
1829 p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
1830 p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
1831 virtual return_type Perform(const args_type& args) {\
1832 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1833 Perform(this, args);\
1835 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1836 typename arg3_type, typename arg4_type, typename arg5_type, \
1837 typename arg6_type, typename arg7_type, typename arg8_type, \
1838 typename arg9_type>\
1839 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1840 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1841 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1842 arg9_type arg9) const;\
1852 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1854 template <typename F> operator ::testing::Action<F>() const {\
1855 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1867 GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
1869 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1870 typename p3##_type, typename p4##_type, typename p5##_type, \
1871 typename p6##_type, typename p7##_type>\
1872 inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1873 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
1874 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1875 p6##_type p6, p7##_type p7) {\
1876 return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1877 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
1880 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1881 typename p3##_type, typename p4##_type, typename p5##_type, \
1882 typename p6##_type, typename p7##_type>\
1883 template <typename F>\
1884 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1885 typename arg3_type, typename arg4_type, typename arg5_type, \
1886 typename arg6_type, typename arg7_type, typename arg8_type, \
1887 typename arg9_type>\
1888 typename ::testing::internal::Function<F>::Result\
1889 name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1890 p5##_type, p6##_type, \
1891 p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1892 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1894 #define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
1895 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1896 typename p3##_type, typename p4##_type, typename p5##_type, \
1897 typename p6##_type, typename p7##_type, typename p8##_type>\
1898 class name##ActionP9 {\
1900 name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
1901 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1902 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1903 p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1904 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1906 template <typename F>\
1907 class gmock_Impl : public ::testing::ActionInterface<F> {\
1909 typedef F function_type;\
1910 typedef typename ::testing::internal::Function<F>::Result return_type;\
1911 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1913 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1914 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1915 p6##_type gmock_p6, p7##_type gmock_p7, \
1916 p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1917 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1918 p7(gmock_p7), p8(gmock_p8) {}\
1919 virtual return_type Perform(const args_type& args) {\
1920 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1921 Perform(this, args);\
1923 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1924 typename arg3_type, typename arg4_type, typename arg5_type, \
1925 typename arg6_type, typename arg7_type, typename arg8_type, \
1926 typename arg9_type>\
1927 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1928 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1929 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1930 arg9_type arg9) const;\
1941 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1943 template <typename F> operator ::testing::Action<F>() const {\
1944 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1957 GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
1959 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1960 typename p3##_type, typename p4##_type, typename p5##_type, \
1961 typename p6##_type, typename p7##_type, typename p8##_type>\
1962 inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1963 p4##_type, p5##_type, p6##_type, p7##_type, \
1964 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1965 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
1967 return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1968 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
1969 p3, p4, p5, p6, p7, p8);\
1971 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1972 typename p3##_type, typename p4##_type, typename p5##_type, \
1973 typename p6##_type, typename p7##_type, typename p8##_type>\
1974 template <typename F>\
1975 template <typename arg0_type, typename arg1_type, typename arg2_type, \
1976 typename arg3_type, typename arg4_type, typename arg5_type, \
1977 typename arg6_type, typename arg7_type, typename arg8_type, \
1978 typename arg9_type>\
1979 typename ::testing::internal::Function<F>::Result\
1980 name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1981 p5##_type, p6##_type, p7##_type, \
1982 p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1983 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1985 #define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
1986 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1987 typename p3##_type, typename p4##_type, typename p5##_type, \
1988 typename p6##_type, typename p7##_type, typename p8##_type, \
1989 typename p9##_type>\
1990 class name##ActionP10 {\
1992 name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \
1993 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1994 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1995 p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
1996 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1997 p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
1998 template <typename F>\
1999 class gmock_Impl : public ::testing::ActionInterface<F> {\
2001 typedef F function_type;\
2002 typedef typename ::testing::internal::Function<F>::Result return_type;\
2003 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
2005 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2006 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2007 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2008 p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
2009 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
2010 p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
2011 virtual return_type Perform(const args_type& args) {\
2012 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
2013 Perform(this, args);\
2015 template <typename arg0_type, typename arg1_type, typename arg2_type, \
2016 typename arg3_type, typename arg4_type, typename arg5_type, \
2017 typename arg6_type, typename arg7_type, typename arg8_type, \
2018 typename arg9_type>\
2019 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
2020 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
2021 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
2022 arg9_type arg9) const;\
2034 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2036 template <typename F> operator ::testing::Action<F>() const {\
2037 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
2051 GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
2053 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2054 typename p3##_type, typename p4##_type, typename p5##_type, \
2055 typename p6##_type, typename p7##_type, typename p8##_type, \
2056 typename p9##_type>\
2057 inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2058 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2059 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2060 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2062 return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2063 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2064 p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2066 template <typename p0##_type, typename p1##_type, typename p2##_type, \
2067 typename p3##_type, typename p4##_type, typename p5##_type, \
2068 typename p6##_type, typename p7##_type, typename p8##_type, \
2069 typename p9##_type>\
2070 template <typename F>\
2071 template <typename arg0_type, typename arg1_type, typename arg2_type, \
2072 typename arg3_type, typename arg4_type, typename arg5_type, \
2073 typename arg6_type, typename arg7_type, typename arg8_type, \
2074 typename arg9_type>\
2075 typename ::testing::internal::Function<F>::Result\
2076 name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2077 p5##_type, p6##_type, p7##_type, p8##_type, \
2078 p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\
2079 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
2084 // The ACTION*() macros trigger warning C4100 (unreferenced formal
2085 // parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
2086 // the macro definition, as the warnings are generated when the macro
2087 // is expanded and macro expansion cannot contain #pragma. Therefore
2088 // we suppress them here.
2090 # pragma warning(push)
2091 # pragma warning(disable:4100)
2094 // Various overloads for InvokeArgument<N>().
2096 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
2097 // (0-based) argument, which must be a k-ary callable, of the mock
2098 // function, with arguments a1, a2, ..., a_k.
2102 // 1. The arguments are passed by value by default. If you need to
2103 // pass an argument by reference, wrap it inside ByRef(). For
2106 // InvokeArgument<1>(5, string("Hello"), ByRef(foo))
2108 // passes 5 and string("Hello") by value, and passes foo by
2111 // 2. If the callable takes an argument by reference but ByRef() is
2112 // not used, it will receive the reference to a copy of the value,
2113 // instead of the original value. For example, when the 0-th
2114 // argument of the mock function takes a const string&, the action
2116 // InvokeArgument<0>(string("Hello"))
2118 // makes a copy of the temporary string("Hello") object and passes a
2119 // reference of the copy, instead of the original temporary object,
2120 // to the callable. This makes it easy for a user to define an
2121 // InvokeArgument action from temporary values and have it performed
2124 namespace internal {
2125 namespace invoke_argument {
2127 // Appears in InvokeArgumentAdl's argument list to help avoid
2128 // accidental calls to user functions of the same name.
2131 // InvokeArgumentAdl - a helper for InvokeArgument.
2132 // The basic overloads are provided here for generic functors.
2133 // Overloads for other custom-callables are provided in the
2134 // internal/custom/callback-actions.h header.
2136 template <typename R, typename F>
2137 R InvokeArgumentAdl(AdlTag, F f) {
2140 template <typename R, typename F, typename A1>
2141 R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
2144 template <typename R, typename F, typename A1, typename A2>
2145 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
2148 template <typename R, typename F, typename A1, typename A2, typename A3>
2149 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
2150 return f(a1, a2, a3);
2152 template <typename R, typename F, typename A1, typename A2, typename A3,
2154 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
2155 return f(a1, a2, a3, a4);
2157 template <typename R, typename F, typename A1, typename A2, typename A3,
2158 typename A4, typename A5>
2159 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
2160 return f(a1, a2, a3, a4, a5);
2162 template <typename R, typename F, typename A1, typename A2, typename A3,
2163 typename A4, typename A5, typename A6>
2164 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
2165 return f(a1, a2, a3, a4, a5, a6);
2167 template <typename R, typename F, typename A1, typename A2, typename A3,
2168 typename A4, typename A5, typename A6, typename A7>
2169 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2171 return f(a1, a2, a3, a4, a5, a6, a7);
2173 template <typename R, typename F, typename A1, typename A2, typename A3,
2174 typename A4, typename A5, typename A6, typename A7, typename A8>
2175 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2177 return f(a1, a2, a3, a4, a5, a6, a7, a8);
2179 template <typename R, typename F, typename A1, typename A2, typename A3,
2180 typename A4, typename A5, typename A6, typename A7, typename A8,
2182 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2183 A7 a7, A8 a8, A9 a9) {
2184 return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2186 template <typename R, typename F, typename A1, typename A2, typename A3,
2187 typename A4, typename A5, typename A6, typename A7, typename A8,
2188 typename A9, typename A10>
2189 R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2190 A7 a7, A8 a8, A9 a9, A10 a10) {
2191 return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2193 } // namespace invoke_argument
2194 } // namespace internal
2196 ACTION_TEMPLATE(InvokeArgument,
2197 HAS_1_TEMPLATE_PARAMS(int, k),
2198 AND_0_VALUE_PARAMS()) {
2199 using internal::invoke_argument::InvokeArgumentAdl;
2200 return InvokeArgumentAdl<return_type>(
2201 internal::invoke_argument::AdlTag(),
2202 ::testing::get<k>(args));
2205 ACTION_TEMPLATE(InvokeArgument,
2206 HAS_1_TEMPLATE_PARAMS(int, k),
2207 AND_1_VALUE_PARAMS(p0)) {
2208 using internal::invoke_argument::InvokeArgumentAdl;
2209 return InvokeArgumentAdl<return_type>(
2210 internal::invoke_argument::AdlTag(),
2211 ::testing::get<k>(args), p0);
2214 ACTION_TEMPLATE(InvokeArgument,
2215 HAS_1_TEMPLATE_PARAMS(int, k),
2216 AND_2_VALUE_PARAMS(p0, p1)) {
2217 using internal::invoke_argument::InvokeArgumentAdl;
2218 return InvokeArgumentAdl<return_type>(
2219 internal::invoke_argument::AdlTag(),
2220 ::testing::get<k>(args), p0, p1);
2223 ACTION_TEMPLATE(InvokeArgument,
2224 HAS_1_TEMPLATE_PARAMS(int, k),
2225 AND_3_VALUE_PARAMS(p0, p1, p2)) {
2226 using internal::invoke_argument::InvokeArgumentAdl;
2227 return InvokeArgumentAdl<return_type>(
2228 internal::invoke_argument::AdlTag(),
2229 ::testing::get<k>(args), p0, p1, p2);
2232 ACTION_TEMPLATE(InvokeArgument,
2233 HAS_1_TEMPLATE_PARAMS(int, k),
2234 AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2235 using internal::invoke_argument::InvokeArgumentAdl;
2236 return InvokeArgumentAdl<return_type>(
2237 internal::invoke_argument::AdlTag(),
2238 ::testing::get<k>(args), p0, p1, p2, p3);
2241 ACTION_TEMPLATE(InvokeArgument,
2242 HAS_1_TEMPLATE_PARAMS(int, k),
2243 AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2244 using internal::invoke_argument::InvokeArgumentAdl;
2245 return InvokeArgumentAdl<return_type>(
2246 internal::invoke_argument::AdlTag(),
2247 ::testing::get<k>(args), p0, p1, p2, p3, p4);
2250 ACTION_TEMPLATE(InvokeArgument,
2251 HAS_1_TEMPLATE_PARAMS(int, k),
2252 AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2253 using internal::invoke_argument::InvokeArgumentAdl;
2254 return InvokeArgumentAdl<return_type>(
2255 internal::invoke_argument::AdlTag(),
2256 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
2259 ACTION_TEMPLATE(InvokeArgument,
2260 HAS_1_TEMPLATE_PARAMS(int, k),
2261 AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2262 using internal::invoke_argument::InvokeArgumentAdl;
2263 return InvokeArgumentAdl<return_type>(
2264 internal::invoke_argument::AdlTag(),
2265 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
2268 ACTION_TEMPLATE(InvokeArgument,
2269 HAS_1_TEMPLATE_PARAMS(int, k),
2270 AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2271 using internal::invoke_argument::InvokeArgumentAdl;
2272 return InvokeArgumentAdl<return_type>(
2273 internal::invoke_argument::AdlTag(),
2274 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
2277 ACTION_TEMPLATE(InvokeArgument,
2278 HAS_1_TEMPLATE_PARAMS(int, k),
2279 AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2280 using internal::invoke_argument::InvokeArgumentAdl;
2281 return InvokeArgumentAdl<return_type>(
2282 internal::invoke_argument::AdlTag(),
2283 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
2286 ACTION_TEMPLATE(InvokeArgument,
2287 HAS_1_TEMPLATE_PARAMS(int, k),
2288 AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2289 using internal::invoke_argument::InvokeArgumentAdl;
2290 return InvokeArgumentAdl<return_type>(
2291 internal::invoke_argument::AdlTag(),
2292 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2295 // Various overloads for ReturnNew<T>().
2297 // The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
2298 // instance of type T, constructed on the heap with constructor arguments
2299 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
2300 ACTION_TEMPLATE(ReturnNew,
2301 HAS_1_TEMPLATE_PARAMS(typename, T),
2302 AND_0_VALUE_PARAMS()) {
2306 ACTION_TEMPLATE(ReturnNew,
2307 HAS_1_TEMPLATE_PARAMS(typename, T),
2308 AND_1_VALUE_PARAMS(p0)) {
2312 ACTION_TEMPLATE(ReturnNew,
2313 HAS_1_TEMPLATE_PARAMS(typename, T),
2314 AND_2_VALUE_PARAMS(p0, p1)) {
2315 return new T(p0, p1);
2318 ACTION_TEMPLATE(ReturnNew,
2319 HAS_1_TEMPLATE_PARAMS(typename, T),
2320 AND_3_VALUE_PARAMS(p0, p1, p2)) {
2321 return new T(p0, p1, p2);
2324 ACTION_TEMPLATE(ReturnNew,
2325 HAS_1_TEMPLATE_PARAMS(typename, T),
2326 AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2327 return new T(p0, p1, p2, p3);
2330 ACTION_TEMPLATE(ReturnNew,
2331 HAS_1_TEMPLATE_PARAMS(typename, T),
2332 AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2333 return new T(p0, p1, p2, p3, p4);
2336 ACTION_TEMPLATE(ReturnNew,
2337 HAS_1_TEMPLATE_PARAMS(typename, T),
2338 AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2339 return new T(p0, p1, p2, p3, p4, p5);
2342 ACTION_TEMPLATE(ReturnNew,
2343 HAS_1_TEMPLATE_PARAMS(typename, T),
2344 AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2345 return new T(p0, p1, p2, p3, p4, p5, p6);
2348 ACTION_TEMPLATE(ReturnNew,
2349 HAS_1_TEMPLATE_PARAMS(typename, T),
2350 AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2351 return new T(p0, p1, p2, p3, p4, p5, p6, p7);
2354 ACTION_TEMPLATE(ReturnNew,
2355 HAS_1_TEMPLATE_PARAMS(typename, T),
2356 AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2357 return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
2360 ACTION_TEMPLATE(ReturnNew,
2361 HAS_1_TEMPLATE_PARAMS(typename, T),
2362 AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2363 return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2367 # pragma warning(pop)
2370 } // namespace testing
2372 // Include any custom actions added by the local installation.
2373 // We must include this header at the end to make sure it can use the
2374 // declarations from this file.
2375 #include "gmock/internal/custom/gmock-generated-actions.h"
2377 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_