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