1 $$ -*- mode: c++; -*-
2 $$ This is a Pump source file. Please use Pump to convert it to
3 $$ gmock-generated-actions.h.
4 $$
5 $var n = 10 $$ The maximum arity we support.
6 $$}} This meta comment fixes auto-indentation in editors.
7 // Copyright 2007, Google Inc.
8 // All rights reserved.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // * Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 // * Redistributions in binary form must reproduce the above
17 // copyright notice, this list of conditions and the following disclaimer
18 // in the documentation and/or other materials provided with the
19 // distribution.
20 // * Neither the name of Google Inc. nor the names of its
21 // contributors may be used to endorse or promote products derived from
22 // this software without specific prior written permission.
23 //
24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35
36
37 // Google Mock - a framework for writing C++ mock classes.
38 //
39 // This file implements some commonly used variadic actions.
40
41 // GOOGLETEST_CM0002 DO NOT DELETE
42
43 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
44 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
45
46 #include "gmock/gmock-actions.h"
47 #include "gmock/internal/gmock-port.h"
48
49 namespace testing {
50 namespace internal {
51
52 // InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
53 // function, method, or callback with the unpacked values, where F is
54 // a function type that takes N arguments.
55 template <typename Result, typename ArgumentTuple>
56 class InvokeHelper;
57
58
59 $var max_callback_arity = 5
60 $range i 0..n
61 $for i [[
62 $range j 1..i
63 $var types = [[$for j [[, typename A$j]]]]
64 $var as = [[$for j, [[A$j]]]]
65 $var args = [[$if i==0 [[]] $else [[ args]]]]
66 $var gets = [[$for j, [[get<$(j - 1)>(args)]]]]
67 template <typename R$types>
68 class InvokeHelper<R, ::testing::tuple<$as> > {
69 public:
70 template <typename Function>
71 static R Invoke(Function function, const ::testing::tuple<$as>&$args) {
72 return function($gets);
73 }
74
75 template <class Class, typename MethodPtr>
76 static R InvokeMethod(Class* obj_ptr,
77 MethodPtr method_ptr,
78 const ::testing::tuple<$as>&$args) {
79 return (obj_ptr->*method_ptr)($gets);
80 }
81
82
83 $if i <= max_callback_arity [[
84 template <typename CallbackType>
85 static R InvokeCallback(CallbackType* callback,
86 const ::testing::tuple<$as>&$args) {
87 return callback->Run($gets);
88 }
89 ]] $else [[
90 // There is no InvokeCallback() for $i-tuples
91 ]]
92
93 };
94
95
96 ]]
97 // Implements the Invoke(callback) action.
98 template <typename CallbackType>
99 class InvokeCallbackAction {
100 public:
101 // The c'tor takes ownership of the callback.
102 explicit InvokeCallbackAction(CallbackType* callback)
103 : callback_(callback) {
104 callback->CheckIsRepeatable(); // Makes sure the callback is permanent.
105 }
106
107 // This type conversion operator template allows Invoke(callback) to
108 // be used wherever the callback's type is compatible with that of
109 // the mock function, i.e. if the mock function's arguments can be
110 // implicitly converted to the callback's arguments and the
111 // callback's result can be implicitly converted to the mock
112 // function's result.
113 template <typename Result, typename ArgumentTuple>
114 Result Perform(const ArgumentTuple& args) const {
115 return InvokeHelper<Result, ArgumentTuple>::InvokeCallback(
116 callback_.get(), args);
117 }
118 private:
119 const linked_ptr<CallbackType> callback_;
120 };
121
122 // An INTERNAL macro for extracting the type of a tuple field. It's
123 // subject to change without notice - DO NOT USE IN USER CODE!
124 #define GMOCK_FIELD_(Tuple, N) \
125 typename ::testing::tuple_element<N, Tuple>::type
126
127 $range i 1..n
128
129 // SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
130 // type of an n-ary function whose i-th (1-based) argument type is the
131 // k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
132 // type, and whose return type is Result. For example,
133 // SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
134 // is int(bool, long).
135 //
136 // SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
137 // returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
138 // For example,
139 // SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
140 // ::testing::make_tuple(true, 'a', 2.5))
141 // returns tuple (2.5, true).
142 //
143 // The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
144 // in the range [0, $n]. Duplicates are allowed and they don't have
145 // to be in an ascending or descending order.
146
147 template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]>
148 class SelectArgs {
149 public:
150 typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]);
151 typedef typename Function<type>::ArgumentTuple SelectedArgs;
152 static SelectedArgs Select(const ArgumentTuple& args) {
153 return SelectedArgs($for i, [[get<k$i>(args)]]);
154 }
155 };
156
157
158 $for i [[
159 $range j 1..n
160 $range j1 1..i-1
161 template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]>
162 class SelectArgs<Result, ArgumentTuple,
163 $for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> {
164 public:
165 typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]);
166 typedef typename Function<type>::ArgumentTuple SelectedArgs;
167 static SelectedArgs Select(const ArgumentTuple& [[]]
168 $if i == 1 [[/* args */]] $else [[args]]) {
169 return SelectedArgs($for j1, [[get<k$j1>(args)]]);
170 }
171 };
172
173
174 ]]
175 #undef GMOCK_FIELD_
176
177 $var ks = [[$for i, [[k$i]]]]
178
179 // Implements the WithArgs action.
180 template <typename InnerAction, $for i, [[int k$i = -1]]>
181 class WithArgsAction {
182 public:
183 explicit WithArgsAction(const InnerAction& action) : action_(action) {}
184
185 template <typename F>
186 operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
187
188 private:
189 template <typename F>
190 class Impl : public ActionInterface<F> {
191 public:
192 typedef typename Function<F>::Result Result;
193 typedef typename Function<F>::ArgumentTuple ArgumentTuple;
194
195 explicit Impl(const InnerAction& action) : action_(action) {}
196
197 virtual Result Perform(const ArgumentTuple& args) {
198 return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args));
199 }
200
201 private:
202 typedef typename SelectArgs<Result, ArgumentTuple,
203 $ks>::type InnerFunctionType;
204
205 Action<InnerFunctionType> action_;
206 };
207
208 const InnerAction action_;
209
210 GTEST_DISALLOW_ASSIGN_(WithArgsAction);
211 };
212
213 // A macro from the ACTION* family (defined later in this file)
214 // defines an action that can be used in a mock function. Typically,
215 // these actions only care about a subset of the arguments of the mock
216 // function. For example, if such an action only uses the second
217 // argument, it can be used in any mock function that takes >= 2
218 // arguments where the type of the second argument is compatible.
219 //
220 // Therefore, the action implementation must be prepared to take more
221 // arguments than it needs. The ExcessiveArg type is used to
222 // represent those excessive arguments. In order to keep the compiler
223 // error messages tractable, we define it in the testing namespace
224 // instead of testing::internal. However, this is an INTERNAL TYPE
225 // and subject to change without notice, so a user MUST NOT USE THIS
226 // TYPE DIRECTLY.
227 struct ExcessiveArg {};
228
229 // A helper class needed for implementing the ACTION* macros.
230 template <typename Result, class Impl>
231 class ActionHelper {
232 public:
233 $range i 0..n
234 $for i
235
236 [[
237 $var template = [[$if i==0 [[]] $else [[
238 $range j 0..i-1
239 template <$for j, [[typename A$j]]>
240 ]]]]
241 $range j 0..i-1
242 $var As = [[$for j, [[A$j]]]]
243 $var as = [[$for j, [[get<$j>(args)]]]]
244 $range k 1..n-i
245 $var eas = [[$for k, [[ExcessiveArg()]]]]
246 $var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]]
247 $template
248 static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) {
249 return impl->template gmock_PerformImpl<$As>(args, $arg_list);
250 }
251
252 ]]
253 };
254
255 } // namespace internal
256
257 // Various overloads for Invoke().
258
259 // WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
260 // the selected arguments of the mock function to an_action and
261 // performs it. It serves as an adaptor between actions with
262 // different argument lists. C++ doesn't support default arguments for
263 // function templates, so we have to overload it.
264
265 $range i 1..n
266 $for i [[
267 $range j 1..i
268 template <$for j [[int k$j, ]]typename InnerAction>
269 inline internal::WithArgsAction<InnerAction$for j [[, k$j]]>
270 WithArgs(const InnerAction& action) {
271 return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action);
272 }
273
274
275 ]]
276 // Creates an action that does actions a1, a2, ..., sequentially in
277 // each invocation.
278 $range i 2..n
279 $for i [[
280 $range j 2..i
281 $var types = [[$for j, [[typename Action$j]]]]
282 $var Aas = [[$for j [[, Action$j a$j]]]]
283
284 template <typename Action1, $types>
285 $range k 1..i-1
286
287 inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k [[>]]
288
289 DoAll(Action1 a1$Aas) {
290 $if i==2 [[
291
292 return internal::DoBothAction<Action1, Action2>(a1, a2);
293 ]] $else [[
294 $range j2 2..i
295
296 return DoAll(a1, DoAll($for j2, [[a$j2]]));
297 ]]
298
299 }
300
301 ]]
302
303 } // namespace testing
304
305 // The ACTION* family of macros can be used in a namespace scope to
306 // define custom actions easily. The syntax:
307 //
308 // ACTION(name) { statements; }
309 //
310 // will define an action with the given name that executes the
311 // statements. The value returned by the statements will be used as
312 // the return value of the action. Inside the statements, you can
313 // refer to the K-th (0-based) argument of the mock function by
314 // 'argK', and refer to its type by 'argK_type'. For example:
315 //
316 // ACTION(IncrementArg1) {
317 // arg1_type temp = arg1;
318 // return ++(*temp);
319 // }
320 //
321 // allows you to write
322 //
323 // ...WillOnce(IncrementArg1());
324 //
325 // You can also refer to the entire argument tuple and its type by
326 // 'args' and 'args_type', and refer to the mock function type and its
327 // return type by 'function_type' and 'return_type'.
328 //
329 // Note that you don't need to specify the types of the mock function
330 // arguments. However rest assured that your code is still type-safe:
331 // you'll get a compiler error if *arg1 doesn't support the ++
332 // operator, or if the type of ++(*arg1) isn't compatible with the
333 // mock function's return type, for example.
334 //
335 // Sometimes you'll want to parameterize the action. For that you can use
336 // another macro:
337 //
338 // ACTION_P(name, param_name) { statements; }
339 //
340 // For example:
341 //
342 // ACTION_P(Add, n) { return arg0 + n; }
343 //
344 // will allow you to write:
345 //
346 // ...WillOnce(Add(5));
347 //
348 // Note that you don't need to provide the type of the parameter
349 // either. If you need to reference the type of a parameter named
350 // 'foo', you can write 'foo_type'. For example, in the body of
351 // ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
352 // of 'n'.
353 //
354 // We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support
355 // multi-parameter actions.
356 //
357 // For the purpose of typing, you can view
358 //
359 // ACTION_Pk(Foo, p1, ..., pk) { ... }
360 //
361 // as shorthand for
362 //
363 // template <typename p1_type, ..., typename pk_type>
364 // FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
365 //
366 // In particular, you can provide the template type arguments
367 // explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
368 // although usually you can rely on the compiler to infer the types
369 // for you automatically. You can assign the result of expression
370 // Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
371 // pk_type>. This can be useful when composing actions.
372 //
373 // You can also overload actions with different numbers of parameters:
374 //
375 // ACTION_P(Plus, a) { ... }
376 // ACTION_P2(Plus, a, b) { ... }
377 //
378 // While it's tempting to always use the ACTION* macros when defining
379 // a new action, you should also consider implementing ActionInterface
380 // or using MakePolymorphicAction() instead, especially if you need to
381 // use the action a lot. While these approaches require more work,
382 // they give you more control on the types of the mock function
383 // arguments and the action parameters, which in general leads to
384 // better compiler error messages that pay off in the long run. They
385 // also allow overloading actions based on parameter types (as opposed
386 // to just based on the number of parameters).
387 //
388 // CAVEAT:
389 //
390 // ACTION*() can only be used in a namespace scope. The reason is
391 // that C++ doesn't yet allow function-local types to be used to
392 // instantiate templates. The up-coming C++0x standard will fix this.
393 // Once that's done, we'll consider supporting using ACTION*() inside
394 // a function.
395 //
396 // MORE INFORMATION:
397 //
398 // To learn more about using these macros, please search for 'ACTION'
399 // on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
400
401 $range i 0..n
402 $range k 0..n-1
403
404 // An internal macro needed for implementing ACTION*().
405 #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
406 const args_type& args GTEST_ATTRIBUTE_UNUSED_
407 $for k [[, \
408 arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]]
409
410
411 // Sometimes you want to give an action explicit template parameters
412 // that cannot be inferred from its value parameters. ACTION() and
413 // ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that
414 // and can be viewed as an extension to ACTION() and ACTION_P*().
415 //
416 // The syntax:
417 //
418 // ACTION_TEMPLATE(ActionName,
419 // HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
420 // AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
421 //
422 // defines an action template that takes m explicit template
423 // parameters and n value parameters. name_i is the name of the i-th
424 // template parameter, and kind_i specifies whether it's a typename,
425 // an integral constant, or a template. p_i is the name of the i-th
426 // value parameter.
427 //
428 // Example:
429 //
430 // // DuplicateArg<k, T>(output) converts the k-th argument of the mock
431 // // function to type T and copies it to *output.
432 // ACTION_TEMPLATE(DuplicateArg,
433 // HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
434 // AND_1_VALUE_PARAMS(output)) {
435 // *output = T(::testing::get<k>(args));
436 // }
437 // ...
438 // int n;
439 // EXPECT_CALL(mock, Foo(_, _))
440 // .WillOnce(DuplicateArg<1, unsigned char>(&n));
441 //
442 // To create an instance of an action template, write:
443 //
444 // ActionName<t1, ..., t_m>(v1, ..., v_n)
445 //
446 // where the ts are the template arguments and the vs are the value
447 // arguments. The value argument types are inferred by the compiler.
448 // If you want to explicitly specify the value argument types, you can
449 // provide additional template arguments:
450 //
451 // ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
452 //
453 // where u_i is the desired type of v_i.
454 //
455 // ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
456 // number of value parameters, but not on the number of template
457 // parameters. Without the restriction, the meaning of the following
458 // is unclear:
459 //
460 // OverloadedAction<int, bool>(x);
461 //
462 // Are we using a single-template-parameter action where 'bool' refers
463 // to the type of x, or are we using a two-template-parameter action
464 // where the compiler is asked to infer the type of x?
465 //
466 // Implementation notes:
467 //
468 // GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
469 // GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
470 // implementing ACTION_TEMPLATE. The main trick we use is to create
471 // new macro invocations when expanding a macro. For example, we have
472 //
473 // #define ACTION_TEMPLATE(name, template_params, value_params)
474 // ... GMOCK_INTERNAL_DECL_##template_params ...
475 //
476 // which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
477 // to expand to
478 //
479 // ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
480 //
481 // Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
482 // preprocessor will continue to expand it to
483 //
484 // ... typename T ...
485 //
486 // This technique conforms to the C++ standard and is portable. It
487 // allows us to implement action templates using O(N) code, where N is
488 // the maximum number of template/value parameters supported. Without
489 // using it, we'd have to devote O(N^2) amount of code to implement all
490 // combinations of m and n.
491
492 // Declares the template parameters.
493
494 $range j 1..n
495 $for j [[
496 $range m 0..j-1
497 #define GMOCK_INTERNAL_DECL_HAS_$j[[]]
498 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]]
499
500
501 ]]
502
503 // Lists the template parameters.
504
505 $for j [[
506 $range m 0..j-1
507 #define GMOCK_INTERNAL_LIST_HAS_$j[[]]
508 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]]
509
510
511 ]]
512
513 // Declares the types of value parameters.
514
515 $for i [[
516 $range j 0..i-1
517 #define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]]
518 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]]
519
520
521 ]]
522
523 // Initializes the value parameters.
524
525 $for i [[
526 $range j 0..i-1
527 #define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\
528 ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::testing::internal::move(gmock_p$j))]]
529
530
531 ]]
532
533 // Declares the fields for storing the value parameters.
534
535 $for i [[
536 $range j 0..i-1
537 #define GMOCK_INTERNAL_DEFN_AND_$i[[]]
538 _VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]]
539
540
541 ]]
542
543 // Lists the value parameters.
544
545 $for i [[
546 $range j 0..i-1
547 #define GMOCK_INTERNAL_LIST_AND_$i[[]]
548 _VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]]
549
550
551 ]]
552
553 // Lists the value parameter types.
554
555 $for i [[
556 $range j 0..i-1
557 #define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]]
558 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]]
559
560
561 ]]
562
563 // Declares the value parameters.
564
565 $for i [[
566 $range j 0..i-1
567 #define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
568 $for j, [[p$j##_type p$j]]
569
570
571 ]]
572
573 // The suffix of the class template implementing the action template.
574 $for i [[
575
576
577 $range j 0..i-1
578 #define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
579 $if i==1 [[P]] $elif i>=2 [[P$i]]
580 ]]
581
582
583 // The name of the class template implementing the action template.
584 #define GMOCK_ACTION_CLASS_(name, value_params)\
585 GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
586
587 $range k 0..n-1
588
589 #define ACTION_TEMPLATE(name, template_params, value_params)\
590 template <GMOCK_INTERNAL_DECL_##template_params\
591 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
592 class GMOCK_ACTION_CLASS_(name, value_params) {\
593 public:\
594 explicit GMOCK_ACTION_CLASS_(name, value_params)\
595 GMOCK_INTERNAL_INIT_##value_params {}\
596 template <typename F>\
597 class gmock_Impl : public ::testing::ActionInterface<F> {\
598 public:\
599 typedef F function_type;\
600 typedef typename ::testing::internal::Function<F>::Result return_type;\
601 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
602 args_type;\
603 explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
604 virtual return_type Perform(const args_type& args) {\
605 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
606 Perform(this, args);\
607 }\
608 template <$for k, [[typename arg$k[[]]_type]]>\
609 return_type gmock_PerformImpl(const args_type& args[[]]
610 $for k [[, arg$k[[]]_type arg$k]]) const;\
611 GMOCK_INTERNAL_DEFN_##value_params\
612 private:\
613 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
614 };\
615 template <typename F> operator ::testing::Action<F>() const {\
616 return ::testing::Action<F>(\
617 new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
618 }\
619 GMOCK_INTERNAL_DEFN_##value_params\
620 private:\
621 GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
622 };\
623 template <GMOCK_INTERNAL_DECL_##template_params\
624 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
625 inline GMOCK_ACTION_CLASS_(name, value_params)<\
626 GMOCK_INTERNAL_LIST_##template_params\
627 GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
628 GMOCK_INTERNAL_DECL_##value_params) {\
629 return GMOCK_ACTION_CLASS_(name, value_params)<\
630 GMOCK_INTERNAL_LIST_##template_params\
631 GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
632 GMOCK_INTERNAL_LIST_##value_params);\
633 }\
634 template <GMOCK_INTERNAL_DECL_##template_params\
635 GMOCK_INTERNAL_DECL_TYPE_##value_params>\
636 template <typename F>\
637 template <typename arg0_type, typename arg1_type, typename arg2_type, \
638 typename arg3_type, typename arg4_type, typename arg5_type, \
639 typename arg6_type, typename arg7_type, typename arg8_type, \
640 typename arg9_type>\
641 typename ::testing::internal::Function<F>::Result\
642 GMOCK_ACTION_CLASS_(name, value_params)<\
643 GMOCK_INTERNAL_LIST_##template_params\
644 GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
645 gmock_PerformImpl(\
646 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
647
648 $for i
649
650 [[
651 $var template = [[$if i==0 [[]] $else [[
652 $range j 0..i-1
653
654 template <$for j, [[typename p$j##_type]]>\
655 ]]]]
656 $var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]]
657 $else [[P$i]]]]]]
658 $range j 0..i-1
659 $var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
660 $var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
661 $var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::forward<p$j##_type>(gmock_p$j))]]]]]]
662 $var param_field_decls = [[$for j
663 [[
664
665 p$j##_type p$j;\
666 ]]]]
667 $var param_field_decls2 = [[$for j
668 [[
669
670 p$j##_type p$j;\
671 ]]]]
672 $var params = [[$for j, [[p$j]]]]
673 $var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
674 $var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]]
675 $var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]]
676 $var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]]
677 $else [[ACTION_P$i]]]]
678
679 #define $macro_name(name$for j [[, p$j]])\$template
680 class $class_name {\
681 public:\
682 [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\
683 template <typename F>\
684 class gmock_Impl : public ::testing::ActionInterface<F> {\
685 public:\
686 typedef F function_type;\
687 typedef typename ::testing::internal::Function<F>::Result return_type;\
688 typedef typename ::testing::internal::Function<F>::ArgumentTuple\
689 args_type;\
690 [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\
691 virtual return_type Perform(const args_type& args) {\
692 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
693 Perform(this, args);\
694 }\
695 template <$typename_arg_types>\
696 return_type gmock_PerformImpl(const args_type& args, [[]]
697 $arg_types_and_names) const;\$param_field_decls
698 private:\
699 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
700 };\
701 template <typename F> operator ::testing::Action<F>() const {\
702 return ::testing::Action<F>(new gmock_Impl<F>($params));\
703 }\$param_field_decls2
704 private:\
705 GTEST_DISALLOW_ASSIGN_($class_name);\
706 };\$template
707 inline $class_name$param_types name($param_types_and_names) {\
708 return $class_name$param_types($params);\
709 }\$template
710 template <typename F>\
711 template <$typename_arg_types>\
712 typename ::testing::internal::Function<F>::Result\
713 $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\
714 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
715 ]]
716 $$ } // This meta comment fixes auto-indentation in Emacs. It won't
717 $$ // show up in the generated code.
718
719
720 namespace testing {
721
722
723 // The ACTION*() macros trigger warning C4100 (unreferenced formal
724 // parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
725 // the macro definition, as the warnings are generated when the macro
726 // is expanded and macro expansion cannot contain #pragma. Therefore
727 // we suppress them here.
728 #ifdef _MSC_VER
729 # pragma warning(push)
730 # pragma warning(disable:4100)
731 #endif
732
733 // Various overloads for InvokeArgument<N>().
734 //
735 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
736 // (0-based) argument, which must be a k-ary callable, of the mock
737 // function, with arguments a1, a2, ..., a_k.
738 //
739 // Notes:
740 //
741 // 1. The arguments are passed by value by default. If you need to
742 // pass an argument by reference, wrap it inside ByRef(). For
743 // example,
744 //
745 // InvokeArgument<1>(5, string("Hello"), ByRef(foo))
746 //
747 // passes 5 and string("Hello") by value, and passes foo by
748 // reference.
749 //
750 // 2. If the callable takes an argument by reference but ByRef() is
751 // not used, it will receive the reference to a copy of the value,
752 // instead of the original value. For example, when the 0-th
753 // argument of the mock function takes a const string&, the action
754 //
755 // InvokeArgument<0>(string("Hello"))
756 //
757 // makes a copy of the temporary string("Hello") object and passes a
758 // reference of the copy, instead of the original temporary object,
759 // to the callable. This makes it easy for a user to define an
760 // InvokeArgument action from temporary values and have it performed
761 // later.
762
763 namespace internal {
764 namespace invoke_argument {
765
766 // Appears in InvokeArgumentAdl's argument list to help avoid
767 // accidental calls to user functions of the same name.
768 struct AdlTag {};
769
770 // InvokeArgumentAdl - a helper for InvokeArgument.
771 // The basic overloads are provided here for generic functors.
772 // Overloads for other custom-callables are provided in the
773 // internal/custom/callback-actions.h header.
774
775 $range i 0..n
776 $for i
777 [[
778 $range j 1..i
779
780 template <typename R, typename F[[$for j [[, typename A$j]]]]>
781 R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) {
782 return f([[$for j, [[a$j]]]]);
783 }
784 ]]
785
786 } // namespace invoke_argument
787 } // namespace internal
788
789 $range i 0..n
790 $for i [[
791 $range j 0..i-1
792
793 ACTION_TEMPLATE(InvokeArgument,
794 HAS_1_TEMPLATE_PARAMS(int, k),
795 AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) {
796 using internal::invoke_argument::InvokeArgumentAdl;
797 return InvokeArgumentAdl<return_type>(
798 internal::invoke_argument::AdlTag(),
799 ::testing::get<k>(args)$for j [[, p$j]]);
800 }
801
802 ]]
803
804 // Various overloads for ReturnNew<T>().
805 //
806 // The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
807 // instance of type T, constructed on the heap with constructor arguments
808 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
809 $range i 0..n
810 $for i [[
811 $range j 0..i-1
812 $var ps = [[$for j, [[p$j]]]]
813
814 ACTION_TEMPLATE(ReturnNew,
815 HAS_1_TEMPLATE_PARAMS(typename, T),
816 AND_$i[[]]_VALUE_PARAMS($ps)) {
817 return new T($ps);
818 }
819
820 ]]
821
822 #ifdef _MSC_VER
823 # pragma warning(pop)
824 #endif
825
826 } // namespace testing
827
828 // Include any custom callback actions added by the local installation.
829 // We must include this header at the end to make sure it can use the
830 // declarations from this file.
831 #include "gmock/internal/custom/gmock-generated-actions.h"
832
833 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_