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