The Tor Browser / file comparison

comparison: media/webrtc/trunk/testing/gmock_mutant.h

media/webrtc/trunk/testing/gmock_mutant.h

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:a2a18eb1649c
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file automatically generated by testing/generate_gmock_mutant.py.
6 // DO NOT EDIT.
7
8 #ifndef TESTING_GMOCK_MUTANT_H_
9 #define TESTING_GMOCK_MUTANT_H_
10
11 // The intention of this file is to make possible using GMock actions in
12 // all of its syntactic beauty. Classes and helper functions can be used as
13 // more generic variants of Task and Callback classes (see base/task.h)
14 // Mutant supports both pre-bound arguments (like Task) and call-time
15 // arguments (like Callback) - hence the name. :-)
16 //
17 // DispatchToMethod/Function supports two sets of arguments: pre-bound (P) and
18 // call-time (C). The arguments as well as the return type are templatized.
19 // DispatchToMethod/Function will also try to call the selected method or
20 // function even if provided pre-bound arguments does not match exactly with
21 // the function signature hence the X1, X2 ... XN parameters in CreateFunctor.
22 // DispatchToMethod will try to invoke method that may not belong to the
23 // object's class itself but to the object's class base class.
24 //
25 // Additionally you can bind the object at calltime by binding a pointer to
26 // pointer to the object at creation time - before including this file you
27 // have to #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING.
28 //
29 // TODO(stoyan): It's yet not clear to me should we use T& and T&* instead
30 // of T* and T** when we invoke CreateFunctor to match the EXPECT_CALL style.
31 //
32 //
33 // Sample usage with gMock:
34 //
35 // struct Mock : public ObjectDelegate {
36 // MOCK_METHOD2(string, OnRequest(int n, const string& request));
37 // MOCK_METHOD1(void, OnQuit(int exit_code));
38 // MOCK_METHOD2(void, LogMessage(int level, const string& message));
39 //
40 // string HandleFlowers(const string& reply, int n, const string& request) {
41 // string result = SStringPrintf("In request of %d %s ", n, request);
42 // for (int i = 0; i < n; ++i) result.append(reply)
43 // return result;
44 // }
45 //
46 // void DoLogMessage(int level, const string& message) {
47 // }
48 //
49 // void QuitMessageLoop(int seconds) {
50 // MessageLoop* loop = MessageLoop::current();
51 // loop->PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
52 // 1000 * seconds);
53 // }
54 // };
55 //
56 // Mock mock;
57 // // Will invoke mock.HandleFlowers("orchids", n, request)
58 // // "orchids" is a pre-bound argument, and <n> and <request> are call-time
59 // // arguments - they are not known until the OnRequest mock is invoked.
60 // EXPECT_CALL(mock, OnRequest(Ge(5), StartsWith("flower"))
61 // .Times(1)
62 // .WillOnce(Invoke(CreateFunctor(&mock, &Mock::HandleFlowers,
63 // string("orchids"))));
64 //
65 //
66 // // No pre-bound arguments, two call-time arguments passed
67 // // directly to DoLogMessage
68 // EXPECT_CALL(mock, OnLogMessage(_, _))
69 // .Times(AnyNumber())
70 // .WillAlways(Invoke(CreateFunctor, &mock, &Mock::DoLogMessage));
71 //
72 //
73 // // In this case we have a single pre-bound argument - 3. We ignore
74 // // all of the arguments of OnQuit.
75 // EXCEPT_CALL(mock, OnQuit(_))
76 // .Times(1)
77 // .WillOnce(InvokeWithoutArgs(CreateFunctor(
78 // &mock, &Mock::QuitMessageLoop, 3)));
79 //
80 // MessageLoop loop;
81 // loop.Run();
82 //
83 //
84 // // Here is another example of how we can set an action that invokes
85 // // method of an object that is not yet created.
86 // struct Mock : public ObjectDelegate {
87 // MOCK_METHOD1(void, DemiurgeCreated(Demiurge*));
88 // MOCK_METHOD2(void, OnRequest(int count, const string&));
89 //
90 // void StoreDemiurge(Demiurge* w) {
91 // demiurge_ = w;
92 // }
93 //
94 // Demiurge* demiurge;
95 // }
96 //
97 // EXPECT_CALL(mock, DemiurgeCreated(_)).Times(1)
98 // .WillOnce(Invoke(CreateFunctor(&mock, &Mock::StoreDemiurge)));
99 //
100 // EXPECT_CALL(mock, OnRequest(_, StrEq("Moby Dick")))
101 // .Times(AnyNumber())
102 // .WillAlways(WithArgs<0>(Invoke(
103 // CreateFunctor(&mock->demiurge_, &Demiurge::DecreaseMonsters))));
104 //
105
106 #include "base/memory/linked_ptr.h"
107 #include "base/tuple.h" // for Tuple
108
109 namespace testing {
110
111 // 0 - 0
112 template <typename R, typename T, typename Method>
113 inline R DispatchToMethod(T* obj, Method method,
114 const Tuple0& p,
115 const Tuple0& c) {
116 return (obj->*method)();
117 }
118 template <typename R, typename Function>
119 inline R DispatchToFunction(Function function,
120 const Tuple0& p,
121 const Tuple0& c) {
122 return (*function)();
123 }
124
125 // 0 - 1
126 template <typename R, typename T, typename Method, typename C1>
127 inline R DispatchToMethod(T* obj, Method method,
128 const Tuple0& p,
129 const Tuple1<C1>& c) {
130 return (obj->*method)(c.a);
131 }
132 template <typename R, typename Function, typename C1>
133 inline R DispatchToFunction(Function function,
134 const Tuple0& p,
135 const Tuple1<C1>& c) {
136 return (*function)(c.a);
137 }
138
139 // 0 - 2
140 template <typename R, typename T, typename Method, typename C1, typename C2>
141 inline R DispatchToMethod(T* obj, Method method,
142 const Tuple0& p,
143 const Tuple2<C1, C2>& c) {
144 return (obj->*method)(c.a, c.b);
145 }
146 template <typename R, typename Function, typename C1, typename C2>
147 inline R DispatchToFunction(Function function,
148 const Tuple0& p,
149 const Tuple2<C1, C2>& c) {
150 return (*function)(c.a, c.b);
151 }
152
153 // 0 - 3
154 template <typename R, typename T, typename Method, typename C1, typename C2,
155 typename C3>
156 inline R DispatchToMethod(T* obj, Method method,
157 const Tuple0& p,
158 const Tuple3<C1, C2, C3>& c) {
159 return (obj->*method)(c.a, c.b, c.c);
160 }
161 template <typename R, typename Function, typename C1, typename C2, typename C3>
162 inline R DispatchToFunction(Function function,
163 const Tuple0& p,
164 const Tuple3<C1, C2, C3>& c) {
165 return (*function)(c.a, c.b, c.c);
166 }
167
168 // 0 - 4
169 template <typename R, typename T, typename Method, typename C1, typename C2,
170 typename C3, typename C4>
171 inline R DispatchToMethod(T* obj, Method method,
172 const Tuple0& p,
173 const Tuple4<C1, C2, C3, C4>& c) {
174 return (obj->*method)(c.a, c.b, c.c, c.d);
175 }
176 template <typename R, typename Function, typename C1, typename C2, typename C3,
177 typename C4>
178 inline R DispatchToFunction(Function function,
179 const Tuple0& p,
180 const Tuple4<C1, C2, C3, C4>& c) {
181 return (*function)(c.a, c.b, c.c, c.d);
182 }
183
184 // 0 - 5
185 template <typename R, typename T, typename Method, typename C1, typename C2,
186 typename C3, typename C4, typename C5>
187 inline R DispatchToMethod(T* obj, Method method,
188 const Tuple0& p,
189 const Tuple5<C1, C2, C3, C4, C5>& c) {
190 return (obj->*method)(c.a, c.b, c.c, c.d, c.e);
191 }
192 template <typename R, typename Function, typename C1, typename C2, typename C3,
193 typename C4, typename C5>
194 inline R DispatchToFunction(Function function,
195 const Tuple0& p,
196 const Tuple5<C1, C2, C3, C4, C5>& c) {
197 return (*function)(c.a, c.b, c.c, c.d, c.e);
198 }
199
200 // 0 - 6
201 template <typename R, typename T, typename Method, typename C1, typename C2,
202 typename C3, typename C4, typename C5, typename C6>
203 inline R DispatchToMethod(T* obj, Method method,
204 const Tuple0& p,
205 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
206 return (obj->*method)(c.a, c.b, c.c, c.d, c.e, c.f);
207 }
208 template <typename R, typename Function, typename C1, typename C2, typename C3,
209 typename C4, typename C5, typename C6>
210 inline R DispatchToFunction(Function function,
211 const Tuple0& p,
212 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
213 return (*function)(c.a, c.b, c.c, c.d, c.e, c.f);
214 }
215
216 // 1 - 0
217 template <typename R, typename T, typename Method, typename P1>
218 inline R DispatchToMethod(T* obj, Method method,
219 const Tuple1<P1>& p,
220 const Tuple0& c) {
221 return (obj->*method)(p.a);
222 }
223 template <typename R, typename Function, typename P1>
224 inline R DispatchToFunction(Function function,
225 const Tuple1<P1>& p,
226 const Tuple0& c) {
227 return (*function)(p.a);
228 }
229
230 // 1 - 1
231 template <typename R, typename T, typename Method, typename P1, typename C1>
232 inline R DispatchToMethod(T* obj, Method method,
233 const Tuple1<P1>& p,
234 const Tuple1<C1>& c) {
235 return (obj->*method)(p.a, c.a);
236 }
237 template <typename R, typename Function, typename P1, typename C1>
238 inline R DispatchToFunction(Function function,
239 const Tuple1<P1>& p,
240 const Tuple1<C1>& c) {
241 return (*function)(p.a, c.a);
242 }
243
244 // 1 - 2
245 template <typename R, typename T, typename Method, typename P1, typename C1,
246 typename C2>
247 inline R DispatchToMethod(T* obj, Method method,
248 const Tuple1<P1>& p,
249 const Tuple2<C1, C2>& c) {
250 return (obj->*method)(p.a, c.a, c.b);
251 }
252 template <typename R, typename Function, typename P1, typename C1, typename C2>
253 inline R DispatchToFunction(Function function,
254 const Tuple1<P1>& p,
255 const Tuple2<C1, C2>& c) {
256 return (*function)(p.a, c.a, c.b);
257 }
258
259 // 1 - 3
260 template <typename R, typename T, typename Method, typename P1, typename C1,
261 typename C2, typename C3>
262 inline R DispatchToMethod(T* obj, Method method,
263 const Tuple1<P1>& p,
264 const Tuple3<C1, C2, C3>& c) {
265 return (obj->*method)(p.a, c.a, c.b, c.c);
266 }
267 template <typename R, typename Function, typename P1, typename C1, typename C2,
268 typename C3>
269 inline R DispatchToFunction(Function function,
270 const Tuple1<P1>& p,
271 const Tuple3<C1, C2, C3>& c) {
272 return (*function)(p.a, c.a, c.b, c.c);
273 }
274
275 // 1 - 4
276 template <typename R, typename T, typename Method, typename P1, typename C1,
277 typename C2, typename C3, typename C4>
278 inline R DispatchToMethod(T* obj, Method method,
279 const Tuple1<P1>& p,
280 const Tuple4<C1, C2, C3, C4>& c) {
281 return (obj->*method)(p.a, c.a, c.b, c.c, c.d);
282 }
283 template <typename R, typename Function, typename P1, typename C1, typename C2,
284 typename C3, typename C4>
285 inline R DispatchToFunction(Function function,
286 const Tuple1<P1>& p,
287 const Tuple4<C1, C2, C3, C4>& c) {
288 return (*function)(p.a, c.a, c.b, c.c, c.d);
289 }
290
291 // 1 - 5
292 template <typename R, typename T, typename Method, typename P1, typename C1,
293 typename C2, typename C3, typename C4, typename C5>
294 inline R DispatchToMethod(T* obj, Method method,
295 const Tuple1<P1>& p,
296 const Tuple5<C1, C2, C3, C4, C5>& c) {
297 return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e);
298 }
299 template <typename R, typename Function, typename P1, typename C1, typename C2,
300 typename C3, typename C4, typename C5>
301 inline R DispatchToFunction(Function function,
302 const Tuple1<P1>& p,
303 const Tuple5<C1, C2, C3, C4, C5>& c) {
304 return (*function)(p.a, c.a, c.b, c.c, c.d, c.e);
305 }
306
307 // 1 - 6
308 template <typename R, typename T, typename Method, typename P1, typename C1,
309 typename C2, typename C3, typename C4, typename C5, typename C6>
310 inline R DispatchToMethod(T* obj, Method method,
311 const Tuple1<P1>& p,
312 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
313 return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
314 }
315 template <typename R, typename Function, typename P1, typename C1, typename C2,
316 typename C3, typename C4, typename C5, typename C6>
317 inline R DispatchToFunction(Function function,
318 const Tuple1<P1>& p,
319 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
320 return (*function)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
321 }
322
323 // 2 - 0
324 template <typename R, typename T, typename Method, typename P1, typename P2>
325 inline R DispatchToMethod(T* obj, Method method,
326 const Tuple2<P1, P2>& p,
327 const Tuple0& c) {
328 return (obj->*method)(p.a, p.b);
329 }
330 template <typename R, typename Function, typename P1, typename P2>
331 inline R DispatchToFunction(Function function,
332 const Tuple2<P1, P2>& p,
333 const Tuple0& c) {
334 return (*function)(p.a, p.b);
335 }
336
337 // 2 - 1
338 template <typename R, typename T, typename Method, typename P1, typename P2,
339 typename C1>
340 inline R DispatchToMethod(T* obj, Method method,
341 const Tuple2<P1, P2>& p,
342 const Tuple1<C1>& c) {
343 return (obj->*method)(p.a, p.b, c.a);
344 }
345 template <typename R, typename Function, typename P1, typename P2, typename C1>
346 inline R DispatchToFunction(Function function,
347 const Tuple2<P1, P2>& p,
348 const Tuple1<C1>& c) {
349 return (*function)(p.a, p.b, c.a);
350 }
351
352 // 2 - 2
353 template <typename R, typename T, typename Method, typename P1, typename P2,
354 typename C1, typename C2>
355 inline R DispatchToMethod(T* obj, Method method,
356 const Tuple2<P1, P2>& p,
357 const Tuple2<C1, C2>& c) {
358 return (obj->*method)(p.a, p.b, c.a, c.b);
359 }
360 template <typename R, typename Function, typename P1, typename P2, typename C1,
361 typename C2>
362 inline R DispatchToFunction(Function function,
363 const Tuple2<P1, P2>& p,
364 const Tuple2<C1, C2>& c) {
365 return (*function)(p.a, p.b, c.a, c.b);
366 }
367
368 // 2 - 3
369 template <typename R, typename T, typename Method, typename P1, typename P2,
370 typename C1, typename C2, typename C3>
371 inline R DispatchToMethod(T* obj, Method method,
372 const Tuple2<P1, P2>& p,
373 const Tuple3<C1, C2, C3>& c) {
374 return (obj->*method)(p.a, p.b, c.a, c.b, c.c);
375 }
376 template <typename R, typename Function, typename P1, typename P2, typename C1,
377 typename C2, typename C3>
378 inline R DispatchToFunction(Function function,
379 const Tuple2<P1, P2>& p,
380 const Tuple3<C1, C2, C3>& c) {
381 return (*function)(p.a, p.b, c.a, c.b, c.c);
382 }
383
384 // 2 - 4
385 template <typename R, typename T, typename Method, typename P1, typename P2,
386 typename C1, typename C2, typename C3, typename C4>
387 inline R DispatchToMethod(T* obj, Method method,
388 const Tuple2<P1, P2>& p,
389 const Tuple4<C1, C2, C3, C4>& c) {
390 return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d);
391 }
392 template <typename R, typename Function, typename P1, typename P2, typename C1,
393 typename C2, typename C3, typename C4>
394 inline R DispatchToFunction(Function function,
395 const Tuple2<P1, P2>& p,
396 const Tuple4<C1, C2, C3, C4>& c) {
397 return (*function)(p.a, p.b, c.a, c.b, c.c, c.d);
398 }
399
400 // 2 - 5
401 template <typename R, typename T, typename Method, typename P1, typename P2,
402 typename C1, typename C2, typename C3, typename C4, typename C5>
403 inline R DispatchToMethod(T* obj, Method method,
404 const Tuple2<P1, P2>& p,
405 const Tuple5<C1, C2, C3, C4, C5>& c) {
406 return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
407 }
408 template <typename R, typename Function, typename P1, typename P2, typename C1,
409 typename C2, typename C3, typename C4, typename C5>
410 inline R DispatchToFunction(Function function,
411 const Tuple2<P1, P2>& p,
412 const Tuple5<C1, C2, C3, C4, C5>& c) {
413 return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
414 }
415
416 // 2 - 6
417 template <typename R, typename T, typename Method, typename P1, typename P2,
418 typename C1, typename C2, typename C3, typename C4, typename C5,
419 typename C6>
420 inline R DispatchToMethod(T* obj, Method method,
421 const Tuple2<P1, P2>& p,
422 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
423 return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
424 }
425 template <typename R, typename Function, typename P1, typename P2, typename C1,
426 typename C2, typename C3, typename C4, typename C5, typename C6>
427 inline R DispatchToFunction(Function function,
428 const Tuple2<P1, P2>& p,
429 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
430 return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
431 }
432
433 // 3 - 0
434 template <typename R, typename T, typename Method, typename P1, typename P2,
435 typename P3>
436 inline R DispatchToMethod(T* obj, Method method,
437 const Tuple3<P1, P2, P3>& p,
438 const Tuple0& c) {
439 return (obj->*method)(p.a, p.b, p.c);
440 }
441 template <typename R, typename Function, typename P1, typename P2, typename P3>
442 inline R DispatchToFunction(Function function,
443 const Tuple3<P1, P2, P3>& p,
444 const Tuple0& c) {
445 return (*function)(p.a, p.b, p.c);
446 }
447
448 // 3 - 1
449 template <typename R, typename T, typename Method, typename P1, typename P2,
450 typename P3, typename C1>
451 inline R DispatchToMethod(T* obj, Method method,
452 const Tuple3<P1, P2, P3>& p,
453 const Tuple1<C1>& c) {
454 return (obj->*method)(p.a, p.b, p.c, c.a);
455 }
456 template <typename R, typename Function, typename P1, typename P2, typename P3,
457 typename C1>
458 inline R DispatchToFunction(Function function,
459 const Tuple3<P1, P2, P3>& p,
460 const Tuple1<C1>& c) {
461 return (*function)(p.a, p.b, p.c, c.a);
462 }
463
464 // 3 - 2
465 template <typename R, typename T, typename Method, typename P1, typename P2,
466 typename P3, typename C1, typename C2>
467 inline R DispatchToMethod(T* obj, Method method,
468 const Tuple3<P1, P2, P3>& p,
469 const Tuple2<C1, C2>& c) {
470 return (obj->*method)(p.a, p.b, p.c, c.a, c.b);
471 }
472 template <typename R, typename Function, typename P1, typename P2, typename P3,
473 typename C1, typename C2>
474 inline R DispatchToFunction(Function function,
475 const Tuple3<P1, P2, P3>& p,
476 const Tuple2<C1, C2>& c) {
477 return (*function)(p.a, p.b, p.c, c.a, c.b);
478 }
479
480 // 3 - 3
481 template <typename R, typename T, typename Method, typename P1, typename P2,
482 typename P3, typename C1, typename C2, typename C3>
483 inline R DispatchToMethod(T* obj, Method method,
484 const Tuple3<P1, P2, P3>& p,
485 const Tuple3<C1, C2, C3>& c) {
486 return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c);
487 }
488 template <typename R, typename Function, typename P1, typename P2, typename P3,
489 typename C1, typename C2, typename C3>
490 inline R DispatchToFunction(Function function,
491 const Tuple3<P1, P2, P3>& p,
492 const Tuple3<C1, C2, C3>& c) {
493 return (*function)(p.a, p.b, p.c, c.a, c.b, c.c);
494 }
495
496 // 3 - 4
497 template <typename R, typename T, typename Method, typename P1, typename P2,
498 typename P3, typename C1, typename C2, typename C3, typename C4>
499 inline R DispatchToMethod(T* obj, Method method,
500 const Tuple3<P1, P2, P3>& p,
501 const Tuple4<C1, C2, C3, C4>& c) {
502 return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
503 }
504 template <typename R, typename Function, typename P1, typename P2, typename P3,
505 typename C1, typename C2, typename C3, typename C4>
506 inline R DispatchToFunction(Function function,
507 const Tuple3<P1, P2, P3>& p,
508 const Tuple4<C1, C2, C3, C4>& c) {
509 return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
510 }
511
512 // 3 - 5
513 template <typename R, typename T, typename Method, typename P1, typename P2,
514 typename P3, typename C1, typename C2, typename C3, typename C4,
515 typename C5>
516 inline R DispatchToMethod(T* obj, Method method,
517 const Tuple3<P1, P2, P3>& p,
518 const Tuple5<C1, C2, C3, C4, C5>& c) {
519 return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
520 }
521 template <typename R, typename Function, typename P1, typename P2, typename P3,
522 typename C1, typename C2, typename C3, typename C4, typename C5>
523 inline R DispatchToFunction(Function function,
524 const Tuple3<P1, P2, P3>& p,
525 const Tuple5<C1, C2, C3, C4, C5>& c) {
526 return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
527 }
528
529 // 3 - 6
530 template <typename R, typename T, typename Method, typename P1, typename P2,
531 typename P3, typename C1, typename C2, typename C3, typename C4,
532 typename C5, typename C6>
533 inline R DispatchToMethod(T* obj, Method method,
534 const Tuple3<P1, P2, P3>& p,
535 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
536 return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
537 }
538 template <typename R, typename Function, typename P1, typename P2, typename P3,
539 typename C1, typename C2, typename C3, typename C4, typename C5,
540 typename C6>
541 inline R DispatchToFunction(Function function,
542 const Tuple3<P1, P2, P3>& p,
543 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
544 return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
545 }
546
547 // 4 - 0
548 template <typename R, typename T, typename Method, typename P1, typename P2,
549 typename P3, typename P4>
550 inline R DispatchToMethod(T* obj, Method method,
551 const Tuple4<P1, P2, P3, P4>& p,
552 const Tuple0& c) {
553 return (obj->*method)(p.a, p.b, p.c, p.d);
554 }
555 template <typename R, typename Function, typename P1, typename P2, typename P3,
556 typename P4>
557 inline R DispatchToFunction(Function function,
558 const Tuple4<P1, P2, P3, P4>& p,
559 const Tuple0& c) {
560 return (*function)(p.a, p.b, p.c, p.d);
561 }
562
563 // 4 - 1
564 template <typename R, typename T, typename Method, typename P1, typename P2,
565 typename P3, typename P4, typename C1>
566 inline R DispatchToMethod(T* obj, Method method,
567 const Tuple4<P1, P2, P3, P4>& p,
568 const Tuple1<C1>& c) {
569 return (obj->*method)(p.a, p.b, p.c, p.d, c.a);
570 }
571 template <typename R, typename Function, typename P1, typename P2, typename P3,
572 typename P4, typename C1>
573 inline R DispatchToFunction(Function function,
574 const Tuple4<P1, P2, P3, P4>& p,
575 const Tuple1<C1>& c) {
576 return (*function)(p.a, p.b, p.c, p.d, c.a);
577 }
578
579 // 4 - 2
580 template <typename R, typename T, typename Method, typename P1, typename P2,
581 typename P3, typename P4, typename C1, typename C2>
582 inline R DispatchToMethod(T* obj, Method method,
583 const Tuple4<P1, P2, P3, P4>& p,
584 const Tuple2<C1, C2>& c) {
585 return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b);
586 }
587 template <typename R, typename Function, typename P1, typename P2, typename P3,
588 typename P4, typename C1, typename C2>
589 inline R DispatchToFunction(Function function,
590 const Tuple4<P1, P2, P3, P4>& p,
591 const Tuple2<C1, C2>& c) {
592 return (*function)(p.a, p.b, p.c, p.d, c.a, c.b);
593 }
594
595 // 4 - 3
596 template <typename R, typename T, typename Method, typename P1, typename P2,
597 typename P3, typename P4, typename C1, typename C2, typename C3>
598 inline R DispatchToMethod(T* obj, Method method,
599 const Tuple4<P1, P2, P3, P4>& p,
600 const Tuple3<C1, C2, C3>& c) {
601 return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c);
602 }
603 template <typename R, typename Function, typename P1, typename P2, typename P3,
604 typename P4, typename C1, typename C2, typename C3>
605 inline R DispatchToFunction(Function function,
606 const Tuple4<P1, P2, P3, P4>& p,
607 const Tuple3<C1, C2, C3>& c) {
608 return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c);
609 }
610
611 // 4 - 4
612 template <typename R, typename T, typename Method, typename P1, typename P2,
613 typename P3, typename P4, typename C1, typename C2, typename C3,
614 typename C4>
615 inline R DispatchToMethod(T* obj, Method method,
616 const Tuple4<P1, P2, P3, P4>& p,
617 const Tuple4<C1, C2, C3, C4>& c) {
618 return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
619 }
620 template <typename R, typename Function, typename P1, typename P2, typename P3,
621 typename P4, typename C1, typename C2, typename C3, typename C4>
622 inline R DispatchToFunction(Function function,
623 const Tuple4<P1, P2, P3, P4>& p,
624 const Tuple4<C1, C2, C3, C4>& c) {
625 return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
626 }
627
628 // 4 - 5
629 template <typename R, typename T, typename Method, typename P1, typename P2,
630 typename P3, typename P4, typename C1, typename C2, typename C3,
631 typename C4, typename C5>
632 inline R DispatchToMethod(T* obj, Method method,
633 const Tuple4<P1, P2, P3, P4>& p,
634 const Tuple5<C1, C2, C3, C4, C5>& c) {
635 return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
636 }
637 template <typename R, typename Function, typename P1, typename P2, typename P3,
638 typename P4, typename C1, typename C2, typename C3, typename C4,
639 typename C5>
640 inline R DispatchToFunction(Function function,
641 const Tuple4<P1, P2, P3, P4>& p,
642 const Tuple5<C1, C2, C3, C4, C5>& c) {
643 return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
644 }
645
646 // 4 - 6
647 template <typename R, typename T, typename Method, typename P1, typename P2,
648 typename P3, typename P4, typename C1, typename C2, typename C3,
649 typename C4, typename C5, typename C6>
650 inline R DispatchToMethod(T* obj, Method method,
651 const Tuple4<P1, P2, P3, P4>& p,
652 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
653 return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
654 }
655 template <typename R, typename Function, typename P1, typename P2, typename P3,
656 typename P4, typename C1, typename C2, typename C3, typename C4,
657 typename C5, typename C6>
658 inline R DispatchToFunction(Function function,
659 const Tuple4<P1, P2, P3, P4>& p,
660 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
661 return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
662 }
663
664 // 5 - 0
665 template <typename R, typename T, typename Method, typename P1, typename P2,
666 typename P3, typename P4, typename P5>
667 inline R DispatchToMethod(T* obj, Method method,
668 const Tuple5<P1, P2, P3, P4, P5>& p,
669 const Tuple0& c) {
670 return (obj->*method)(p.a, p.b, p.c, p.d, p.e);
671 }
672 template <typename R, typename Function, typename P1, typename P2, typename P3,
673 typename P4, typename P5>
674 inline R DispatchToFunction(Function function,
675 const Tuple5<P1, P2, P3, P4, P5>& p,
676 const Tuple0& c) {
677 return (*function)(p.a, p.b, p.c, p.d, p.e);
678 }
679
680 // 5 - 1
681 template <typename R, typename T, typename Method, typename P1, typename P2,
682 typename P3, typename P4, typename P5, typename C1>
683 inline R DispatchToMethod(T* obj, Method method,
684 const Tuple5<P1, P2, P3, P4, P5>& p,
685 const Tuple1<C1>& c) {
686 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a);
687 }
688 template <typename R, typename Function, typename P1, typename P2, typename P3,
689 typename P4, typename P5, typename C1>
690 inline R DispatchToFunction(Function function,
691 const Tuple5<P1, P2, P3, P4, P5>& p,
692 const Tuple1<C1>& c) {
693 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a);
694 }
695
696 // 5 - 2
697 template <typename R, typename T, typename Method, typename P1, typename P2,
698 typename P3, typename P4, typename P5, typename C1, typename C2>
699 inline R DispatchToMethod(T* obj, Method method,
700 const Tuple5<P1, P2, P3, P4, P5>& p,
701 const Tuple2<C1, C2>& c) {
702 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
703 }
704 template <typename R, typename Function, typename P1, typename P2, typename P3,
705 typename P4, typename P5, typename C1, typename C2>
706 inline R DispatchToFunction(Function function,
707 const Tuple5<P1, P2, P3, P4, P5>& p,
708 const Tuple2<C1, C2>& c) {
709 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
710 }
711
712 // 5 - 3
713 template <typename R, typename T, typename Method, typename P1, typename P2,
714 typename P3, typename P4, typename P5, typename C1, typename C2,
715 typename C3>
716 inline R DispatchToMethod(T* obj, Method method,
717 const Tuple5<P1, P2, P3, P4, P5>& p,
718 const Tuple3<C1, C2, C3>& c) {
719 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
720 }
721 template <typename R, typename Function, typename P1, typename P2, typename P3,
722 typename P4, typename P5, typename C1, typename C2, typename C3>
723 inline R DispatchToFunction(Function function,
724 const Tuple5<P1, P2, P3, P4, P5>& p,
725 const Tuple3<C1, C2, C3>& c) {
726 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
727 }
728
729 // 5 - 4
730 template <typename R, typename T, typename Method, typename P1, typename P2,
731 typename P3, typename P4, typename P5, typename C1, typename C2,
732 typename C3, typename C4>
733 inline R DispatchToMethod(T* obj, Method method,
734 const Tuple5<P1, P2, P3, P4, P5>& p,
735 const Tuple4<C1, C2, C3, C4>& c) {
736 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
737 }
738 template <typename R, typename Function, typename P1, typename P2, typename P3,
739 typename P4, typename P5, typename C1, typename C2, typename C3,
740 typename C4>
741 inline R DispatchToFunction(Function function,
742 const Tuple5<P1, P2, P3, P4, P5>& p,
743 const Tuple4<C1, C2, C3, C4>& c) {
744 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
745 }
746
747 // 5 - 5
748 template <typename R, typename T, typename Method, typename P1, typename P2,
749 typename P3, typename P4, typename P5, typename C1, typename C2,
750 typename C3, typename C4, typename C5>
751 inline R DispatchToMethod(T* obj, Method method,
752 const Tuple5<P1, P2, P3, P4, P5>& p,
753 const Tuple5<C1, C2, C3, C4, C5>& c) {
754 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
755 }
756 template <typename R, typename Function, typename P1, typename P2, typename P3,
757 typename P4, typename P5, typename C1, typename C2, typename C3,
758 typename C4, typename C5>
759 inline R DispatchToFunction(Function function,
760 const Tuple5<P1, P2, P3, P4, P5>& p,
761 const Tuple5<C1, C2, C3, C4, C5>& c) {
762 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
763 }
764
765 // 5 - 6
766 template <typename R, typename T, typename Method, typename P1, typename P2,
767 typename P3, typename P4, typename P5, typename C1, typename C2,
768 typename C3, typename C4, typename C5, typename C6>
769 inline R DispatchToMethod(T* obj, Method method,
770 const Tuple5<P1, P2, P3, P4, P5>& p,
771 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
772 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
773 }
774 template <typename R, typename Function, typename P1, typename P2, typename P3,
775 typename P4, typename P5, typename C1, typename C2, typename C3,
776 typename C4, typename C5, typename C6>
777 inline R DispatchToFunction(Function function,
778 const Tuple5<P1, P2, P3, P4, P5>& p,
779 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
780 return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
781 }
782
783 // 6 - 0
784 template <typename R, typename T, typename Method, typename P1, typename P2,
785 typename P3, typename P4, typename P5, typename P6>
786 inline R DispatchToMethod(T* obj, Method method,
787 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
788 const Tuple0& c) {
789 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f);
790 }
791 template <typename R, typename Function, typename P1, typename P2, typename P3,
792 typename P4, typename P5, typename P6>
793 inline R DispatchToFunction(Function function,
794 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
795 const Tuple0& c) {
796 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f);
797 }
798
799 // 6 - 1
800 template <typename R, typename T, typename Method, typename P1, typename P2,
801 typename P3, typename P4, typename P5, typename P6, typename C1>
802 inline R DispatchToMethod(T* obj, Method method,
803 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
804 const Tuple1<C1>& c) {
805 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
806 }
807 template <typename R, typename Function, typename P1, typename P2, typename P3,
808 typename P4, typename P5, typename P6, typename C1>
809 inline R DispatchToFunction(Function function,
810 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
811 const Tuple1<C1>& c) {
812 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
813 }
814
815 // 6 - 2
816 template <typename R, typename T, typename Method, typename P1, typename P2,
817 typename P3, typename P4, typename P5, typename P6, typename C1,
818 typename C2>
819 inline R DispatchToMethod(T* obj, Method method,
820 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
821 const Tuple2<C1, C2>& c) {
822 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
823 }
824 template <typename R, typename Function, typename P1, typename P2, typename P3,
825 typename P4, typename P5, typename P6, typename C1, typename C2>
826 inline R DispatchToFunction(Function function,
827 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
828 const Tuple2<C1, C2>& c) {
829 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
830 }
831
832 // 6 - 3
833 template <typename R, typename T, typename Method, typename P1, typename P2,
834 typename P3, typename P4, typename P5, typename P6, typename C1,
835 typename C2, typename C3>
836 inline R DispatchToMethod(T* obj, Method method,
837 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
838 const Tuple3<C1, C2, C3>& c) {
839 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
840 }
841 template <typename R, typename Function, typename P1, typename P2, typename P3,
842 typename P4, typename P5, typename P6, typename C1, typename C2,
843 typename C3>
844 inline R DispatchToFunction(Function function,
845 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
846 const Tuple3<C1, C2, C3>& c) {
847 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
848 }
849
850 // 6 - 4
851 template <typename R, typename T, typename Method, typename P1, typename P2,
852 typename P3, typename P4, typename P5, typename P6, typename C1,
853 typename C2, typename C3, typename C4>
854 inline R DispatchToMethod(T* obj, Method method,
855 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
856 const Tuple4<C1, C2, C3, C4>& c) {
857 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
858 }
859 template <typename R, typename Function, typename P1, typename P2, typename P3,
860 typename P4, typename P5, typename P6, typename C1, typename C2,
861 typename C3, typename C4>
862 inline R DispatchToFunction(Function function,
863 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
864 const Tuple4<C1, C2, C3, C4>& c) {
865 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
866 }
867
868 // 6 - 5
869 template <typename R, typename T, typename Method, typename P1, typename P2,
870 typename P3, typename P4, typename P5, typename P6, typename C1,
871 typename C2, typename C3, typename C4, typename C5>
872 inline R DispatchToMethod(T* obj, Method method,
873 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
874 const Tuple5<C1, C2, C3, C4, C5>& c) {
875 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
876 }
877 template <typename R, typename Function, typename P1, typename P2, typename P3,
878 typename P4, typename P5, typename P6, typename C1, typename C2,
879 typename C3, typename C4, typename C5>
880 inline R DispatchToFunction(Function function,
881 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
882 const Tuple5<C1, C2, C3, C4, C5>& c) {
883 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
884 }
885
886 // 6 - 6
887 template <typename R, typename T, typename Method, typename P1, typename P2,
888 typename P3, typename P4, typename P5, typename P6, typename C1,
889 typename C2, typename C3, typename C4, typename C5, typename C6>
890 inline R DispatchToMethod(T* obj, Method method,
891 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
892 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
893 return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
894 }
895 template <typename R, typename Function, typename P1, typename P2, typename P3,
896 typename P4, typename P5, typename P6, typename C1, typename C2,
897 typename C3, typename C4, typename C5, typename C6>
898 inline R DispatchToFunction(Function function,
899 const Tuple6<P1, P2, P3, P4, P5, P6>& p,
900 const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
901 return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
902 }
903
904 // Interface that is exposed to the consumer, that does the actual calling
905 // of the method.
906 template <typename R, typename Params>
907 class MutantRunner {
908 public:
909 virtual R RunWithParams(const Params& params) = 0;
910 virtual ~MutantRunner() {}
911 };
912
913 // Mutant holds pre-bound arguments (like Task). Like Callback
914 // allows call-time arguments. You bind a pointer to the object
915 // at creation time.
916 template <typename R, typename T, typename Method,
917 typename PreBound, typename Params>
918 class Mutant : public MutantRunner<R, Params> {
919 public:
920 Mutant(T* obj, Method method, const PreBound& pb)
921 : obj_(obj), method_(method), pb_(pb) {
922 }
923
924 // MutantRunner implementation
925 virtual R RunWithParams(const Params& params) {
926 return DispatchToMethod<R>(this->obj_, this->method_, pb_, params);
927 }
928
929 T* obj_;
930 Method method_;
931 PreBound pb_;
932 };
933
934 template <typename R, typename Function, typename PreBound, typename Params>
935 class MutantFunction : public MutantRunner<R, Params> {
936 public:
937 MutantFunction(Function function, const PreBound& pb)
938 : function_(function), pb_(pb) {
939 }
940
941 // MutantRunner implementation
942 virtual R RunWithParams(const Params& params) {
943 return DispatchToFunction<R>(function_, pb_, params);
944 }
945
946 Function function_;
947 PreBound pb_;
948 };
949
950 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
951 // MutantLateBind is like Mutant, but you bind a pointer to a pointer
952 // to the object. This way you can create actions for an object
953 // that is not yet created (has only storage for a pointer to it).
954 template <typename R, typename T, typename Method,
955 typename PreBound, typename Params>
956 class MutantLateObjectBind : public MutantRunner<R, Params> {
957 public:
958 MutantLateObjectBind(T** obj, Method method, const PreBound& pb)
959 : obj_(obj), method_(method), pb_(pb) {
960 }
961
962 // MutantRunner implementation.
963 virtual R RunWithParams(const Params& params) {
964 EXPECT_THAT(*this->obj_, testing::NotNull());
965 if (NULL == *this->obj_)
966 return R();
967 return DispatchToMethod<R>( *this->obj_, this->method_, pb_, params);
968 }
969
970 T** obj_;
971 Method method_;
972 PreBound pb_;
973 };
974 #endif
975
976 // Simple MutantRunner<> wrapper acting as a functor.
977 // Redirects operator() to MutantRunner<Params>::Run()
978 template <typename R, typename Params>
979 struct MutantFunctor {
980 explicit MutantFunctor(MutantRunner<R, Params>* cb) : impl_(cb) {
981 }
982
983 ~MutantFunctor() {
984 }
985
986 inline R operator()() {
987 return impl_->RunWithParams(Tuple0());
988 }
989
990 template <typename Arg1>
991 inline R operator()(const Arg1& a) {
992 return impl_->RunWithParams(Params(a));
993 }
994
995 template <typename Arg1, typename Arg2>
996 inline R operator()(const Arg1& a, const Arg2& b) {
997 return impl_->RunWithParams(Params(a, b));
998 }
999
1000 template <typename Arg1, typename Arg2, typename Arg3>
1001 inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c) {
1002 return impl_->RunWithParams(Params(a, b, c));
1003 }
1004
1005 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1006 inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c,
1007 const Arg4& d) {
1008 return impl_->RunWithParams(Params(a, b, c, d));
1009 }
1010
1011 private:
1012 // We need copy constructor since MutantFunctor is copied few times
1013 // inside GMock machinery, hence no DISALLOW_EVIL_CONTRUCTORS
1014 MutantFunctor();
1015 linked_ptr<MutantRunner<R, Params> > impl_;
1016 };
1017
1018 // 0 - 0
1019 template <typename R, typename T, typename U>
1020 inline MutantFunctor<R, Tuple0>
1021 CreateFunctor(T* obj, R (U::*method)()) {
1022 MutantRunner<R, Tuple0>* t =
1023 new Mutant<R, T, R (U::*)(),
1024 Tuple0, Tuple0>
1025 (obj, method, MakeTuple());
1026 return MutantFunctor<R, Tuple0>(t);
1027 }
1028
1029 template <typename R>
1030 inline MutantFunctor<R, Tuple0>
1031 CreateFunctor(R (*function)()) {
1032 MutantRunner<R, Tuple0>* t =
1033 new MutantFunction<R, R (*)(),
1034 Tuple0, Tuple0>
1035 (function, MakeTuple());
1036 return MutantFunctor<R, Tuple0>(t);
1037 }
1038
1039 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1040 template <typename R, typename T, typename U>
1041 inline MutantFunctor<R, Tuple0>
1042 CreateFunctor(T** obj, R (U::*method)()) {
1043 MutantRunner<R, Tuple0>* t =
1044 new MutantLateObjectBind<R, T, R (U::*)(),
1045 Tuple0, Tuple0>
1046 (obj, method, MakeTuple());
1047 return MutantFunctor<R, Tuple0>(t);
1048 }
1049 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1050
1051 #if defined (OS_WIN)
1052 template <typename R, typename T, typename U>
1053 inline MutantFunctor<R, Tuple0>
1054 CreateFunctor(T* obj, R (__stdcall U::*method)()) {
1055 MutantRunner<R, Tuple0>* t =
1056 new Mutant<R, T, R (__stdcall U::*)(),
1057 Tuple0, Tuple0>
1058 (obj, method, MakeTuple());
1059 return MutantFunctor<R, Tuple0>(t);
1060 }
1061
1062 template <typename R>
1063 inline MutantFunctor<R, Tuple0>
1064 CreateFunctor(R (__stdcall *function)()) {
1065 MutantRunner<R, Tuple0>* t =
1066 new MutantFunction<R, R (__stdcall *)(),
1067 Tuple0, Tuple0>
1068 (function, MakeTuple());
1069 return MutantFunctor<R, Tuple0>(t);
1070 }
1071 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1072 template <typename R, typename T, typename U>
1073 inline MutantFunctor<R, Tuple0>
1074 CreateFunctor(T** obj, R (__stdcall U::*method)()) {
1075 MutantRunner<R, Tuple0>* t =
1076 new MutantLateObjectBind<R, T, R (__stdcall U::*)(),
1077 Tuple0, Tuple0>
1078 (obj, method, MakeTuple());
1079 return MutantFunctor<R, Tuple0>(t);
1080 }
1081 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1082 #endif // OS_WIN
1083
1084 // 0 - 1
1085 template <typename R, typename T, typename U, typename A1>
1086 inline MutantFunctor<R, Tuple1<A1> >
1087 CreateFunctor(T* obj, R (U::*method)(A1)) {
1088 MutantRunner<R, Tuple1<A1> >* t =
1089 new Mutant<R, T, R (U::*)(A1),
1090 Tuple0, Tuple1<A1> >
1091 (obj, method, MakeTuple());
1092 return MutantFunctor<R, Tuple1<A1> >(t);
1093 }
1094
1095 template <typename R, typename A1>
1096 inline MutantFunctor<R, Tuple1<A1> >
1097 CreateFunctor(R (*function)(A1)) {
1098 MutantRunner<R, Tuple1<A1> >* t =
1099 new MutantFunction<R, R (*)(A1),
1100 Tuple0, Tuple1<A1> >
1101 (function, MakeTuple());
1102 return MutantFunctor<R, Tuple1<A1> >(t);
1103 }
1104
1105 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1106 template <typename R, typename T, typename U, typename A1>
1107 inline MutantFunctor<R, Tuple1<A1> >
1108 CreateFunctor(T** obj, R (U::*method)(A1)) {
1109 MutantRunner<R, Tuple1<A1> >* t =
1110 new MutantLateObjectBind<R, T, R (U::*)(A1),
1111 Tuple0, Tuple1<A1> >
1112 (obj, method, MakeTuple());
1113 return MutantFunctor<R, Tuple1<A1> >(t);
1114 }
1115 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1116
1117 #if defined (OS_WIN)
1118 template <typename R, typename T, typename U, typename A1>
1119 inline MutantFunctor<R, Tuple1<A1> >
1120 CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) {
1121 MutantRunner<R, Tuple1<A1> >* t =
1122 new Mutant<R, T, R (__stdcall U::*)(A1),
1123 Tuple0, Tuple1<A1> >
1124 (obj, method, MakeTuple());
1125 return MutantFunctor<R, Tuple1<A1> >(t);
1126 }
1127
1128 template <typename R, typename A1>
1129 inline MutantFunctor<R, Tuple1<A1> >
1130 CreateFunctor(R (__stdcall *function)(A1)) {
1131 MutantRunner<R, Tuple1<A1> >* t =
1132 new MutantFunction<R, R (__stdcall *)(A1),
1133 Tuple0, Tuple1<A1> >
1134 (function, MakeTuple());
1135 return MutantFunctor<R, Tuple1<A1> >(t);
1136 }
1137 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1138 template <typename R, typename T, typename U, typename A1>
1139 inline MutantFunctor<R, Tuple1<A1> >
1140 CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) {
1141 MutantRunner<R, Tuple1<A1> >* t =
1142 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1),
1143 Tuple0, Tuple1<A1> >
1144 (obj, method, MakeTuple());
1145 return MutantFunctor<R, Tuple1<A1> >(t);
1146 }
1147 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1148 #endif // OS_WIN
1149
1150 // 0 - 2
1151 template <typename R, typename T, typename U, typename A1, typename A2>
1152 inline MutantFunctor<R, Tuple2<A1, A2> >
1153 CreateFunctor(T* obj, R (U::*method)(A1, A2)) {
1154 MutantRunner<R, Tuple2<A1, A2> >* t =
1155 new Mutant<R, T, R (U::*)(A1, A2),
1156 Tuple0, Tuple2<A1, A2> >
1157 (obj, method, MakeTuple());
1158 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1159 }
1160
1161 template <typename R, typename A1, typename A2>
1162 inline MutantFunctor<R, Tuple2<A1, A2> >
1163 CreateFunctor(R (*function)(A1, A2)) {
1164 MutantRunner<R, Tuple2<A1, A2> >* t =
1165 new MutantFunction<R, R (*)(A1, A2),
1166 Tuple0, Tuple2<A1, A2> >
1167 (function, MakeTuple());
1168 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1169 }
1170
1171 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1172 template <typename R, typename T, typename U, typename A1, typename A2>
1173 inline MutantFunctor<R, Tuple2<A1, A2> >
1174 CreateFunctor(T** obj, R (U::*method)(A1, A2)) {
1175 MutantRunner<R, Tuple2<A1, A2> >* t =
1176 new MutantLateObjectBind<R, T, R (U::*)(A1, A2),
1177 Tuple0, Tuple2<A1, A2> >
1178 (obj, method, MakeTuple());
1179 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1180 }
1181 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1182
1183 #if defined (OS_WIN)
1184 template <typename R, typename T, typename U, typename A1, typename A2>
1185 inline MutantFunctor<R, Tuple2<A1, A2> >
1186 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) {
1187 MutantRunner<R, Tuple2<A1, A2> >* t =
1188 new Mutant<R, T, R (__stdcall U::*)(A1, A2),
1189 Tuple0, Tuple2<A1, A2> >
1190 (obj, method, MakeTuple());
1191 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1192 }
1193
1194 template <typename R, typename A1, typename A2>
1195 inline MutantFunctor<R, Tuple2<A1, A2> >
1196 CreateFunctor(R (__stdcall *function)(A1, A2)) {
1197 MutantRunner<R, Tuple2<A1, A2> >* t =
1198 new MutantFunction<R, R (__stdcall *)(A1, A2),
1199 Tuple0, Tuple2<A1, A2> >
1200 (function, MakeTuple());
1201 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1202 }
1203 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1204 template <typename R, typename T, typename U, typename A1, typename A2>
1205 inline MutantFunctor<R, Tuple2<A1, A2> >
1206 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
1207 MutantRunner<R, Tuple2<A1, A2> >* t =
1208 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2),
1209 Tuple0, Tuple2<A1, A2> >
1210 (obj, method, MakeTuple());
1211 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1212 }
1213 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1214 #endif // OS_WIN
1215
1216 // 0 - 3
1217 template <typename R, typename T, typename U, typename A1, typename A2,
1218 typename A3>
1219 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1220 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) {
1221 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1222 new Mutant<R, T, R (U::*)(A1, A2, A3),
1223 Tuple0, Tuple3<A1, A2, A3> >
1224 (obj, method, MakeTuple());
1225 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1226 }
1227
1228 template <typename R, typename A1, typename A2, typename A3>
1229 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1230 CreateFunctor(R (*function)(A1, A2, A3)) {
1231 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1232 new MutantFunction<R, R (*)(A1, A2, A3),
1233 Tuple0, Tuple3<A1, A2, A3> >
1234 (function, MakeTuple());
1235 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1236 }
1237
1238 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1239 template <typename R, typename T, typename U, typename A1, typename A2,
1240 typename A3>
1241 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1242 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) {
1243 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1244 new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3),
1245 Tuple0, Tuple3<A1, A2, A3> >
1246 (obj, method, MakeTuple());
1247 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1248 }
1249 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1250
1251 #if defined (OS_WIN)
1252 template <typename R, typename T, typename U, typename A1, typename A2,
1253 typename A3>
1254 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1255 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) {
1256 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1257 new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3),
1258 Tuple0, Tuple3<A1, A2, A3> >
1259 (obj, method, MakeTuple());
1260 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1261 }
1262
1263 template <typename R, typename A1, typename A2, typename A3>
1264 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1265 CreateFunctor(R (__stdcall *function)(A1, A2, A3)) {
1266 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1267 new MutantFunction<R, R (__stdcall *)(A1, A2, A3),
1268 Tuple0, Tuple3<A1, A2, A3> >
1269 (function, MakeTuple());
1270 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1271 }
1272 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1273 template <typename R, typename T, typename U, typename A1, typename A2,
1274 typename A3>
1275 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1276 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
1277 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1278 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3),
1279 Tuple0, Tuple3<A1, A2, A3> >
1280 (obj, method, MakeTuple());
1281 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1282 }
1283 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1284 #endif // OS_WIN
1285
1286 // 0 - 4
1287 template <typename R, typename T, typename U, typename A1, typename A2,
1288 typename A3, typename A4>
1289 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1290 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) {
1291 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1292 new Mutant<R, T, R (U::*)(A1, A2, A3, A4),
1293 Tuple0, Tuple4<A1, A2, A3, A4> >
1294 (obj, method, MakeTuple());
1295 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1296 }
1297
1298 template <typename R, typename A1, typename A2, typename A3, typename A4>
1299 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1300 CreateFunctor(R (*function)(A1, A2, A3, A4)) {
1301 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1302 new MutantFunction<R, R (*)(A1, A2, A3, A4),
1303 Tuple0, Tuple4<A1, A2, A3, A4> >
1304 (function, MakeTuple());
1305 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1306 }
1307
1308 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1309 template <typename R, typename T, typename U, typename A1, typename A2,
1310 typename A3, typename A4>
1311 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1312 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4)) {
1313 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1314 new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4),
1315 Tuple0, Tuple4<A1, A2, A3, A4> >
1316 (obj, method, MakeTuple());
1317 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1318 }
1319 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1320
1321 #if defined (OS_WIN)
1322 template <typename R, typename T, typename U, typename A1, typename A2,
1323 typename A3, typename A4>
1324 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1325 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
1326 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1327 new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
1328 Tuple0, Tuple4<A1, A2, A3, A4> >
1329 (obj, method, MakeTuple());
1330 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1331 }
1332
1333 template <typename R, typename A1, typename A2, typename A3, typename A4>
1334 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1335 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) {
1336 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1337 new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4),
1338 Tuple0, Tuple4<A1, A2, A3, A4> >
1339 (function, MakeTuple());
1340 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1341 }
1342 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1343 template <typename R, typename T, typename U, typename A1, typename A2,
1344 typename A3, typename A4>
1345 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1346 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
1347 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1348 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
1349 Tuple0, Tuple4<A1, A2, A3, A4> >
1350 (obj, method, MakeTuple());
1351 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1352 }
1353 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1354 #endif // OS_WIN
1355
1356 // 0 - 5
1357 template <typename R, typename T, typename U, typename A1, typename A2,
1358 typename A3, typename A4, typename A5>
1359 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1360 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) {
1361 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1362 new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5),
1363 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1364 (obj, method, MakeTuple());
1365 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1366 }
1367
1368 template <typename R, typename A1, typename A2, typename A3, typename A4,
1369 typename A5>
1370 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1371 CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) {
1372 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1373 new MutantFunction<R, R (*)(A1, A2, A3, A4, A5),
1374 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1375 (function, MakeTuple());
1376 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1377 }
1378
1379 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1380 template <typename R, typename T, typename U, typename A1, typename A2,
1381 typename A3, typename A4, typename A5>
1382 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1383 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) {
1384 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1385 new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5),
1386 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1387 (obj, method, MakeTuple());
1388 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1389 }
1390 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1391
1392 #if defined (OS_WIN)
1393 template <typename R, typename T, typename U, typename A1, typename A2,
1394 typename A3, typename A4, typename A5>
1395 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1396 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
1397 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1398 new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
1399 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1400 (obj, method, MakeTuple());
1401 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1402 }
1403
1404 template <typename R, typename A1, typename A2, typename A3, typename A4,
1405 typename A5>
1406 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1407 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) {
1408 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1409 new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5),
1410 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1411 (function, MakeTuple());
1412 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1413 }
1414 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1415 template <typename R, typename T, typename U, typename A1, typename A2,
1416 typename A3, typename A4, typename A5>
1417 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1418 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
1419 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1420 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
1421 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
1422 (obj, method, MakeTuple());
1423 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1424 }
1425 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1426 #endif // OS_WIN
1427
1428 // 0 - 6
1429 template <typename R, typename T, typename U, typename A1, typename A2,
1430 typename A3, typename A4, typename A5, typename A6>
1431 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1432 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
1433 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1434 new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
1435 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1436 (obj, method, MakeTuple());
1437 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1438 }
1439
1440 template <typename R, typename A1, typename A2, typename A3, typename A4,
1441 typename A5, typename A6>
1442 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1443 CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) {
1444 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1445 new MutantFunction<R, R (*)(A1, A2, A3, A4, A5, A6),
1446 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1447 (function, MakeTuple());
1448 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1449 }
1450
1451 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1452 template <typename R, typename T, typename U, typename A1, typename A2,
1453 typename A3, typename A4, typename A5, typename A6>
1454 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1455 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
1456 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1457 new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
1458 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1459 (obj, method, MakeTuple());
1460 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1461 }
1462 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1463
1464 #if defined (OS_WIN)
1465 template <typename R, typename T, typename U, typename A1, typename A2,
1466 typename A3, typename A4, typename A5, typename A6>
1467 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1468 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
1469 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1470 new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
1471 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1472 (obj, method, MakeTuple());
1473 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1474 }
1475
1476 template <typename R, typename A1, typename A2, typename A3, typename A4,
1477 typename A5, typename A6>
1478 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1479 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) {
1480 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1481 new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5, A6),
1482 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1483 (function, MakeTuple());
1484 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1485 }
1486 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1487 template <typename R, typename T, typename U, typename A1, typename A2,
1488 typename A3, typename A4, typename A5, typename A6>
1489 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1490 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
1491 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1492 new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
1493 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
1494 (obj, method, MakeTuple());
1495 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1496 }
1497 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1498 #endif // OS_WIN
1499
1500 // 1 - 0
1501 template <typename R, typename T, typename U, typename P1, typename X1>
1502 inline MutantFunctor<R, Tuple0>
1503 CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) {
1504 MutantRunner<R, Tuple0>* t =
1505 new Mutant<R, T, R (U::*)(X1),
1506 Tuple1<P1>, Tuple0>
1507 (obj, method, MakeTuple(p1));
1508 return MutantFunctor<R, Tuple0>(t);
1509 }
1510
1511 template <typename R, typename P1, typename X1>
1512 inline MutantFunctor<R, Tuple0>
1513 CreateFunctor(R (*function)(X1), const P1& p1) {
1514 MutantRunner<R, Tuple0>* t =
1515 new MutantFunction<R, R (*)(X1),
1516 Tuple1<P1>, Tuple0>
1517 (function, MakeTuple(p1));
1518 return MutantFunctor<R, Tuple0>(t);
1519 }
1520
1521 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1522 template <typename R, typename T, typename U, typename P1, typename X1>
1523 inline MutantFunctor<R, Tuple0>
1524 CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) {
1525 MutantRunner<R, Tuple0>* t =
1526 new MutantLateObjectBind<R, T, R (U::*)(X1),
1527 Tuple1<P1>, Tuple0>
1528 (obj, method, MakeTuple(p1));
1529 return MutantFunctor<R, Tuple0>(t);
1530 }
1531 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1532
1533 #if defined (OS_WIN)
1534 template <typename R, typename T, typename U, typename P1, typename X1>
1535 inline MutantFunctor<R, Tuple0>
1536 CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) {
1537 MutantRunner<R, Tuple0>* t =
1538 new Mutant<R, T, R (__stdcall U::*)(X1),
1539 Tuple1<P1>, Tuple0>
1540 (obj, method, MakeTuple(p1));
1541 return MutantFunctor<R, Tuple0>(t);
1542 }
1543
1544 template <typename R, typename P1, typename X1>
1545 inline MutantFunctor<R, Tuple0>
1546 CreateFunctor(R (__stdcall *function)(X1), const P1& p1) {
1547 MutantRunner<R, Tuple0>* t =
1548 new MutantFunction<R, R (__stdcall *)(X1),
1549 Tuple1<P1>, Tuple0>
1550 (function, MakeTuple(p1));
1551 return MutantFunctor<R, Tuple0>(t);
1552 }
1553 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1554 template <typename R, typename T, typename U, typename P1, typename X1>
1555 inline MutantFunctor<R, Tuple0>
1556 CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
1557 MutantRunner<R, Tuple0>* t =
1558 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1),
1559 Tuple1<P1>, Tuple0>
1560 (obj, method, MakeTuple(p1));
1561 return MutantFunctor<R, Tuple0>(t);
1562 }
1563 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1564 #endif // OS_WIN
1565
1566 // 1 - 1
1567 template <typename R, typename T, typename U, typename P1, typename A1,
1568 typename X1>
1569 inline MutantFunctor<R, Tuple1<A1> >
1570 CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) {
1571 MutantRunner<R, Tuple1<A1> >* t =
1572 new Mutant<R, T, R (U::*)(X1, A1),
1573 Tuple1<P1>, Tuple1<A1> >
1574 (obj, method, MakeTuple(p1));
1575 return MutantFunctor<R, Tuple1<A1> >(t);
1576 }
1577
1578 template <typename R, typename P1, typename A1, typename X1>
1579 inline MutantFunctor<R, Tuple1<A1> >
1580 CreateFunctor(R (*function)(X1, A1), const P1& p1) {
1581 MutantRunner<R, Tuple1<A1> >* t =
1582 new MutantFunction<R, R (*)(X1, A1),
1583 Tuple1<P1>, Tuple1<A1> >
1584 (function, MakeTuple(p1));
1585 return MutantFunctor<R, Tuple1<A1> >(t);
1586 }
1587
1588 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1589 template <typename R, typename T, typename U, typename P1, typename A1,
1590 typename X1>
1591 inline MutantFunctor<R, Tuple1<A1> >
1592 CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) {
1593 MutantRunner<R, Tuple1<A1> >* t =
1594 new MutantLateObjectBind<R, T, R (U::*)(X1, A1),
1595 Tuple1<P1>, Tuple1<A1> >
1596 (obj, method, MakeTuple(p1));
1597 return MutantFunctor<R, Tuple1<A1> >(t);
1598 }
1599 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1600
1601 #if defined (OS_WIN)
1602 template <typename R, typename T, typename U, typename P1, typename A1,
1603 typename X1>
1604 inline MutantFunctor<R, Tuple1<A1> >
1605 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
1606 MutantRunner<R, Tuple1<A1> >* t =
1607 new Mutant<R, T, R (__stdcall U::*)(X1, A1),
1608 Tuple1<P1>, Tuple1<A1> >
1609 (obj, method, MakeTuple(p1));
1610 return MutantFunctor<R, Tuple1<A1> >(t);
1611 }
1612
1613 template <typename R, typename P1, typename A1, typename X1>
1614 inline MutantFunctor<R, Tuple1<A1> >
1615 CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) {
1616 MutantRunner<R, Tuple1<A1> >* t =
1617 new MutantFunction<R, R (__stdcall *)(X1, A1),
1618 Tuple1<P1>, Tuple1<A1> >
1619 (function, MakeTuple(p1));
1620 return MutantFunctor<R, Tuple1<A1> >(t);
1621 }
1622 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1623 template <typename R, typename T, typename U, typename P1, typename A1,
1624 typename X1>
1625 inline MutantFunctor<R, Tuple1<A1> >
1626 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
1627 MutantRunner<R, Tuple1<A1> >* t =
1628 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1),
1629 Tuple1<P1>, Tuple1<A1> >
1630 (obj, method, MakeTuple(p1));
1631 return MutantFunctor<R, Tuple1<A1> >(t);
1632 }
1633 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1634 #endif // OS_WIN
1635
1636 // 1 - 2
1637 template <typename R, typename T, typename U, typename P1, typename A1,
1638 typename A2, typename X1>
1639 inline MutantFunctor<R, Tuple2<A1, A2> >
1640 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) {
1641 MutantRunner<R, Tuple2<A1, A2> >* t =
1642 new Mutant<R, T, R (U::*)(X1, A1, A2),
1643 Tuple1<P1>, Tuple2<A1, A2> >
1644 (obj, method, MakeTuple(p1));
1645 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1646 }
1647
1648 template <typename R, typename P1, typename A1, typename A2, typename X1>
1649 inline MutantFunctor<R, Tuple2<A1, A2> >
1650 CreateFunctor(R (*function)(X1, A1, A2), const P1& p1) {
1651 MutantRunner<R, Tuple2<A1, A2> >* t =
1652 new MutantFunction<R, R (*)(X1, A1, A2),
1653 Tuple1<P1>, Tuple2<A1, A2> >
1654 (function, MakeTuple(p1));
1655 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1656 }
1657
1658 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1659 template <typename R, typename T, typename U, typename P1, typename A1,
1660 typename A2, typename X1>
1661 inline MutantFunctor<R, Tuple2<A1, A2> >
1662 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2), const P1& p1) {
1663 MutantRunner<R, Tuple2<A1, A2> >* t =
1664 new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2),
1665 Tuple1<P1>, Tuple2<A1, A2> >
1666 (obj, method, MakeTuple(p1));
1667 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1668 }
1669 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1670
1671 #if defined (OS_WIN)
1672 template <typename R, typename T, typename U, typename P1, typename A1,
1673 typename A2, typename X1>
1674 inline MutantFunctor<R, Tuple2<A1, A2> >
1675 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
1676 MutantRunner<R, Tuple2<A1, A2> >* t =
1677 new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2),
1678 Tuple1<P1>, Tuple2<A1, A2> >
1679 (obj, method, MakeTuple(p1));
1680 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1681 }
1682
1683 template <typename R, typename P1, typename A1, typename A2, typename X1>
1684 inline MutantFunctor<R, Tuple2<A1, A2> >
1685 CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) {
1686 MutantRunner<R, Tuple2<A1, A2> >* t =
1687 new MutantFunction<R, R (__stdcall *)(X1, A1, A2),
1688 Tuple1<P1>, Tuple2<A1, A2> >
1689 (function, MakeTuple(p1));
1690 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1691 }
1692 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1693 template <typename R, typename T, typename U, typename P1, typename A1,
1694 typename A2, typename X1>
1695 inline MutantFunctor<R, Tuple2<A1, A2> >
1696 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
1697 MutantRunner<R, Tuple2<A1, A2> >* t =
1698 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2),
1699 Tuple1<P1>, Tuple2<A1, A2> >
1700 (obj, method, MakeTuple(p1));
1701 return MutantFunctor<R, Tuple2<A1, A2> >(t);
1702 }
1703 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1704 #endif // OS_WIN
1705
1706 // 1 - 3
1707 template <typename R, typename T, typename U, typename P1, typename A1,
1708 typename A2, typename A3, typename X1>
1709 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1710 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
1711 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1712 new Mutant<R, T, R (U::*)(X1, A1, A2, A3),
1713 Tuple1<P1>, Tuple3<A1, A2, A3> >
1714 (obj, method, MakeTuple(p1));
1715 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1716 }
1717
1718 template <typename R, typename P1, typename A1, typename A2, typename A3,
1719 typename X1>
1720 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1721 CreateFunctor(R (*function)(X1, A1, A2, A3), const P1& p1) {
1722 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1723 new MutantFunction<R, R (*)(X1, A1, A2, A3),
1724 Tuple1<P1>, Tuple3<A1, A2, A3> >
1725 (function, MakeTuple(p1));
1726 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1727 }
1728
1729 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1730 template <typename R, typename T, typename U, typename P1, typename A1,
1731 typename A2, typename A3, typename X1>
1732 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1733 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
1734 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1735 new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3),
1736 Tuple1<P1>, Tuple3<A1, A2, A3> >
1737 (obj, method, MakeTuple(p1));
1738 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1739 }
1740 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1741
1742 #if defined (OS_WIN)
1743 template <typename R, typename T, typename U, typename P1, typename A1,
1744 typename A2, typename A3, typename X1>
1745 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1746 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
1747 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1748 new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
1749 Tuple1<P1>, Tuple3<A1, A2, A3> >
1750 (obj, method, MakeTuple(p1));
1751 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1752 }
1753
1754 template <typename R, typename P1, typename A1, typename A2, typename A3,
1755 typename X1>
1756 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1757 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) {
1758 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1759 new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3),
1760 Tuple1<P1>, Tuple3<A1, A2, A3> >
1761 (function, MakeTuple(p1));
1762 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1763 }
1764 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1765 template <typename R, typename T, typename U, typename P1, typename A1,
1766 typename A2, typename A3, typename X1>
1767 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
1768 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
1769 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
1770 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
1771 Tuple1<P1>, Tuple3<A1, A2, A3> >
1772 (obj, method, MakeTuple(p1));
1773 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
1774 }
1775 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1776 #endif // OS_WIN
1777
1778 // 1 - 4
1779 template <typename R, typename T, typename U, typename P1, typename A1,
1780 typename A2, typename A3, typename A4, typename X1>
1781 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1782 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
1783 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1784 new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4),
1785 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1786 (obj, method, MakeTuple(p1));
1787 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1788 }
1789
1790 template <typename R, typename P1, typename A1, typename A2, typename A3,
1791 typename A4, typename X1>
1792 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1793 CreateFunctor(R (*function)(X1, A1, A2, A3, A4), const P1& p1) {
1794 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1795 new MutantFunction<R, R (*)(X1, A1, A2, A3, A4),
1796 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1797 (function, MakeTuple(p1));
1798 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1799 }
1800
1801 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1802 template <typename R, typename T, typename U, typename P1, typename A1,
1803 typename A2, typename A3, typename A4, typename X1>
1804 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1805 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
1806 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1807 new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4),
1808 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1809 (obj, method, MakeTuple(p1));
1810 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1811 }
1812 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1813
1814 #if defined (OS_WIN)
1815 template <typename R, typename T, typename U, typename P1, typename A1,
1816 typename A2, typename A3, typename A4, typename X1>
1817 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1818 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
1819 const P1& p1) {
1820 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1821 new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
1822 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1823 (obj, method, MakeTuple(p1));
1824 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1825 }
1826
1827 template <typename R, typename P1, typename A1, typename A2, typename A3,
1828 typename A4, typename X1>
1829 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1830 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) {
1831 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1832 new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4),
1833 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1834 (function, MakeTuple(p1));
1835 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1836 }
1837 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1838 template <typename R, typename T, typename U, typename P1, typename A1,
1839 typename A2, typename A3, typename A4, typename X1>
1840 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
1841 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
1842 const P1& p1) {
1843 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
1844 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
1845 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
1846 (obj, method, MakeTuple(p1));
1847 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
1848 }
1849 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1850 #endif // OS_WIN
1851
1852 // 1 - 5
1853 template <typename R, typename T, typename U, typename P1, typename A1,
1854 typename A2, typename A3, typename A4, typename A5, typename X1>
1855 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1856 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
1857 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1858 new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
1859 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1860 (obj, method, MakeTuple(p1));
1861 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1862 }
1863
1864 template <typename R, typename P1, typename A1, typename A2, typename A3,
1865 typename A4, typename A5, typename X1>
1866 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1867 CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
1868 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1869 new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5),
1870 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1871 (function, MakeTuple(p1));
1872 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1873 }
1874
1875 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1876 template <typename R, typename T, typename U, typename P1, typename A1,
1877 typename A2, typename A3, typename A4, typename A5, typename X1>
1878 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1879 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
1880 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1881 new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
1882 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1883 (obj, method, MakeTuple(p1));
1884 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1885 }
1886 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1887
1888 #if defined (OS_WIN)
1889 template <typename R, typename T, typename U, typename P1, typename A1,
1890 typename A2, typename A3, typename A4, typename A5, typename X1>
1891 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1892 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
1893 const P1& p1) {
1894 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1895 new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
1896 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1897 (obj, method, MakeTuple(p1));
1898 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1899 }
1900
1901 template <typename R, typename P1, typename A1, typename A2, typename A3,
1902 typename A4, typename A5, typename X1>
1903 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1904 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
1905 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1906 new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5),
1907 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1908 (function, MakeTuple(p1));
1909 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1910 }
1911 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1912 template <typename R, typename T, typename U, typename P1, typename A1,
1913 typename A2, typename A3, typename A4, typename A5, typename X1>
1914 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
1915 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
1916 const P1& p1) {
1917 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
1918 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
1919 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
1920 (obj, method, MakeTuple(p1));
1921 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
1922 }
1923 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1924 #endif // OS_WIN
1925
1926 // 1 - 6
1927 template <typename R, typename T, typename U, typename P1, typename A1,
1928 typename A2, typename A3, typename A4, typename A5, typename A6,
1929 typename X1>
1930 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1931 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
1932 const P1& p1) {
1933 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1934 new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
1935 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
1936 (obj, method, MakeTuple(p1));
1937 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1938 }
1939
1940 template <typename R, typename P1, typename A1, typename A2, typename A3,
1941 typename A4, typename A5, typename A6, typename X1>
1942 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1943 CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) {
1944 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1945 new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5, A6),
1946 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
1947 (function, MakeTuple(p1));
1948 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1949 }
1950
1951 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1952 template <typename R, typename T, typename U, typename P1, typename A1,
1953 typename A2, typename A3, typename A4, typename A5, typename A6,
1954 typename X1>
1955 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1956 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
1957 const P1& p1) {
1958 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1959 new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
1960 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
1961 (obj, method, MakeTuple(p1));
1962 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1963 }
1964 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1965
1966 #if defined (OS_WIN)
1967 template <typename R, typename T, typename U, typename P1, typename A1,
1968 typename A2, typename A3, typename A4, typename A5, typename A6,
1969 typename X1>
1970 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1971 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
1972 const P1& p1) {
1973 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1974 new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
1975 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
1976 (obj, method, MakeTuple(p1));
1977 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1978 }
1979
1980 template <typename R, typename P1, typename A1, typename A2, typename A3,
1981 typename A4, typename A5, typename A6, typename X1>
1982 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1983 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6),
1984 const P1& p1) {
1985 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1986 new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5, A6),
1987 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
1988 (function, MakeTuple(p1));
1989 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
1990 }
1991 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
1992 template <typename R, typename T, typename U, typename P1, typename A1,
1993 typename A2, typename A3, typename A4, typename A5, typename A6,
1994 typename X1>
1995 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
1996 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
1997 const P1& p1) {
1998 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
1999 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
2000 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
2001 (obj, method, MakeTuple(p1));
2002 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2003 }
2004 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2005 #endif // OS_WIN
2006
2007 // 2 - 0
2008 template <typename R, typename T, typename U, typename P1, typename P2,
2009 typename X1, typename X2>
2010 inline MutantFunctor<R, Tuple0>
2011 CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
2012 MutantRunner<R, Tuple0>* t =
2013 new Mutant<R, T, R (U::*)(X1, X2),
2014 Tuple2<P1, P2>, Tuple0>
2015 (obj, method, MakeTuple(p1, p2));
2016 return MutantFunctor<R, Tuple0>(t);
2017 }
2018
2019 template <typename R, typename P1, typename P2, typename X1, typename X2>
2020 inline MutantFunctor<R, Tuple0>
2021 CreateFunctor(R (*function)(X1, X2), const P1& p1, const P2& p2) {
2022 MutantRunner<R, Tuple0>* t =
2023 new MutantFunction<R, R (*)(X1, X2),
2024 Tuple2<P1, P2>, Tuple0>
2025 (function, MakeTuple(p1, p2));
2026 return MutantFunctor<R, Tuple0>(t);
2027 }
2028
2029 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2030 template <typename R, typename T, typename U, typename P1, typename P2,
2031 typename X1, typename X2>
2032 inline MutantFunctor<R, Tuple0>
2033 CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
2034 MutantRunner<R, Tuple0>* t =
2035 new MutantLateObjectBind<R, T, R (U::*)(X1, X2),
2036 Tuple2<P1, P2>, Tuple0>
2037 (obj, method, MakeTuple(p1, p2));
2038 return MutantFunctor<R, Tuple0>(t);
2039 }
2040 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2041
2042 #if defined (OS_WIN)
2043 template <typename R, typename T, typename U, typename P1, typename P2,
2044 typename X1, typename X2>
2045 inline MutantFunctor<R, Tuple0>
2046 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
2047 const P2& p2) {
2048 MutantRunner<R, Tuple0>* t =
2049 new Mutant<R, T, R (__stdcall U::*)(X1, X2),
2050 Tuple2<P1, P2>, Tuple0>
2051 (obj, method, MakeTuple(p1, p2));
2052 return MutantFunctor<R, Tuple0>(t);
2053 }
2054
2055 template <typename R, typename P1, typename P2, typename X1, typename X2>
2056 inline MutantFunctor<R, Tuple0>
2057 CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) {
2058 MutantRunner<R, Tuple0>* t =
2059 new MutantFunction<R, R (__stdcall *)(X1, X2),
2060 Tuple2<P1, P2>, Tuple0>
2061 (function, MakeTuple(p1, p2));
2062 return MutantFunctor<R, Tuple0>(t);
2063 }
2064 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2065 template <typename R, typename T, typename U, typename P1, typename P2,
2066 typename X1, typename X2>
2067 inline MutantFunctor<R, Tuple0>
2068 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
2069 const P2& p2) {
2070 MutantRunner<R, Tuple0>* t =
2071 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2),
2072 Tuple2<P1, P2>, Tuple0>
2073 (obj, method, MakeTuple(p1, p2));
2074 return MutantFunctor<R, Tuple0>(t);
2075 }
2076 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2077 #endif // OS_WIN
2078
2079 // 2 - 1
2080 template <typename R, typename T, typename U, typename P1, typename P2,
2081 typename A1, typename X1, typename X2>
2082 inline MutantFunctor<R, Tuple1<A1> >
2083 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
2084 MutantRunner<R, Tuple1<A1> >* t =
2085 new Mutant<R, T, R (U::*)(X1, X2, A1),
2086 Tuple2<P1, P2>, Tuple1<A1> >
2087 (obj, method, MakeTuple(p1, p2));
2088 return MutantFunctor<R, Tuple1<A1> >(t);
2089 }
2090
2091 template <typename R, typename P1, typename P2, typename A1, typename X1,
2092 typename X2>
2093 inline MutantFunctor<R, Tuple1<A1> >
2094 CreateFunctor(R (*function)(X1, X2, A1), const P1& p1, const P2& p2) {
2095 MutantRunner<R, Tuple1<A1> >* t =
2096 new MutantFunction<R, R (*)(X1, X2, A1),
2097 Tuple2<P1, P2>, Tuple1<A1> >
2098 (function, MakeTuple(p1, p2));
2099 return MutantFunctor<R, Tuple1<A1> >(t);
2100 }
2101
2102 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2103 template <typename R, typename T, typename U, typename P1, typename P2,
2104 typename A1, typename X1, typename X2>
2105 inline MutantFunctor<R, Tuple1<A1> >
2106 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
2107 MutantRunner<R, Tuple1<A1> >* t =
2108 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1),
2109 Tuple2<P1, P2>, Tuple1<A1> >
2110 (obj, method, MakeTuple(p1, p2));
2111 return MutantFunctor<R, Tuple1<A1> >(t);
2112 }
2113 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2114
2115 #if defined (OS_WIN)
2116 template <typename R, typename T, typename U, typename P1, typename P2,
2117 typename A1, typename X1, typename X2>
2118 inline MutantFunctor<R, Tuple1<A1> >
2119 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
2120 const P2& p2) {
2121 MutantRunner<R, Tuple1<A1> >* t =
2122 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1),
2123 Tuple2<P1, P2>, Tuple1<A1> >
2124 (obj, method, MakeTuple(p1, p2));
2125 return MutantFunctor<R, Tuple1<A1> >(t);
2126 }
2127
2128 template <typename R, typename P1, typename P2, typename A1, typename X1,
2129 typename X2>
2130 inline MutantFunctor<R, Tuple1<A1> >
2131 CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1,
2132 const P2& p2) {
2133 MutantRunner<R, Tuple1<A1> >* t =
2134 new MutantFunction<R, R (__stdcall *)(X1, X2, A1),
2135 Tuple2<P1, P2>, Tuple1<A1> >
2136 (function, MakeTuple(p1, p2));
2137 return MutantFunctor<R, Tuple1<A1> >(t);
2138 }
2139 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2140 template <typename R, typename T, typename U, typename P1, typename P2,
2141 typename A1, typename X1, typename X2>
2142 inline MutantFunctor<R, Tuple1<A1> >
2143 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
2144 const P2& p2) {
2145 MutantRunner<R, Tuple1<A1> >* t =
2146 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1),
2147 Tuple2<P1, P2>, Tuple1<A1> >
2148 (obj, method, MakeTuple(p1, p2));
2149 return MutantFunctor<R, Tuple1<A1> >(t);
2150 }
2151 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2152 #endif // OS_WIN
2153
2154 // 2 - 2
2155 template <typename R, typename T, typename U, typename P1, typename P2,
2156 typename A1, typename A2, typename X1, typename X2>
2157 inline MutantFunctor<R, Tuple2<A1, A2> >
2158 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
2159 const P2& p2) {
2160 MutantRunner<R, Tuple2<A1, A2> >* t =
2161 new Mutant<R, T, R (U::*)(X1, X2, A1, A2),
2162 Tuple2<P1, P2>, Tuple2<A1, A2> >
2163 (obj, method, MakeTuple(p1, p2));
2164 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2165 }
2166
2167 template <typename R, typename P1, typename P2, typename A1, typename A2,
2168 typename X1, typename X2>
2169 inline MutantFunctor<R, Tuple2<A1, A2> >
2170 CreateFunctor(R (*function)(X1, X2, A1, A2), const P1& p1, const P2& p2) {
2171 MutantRunner<R, Tuple2<A1, A2> >* t =
2172 new MutantFunction<R, R (*)(X1, X2, A1, A2),
2173 Tuple2<P1, P2>, Tuple2<A1, A2> >
2174 (function, MakeTuple(p1, p2));
2175 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2176 }
2177
2178 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2179 template <typename R, typename T, typename U, typename P1, typename P2,
2180 typename A1, typename A2, typename X1, typename X2>
2181 inline MutantFunctor<R, Tuple2<A1, A2> >
2182 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
2183 const P2& p2) {
2184 MutantRunner<R, Tuple2<A1, A2> >* t =
2185 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2),
2186 Tuple2<P1, P2>, Tuple2<A1, A2> >
2187 (obj, method, MakeTuple(p1, p2));
2188 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2189 }
2190 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2191
2192 #if defined (OS_WIN)
2193 template <typename R, typename T, typename U, typename P1, typename P2,
2194 typename A1, typename A2, typename X1, typename X2>
2195 inline MutantFunctor<R, Tuple2<A1, A2> >
2196 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
2197 const P2& p2) {
2198 MutantRunner<R, Tuple2<A1, A2> >* t =
2199 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
2200 Tuple2<P1, P2>, Tuple2<A1, A2> >
2201 (obj, method, MakeTuple(p1, p2));
2202 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2203 }
2204
2205 template <typename R, typename P1, typename P2, typename A1, typename A2,
2206 typename X1, typename X2>
2207 inline MutantFunctor<R, Tuple2<A1, A2> >
2208 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1,
2209 const P2& p2) {
2210 MutantRunner<R, Tuple2<A1, A2> >* t =
2211 new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2),
2212 Tuple2<P1, P2>, Tuple2<A1, A2> >
2213 (function, MakeTuple(p1, p2));
2214 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2215 }
2216 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2217 template <typename R, typename T, typename U, typename P1, typename P2,
2218 typename A1, typename A2, typename X1, typename X2>
2219 inline MutantFunctor<R, Tuple2<A1, A2> >
2220 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
2221 const P2& p2) {
2222 MutantRunner<R, Tuple2<A1, A2> >* t =
2223 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
2224 Tuple2<P1, P2>, Tuple2<A1, A2> >
2225 (obj, method, MakeTuple(p1, p2));
2226 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2227 }
2228 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2229 #endif // OS_WIN
2230
2231 // 2 - 3
2232 template <typename R, typename T, typename U, typename P1, typename P2,
2233 typename A1, typename A2, typename A3, typename X1, typename X2>
2234 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2235 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
2236 const P2& p2) {
2237 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2238 new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3),
2239 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2240 (obj, method, MakeTuple(p1, p2));
2241 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2242 }
2243
2244 template <typename R, typename P1, typename P2, typename A1, typename A2,
2245 typename A3, typename X1, typename X2>
2246 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2247 CreateFunctor(R (*function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) {
2248 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2249 new MutantFunction<R, R (*)(X1, X2, A1, A2, A3),
2250 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2251 (function, MakeTuple(p1, p2));
2252 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2253 }
2254
2255 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2256 template <typename R, typename T, typename U, typename P1, typename P2,
2257 typename A1, typename A2, typename A3, typename X1, typename X2>
2258 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2259 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
2260 const P2& p2) {
2261 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2262 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3),
2263 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2264 (obj, method, MakeTuple(p1, p2));
2265 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2266 }
2267 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2268
2269 #if defined (OS_WIN)
2270 template <typename R, typename T, typename U, typename P1, typename P2,
2271 typename A1, typename A2, typename A3, typename X1, typename X2>
2272 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2273 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
2274 const P1& p1, const P2& p2) {
2275 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2276 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
2277 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2278 (obj, method, MakeTuple(p1, p2));
2279 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2280 }
2281
2282 template <typename R, typename P1, typename P2, typename A1, typename A2,
2283 typename A3, typename X1, typename X2>
2284 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2285 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1,
2286 const P2& p2) {
2287 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2288 new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3),
2289 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2290 (function, MakeTuple(p1, p2));
2291 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2292 }
2293 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2294 template <typename R, typename T, typename U, typename P1, typename P2,
2295 typename A1, typename A2, typename A3, typename X1, typename X2>
2296 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2297 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
2298 const P1& p1, const P2& p2) {
2299 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2300 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
2301 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
2302 (obj, method, MakeTuple(p1, p2));
2303 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2304 }
2305 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2306 #endif // OS_WIN
2307
2308 // 2 - 4
2309 template <typename R, typename T, typename U, typename P1, typename P2,
2310 typename A1, typename A2, typename A3, typename A4, typename X1,
2311 typename X2>
2312 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2313 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
2314 const P2& p2) {
2315 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2316 new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
2317 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2318 (obj, method, MakeTuple(p1, p2));
2319 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2320 }
2321
2322 template <typename R, typename P1, typename P2, typename A1, typename A2,
2323 typename A3, typename A4, typename X1, typename X2>
2324 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2325 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4), const P1& p1,
2326 const P2& p2) {
2327 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2328 new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4),
2329 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2330 (function, MakeTuple(p1, p2));
2331 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2332 }
2333
2334 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2335 template <typename R, typename T, typename U, typename P1, typename P2,
2336 typename A1, typename A2, typename A3, typename A4, typename X1,
2337 typename X2>
2338 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2339 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
2340 const P2& p2) {
2341 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2342 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
2343 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2344 (obj, method, MakeTuple(p1, p2));
2345 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2346 }
2347 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2348
2349 #if defined (OS_WIN)
2350 template <typename R, typename T, typename U, typename P1, typename P2,
2351 typename A1, typename A2, typename A3, typename A4, typename X1,
2352 typename X2>
2353 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2354 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
2355 const P1& p1, const P2& p2) {
2356 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2357 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
2358 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2359 (obj, method, MakeTuple(p1, p2));
2360 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2361 }
2362
2363 template <typename R, typename P1, typename P2, typename A1, typename A2,
2364 typename A3, typename A4, typename X1, typename X2>
2365 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2366 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1,
2367 const P2& p2) {
2368 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2369 new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4),
2370 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2371 (function, MakeTuple(p1, p2));
2372 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2373 }
2374 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2375 template <typename R, typename T, typename U, typename P1, typename P2,
2376 typename A1, typename A2, typename A3, typename A4, typename X1,
2377 typename X2>
2378 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2379 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
2380 const P1& p1, const P2& p2) {
2381 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2382 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
2383 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
2384 (obj, method, MakeTuple(p1, p2));
2385 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2386 }
2387 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2388 #endif // OS_WIN
2389
2390 // 2 - 5
2391 template <typename R, typename T, typename U, typename P1, typename P2,
2392 typename A1, typename A2, typename A3, typename A4, typename A5,
2393 typename X1, typename X2>
2394 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2395 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
2396 const P2& p2) {
2397 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2398 new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
2399 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2400 (obj, method, MakeTuple(p1, p2));
2401 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2402 }
2403
2404 template <typename R, typename P1, typename P2, typename A1, typename A2,
2405 typename A3, typename A4, typename A5, typename X1, typename X2>
2406 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2407 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
2408 const P2& p2) {
2409 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2410 new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5),
2411 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2412 (function, MakeTuple(p1, p2));
2413 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2414 }
2415
2416 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2417 template <typename R, typename T, typename U, typename P1, typename P2,
2418 typename A1, typename A2, typename A3, typename A4, typename A5,
2419 typename X1, typename X2>
2420 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2421 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
2422 const P2& p2) {
2423 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2424 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
2425 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2426 (obj, method, MakeTuple(p1, p2));
2427 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2428 }
2429 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2430
2431 #if defined (OS_WIN)
2432 template <typename R, typename T, typename U, typename P1, typename P2,
2433 typename A1, typename A2, typename A3, typename A4, typename A5,
2434 typename X1, typename X2>
2435 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2436 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
2437 const P1& p1, const P2& p2) {
2438 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2439 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
2440 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2441 (obj, method, MakeTuple(p1, p2));
2442 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2443 }
2444
2445 template <typename R, typename P1, typename P2, typename A1, typename A2,
2446 typename A3, typename A4, typename A5, typename X1, typename X2>
2447 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2448 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
2449 const P2& p2) {
2450 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2451 new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5),
2452 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2453 (function, MakeTuple(p1, p2));
2454 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2455 }
2456 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2457 template <typename R, typename T, typename U, typename P1, typename P2,
2458 typename A1, typename A2, typename A3, typename A4, typename A5,
2459 typename X1, typename X2>
2460 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2461 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
2462 const P1& p1, const P2& p2) {
2463 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2464 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
2465 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
2466 (obj, method, MakeTuple(p1, p2));
2467 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2468 }
2469 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2470 #endif // OS_WIN
2471
2472 // 2 - 6
2473 template <typename R, typename T, typename U, typename P1, typename P2,
2474 typename A1, typename A2, typename A3, typename A4, typename A5,
2475 typename A6, typename X1, typename X2>
2476 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2477 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
2478 const P1& p1, const P2& p2) {
2479 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2480 new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
2481 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2482 (obj, method, MakeTuple(p1, p2));
2483 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2484 }
2485
2486 template <typename R, typename P1, typename P2, typename A1, typename A2,
2487 typename A3, typename A4, typename A5, typename A6, typename X1,
2488 typename X2>
2489 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2490 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1,
2491 const P2& p2) {
2492 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2493 new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5, A6),
2494 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2495 (function, MakeTuple(p1, p2));
2496 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2497 }
2498
2499 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2500 template <typename R, typename T, typename U, typename P1, typename P2,
2501 typename A1, typename A2, typename A3, typename A4, typename A5,
2502 typename A6, typename X1, typename X2>
2503 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2504 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
2505 const P1& p1, const P2& p2) {
2506 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2507 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
2508 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2509 (obj, method, MakeTuple(p1, p2));
2510 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2511 }
2512 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2513
2514 #if defined (OS_WIN)
2515 template <typename R, typename T, typename U, typename P1, typename P2,
2516 typename A1, typename A2, typename A3, typename A4, typename A5,
2517 typename A6, typename X1, typename X2>
2518 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2519 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
2520 const P1& p1, const P2& p2) {
2521 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2522 new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
2523 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2524 (obj, method, MakeTuple(p1, p2));
2525 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2526 }
2527
2528 template <typename R, typename P1, typename P2, typename A1, typename A2,
2529 typename A3, typename A4, typename A5, typename A6, typename X1,
2530 typename X2>
2531 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2532 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5, A6),
2533 const P1& p1, const P2& p2) {
2534 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2535 new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5, A6),
2536 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2537 (function, MakeTuple(p1, p2));
2538 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2539 }
2540 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2541 template <typename R, typename T, typename U, typename P1, typename P2,
2542 typename A1, typename A2, typename A3, typename A4, typename A5,
2543 typename A6, typename X1, typename X2>
2544 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
2545 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
2546 const P1& p1, const P2& p2) {
2547 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
2548 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
2549 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
2550 (obj, method, MakeTuple(p1, p2));
2551 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
2552 }
2553 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2554 #endif // OS_WIN
2555
2556 // 3 - 0
2557 template <typename R, typename T, typename U, typename P1, typename P2,
2558 typename P3, typename X1, typename X2, typename X3>
2559 inline MutantFunctor<R, Tuple0>
2560 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
2561 const P3& p3) {
2562 MutantRunner<R, Tuple0>* t =
2563 new Mutant<R, T, R (U::*)(X1, X2, X3),
2564 Tuple3<P1, P2, P3>, Tuple0>
2565 (obj, method, MakeTuple(p1, p2, p3));
2566 return MutantFunctor<R, Tuple0>(t);
2567 }
2568
2569 template <typename R, typename P1, typename P2, typename P3, typename X1,
2570 typename X2, typename X3>
2571 inline MutantFunctor<R, Tuple0>
2572 CreateFunctor(R (*function)(X1, X2, X3), const P1& p1, const P2& p2,
2573 const P3& p3) {
2574 MutantRunner<R, Tuple0>* t =
2575 new MutantFunction<R, R (*)(X1, X2, X3),
2576 Tuple3<P1, P2, P3>, Tuple0>
2577 (function, MakeTuple(p1, p2, p3));
2578 return MutantFunctor<R, Tuple0>(t);
2579 }
2580
2581 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2582 template <typename R, typename T, typename U, typename P1, typename P2,
2583 typename P3, typename X1, typename X2, typename X3>
2584 inline MutantFunctor<R, Tuple0>
2585 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
2586 const P3& p3) {
2587 MutantRunner<R, Tuple0>* t =
2588 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3),
2589 Tuple3<P1, P2, P3>, Tuple0>
2590 (obj, method, MakeTuple(p1, p2, p3));
2591 return MutantFunctor<R, Tuple0>(t);
2592 }
2593 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2594
2595 #if defined (OS_WIN)
2596 template <typename R, typename T, typename U, typename P1, typename P2,
2597 typename P3, typename X1, typename X2, typename X3>
2598 inline MutantFunctor<R, Tuple0>
2599 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
2600 const P2& p2, const P3& p3) {
2601 MutantRunner<R, Tuple0>* t =
2602 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3),
2603 Tuple3<P1, P2, P3>, Tuple0>
2604 (obj, method, MakeTuple(p1, p2, p3));
2605 return MutantFunctor<R, Tuple0>(t);
2606 }
2607
2608 template <typename R, typename P1, typename P2, typename P3, typename X1,
2609 typename X2, typename X3>
2610 inline MutantFunctor<R, Tuple0>
2611 CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2,
2612 const P3& p3) {
2613 MutantRunner<R, Tuple0>* t =
2614 new MutantFunction<R, R (__stdcall *)(X1, X2, X3),
2615 Tuple3<P1, P2, P3>, Tuple0>
2616 (function, MakeTuple(p1, p2, p3));
2617 return MutantFunctor<R, Tuple0>(t);
2618 }
2619 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2620 template <typename R, typename T, typename U, typename P1, typename P2,
2621 typename P3, typename X1, typename X2, typename X3>
2622 inline MutantFunctor<R, Tuple0>
2623 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
2624 const P2& p2, const P3& p3) {
2625 MutantRunner<R, Tuple0>* t =
2626 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3),
2627 Tuple3<P1, P2, P3>, Tuple0>
2628 (obj, method, MakeTuple(p1, p2, p3));
2629 return MutantFunctor<R, Tuple0>(t);
2630 }
2631 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2632 #endif // OS_WIN
2633
2634 // 3 - 1
2635 template <typename R, typename T, typename U, typename P1, typename P2,
2636 typename P3, typename A1, typename X1, typename X2, typename X3>
2637 inline MutantFunctor<R, Tuple1<A1> >
2638 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
2639 const P2& p2, const P3& p3) {
2640 MutantRunner<R, Tuple1<A1> >* t =
2641 new Mutant<R, T, R (U::*)(X1, X2, X3, A1),
2642 Tuple3<P1, P2, P3>, Tuple1<A1> >
2643 (obj, method, MakeTuple(p1, p2, p3));
2644 return MutantFunctor<R, Tuple1<A1> >(t);
2645 }
2646
2647 template <typename R, typename P1, typename P2, typename P3, typename A1,
2648 typename X1, typename X2, typename X3>
2649 inline MutantFunctor<R, Tuple1<A1> >
2650 CreateFunctor(R (*function)(X1, X2, X3, A1), const P1& p1, const P2& p2,
2651 const P3& p3) {
2652 MutantRunner<R, Tuple1<A1> >* t =
2653 new MutantFunction<R, R (*)(X1, X2, X3, A1),
2654 Tuple3<P1, P2, P3>, Tuple1<A1> >
2655 (function, MakeTuple(p1, p2, p3));
2656 return MutantFunctor<R, Tuple1<A1> >(t);
2657 }
2658
2659 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2660 template <typename R, typename T, typename U, typename P1, typename P2,
2661 typename P3, typename A1, typename X1, typename X2, typename X3>
2662 inline MutantFunctor<R, Tuple1<A1> >
2663 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
2664 const P2& p2, const P3& p3) {
2665 MutantRunner<R, Tuple1<A1> >* t =
2666 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1),
2667 Tuple3<P1, P2, P3>, Tuple1<A1> >
2668 (obj, method, MakeTuple(p1, p2, p3));
2669 return MutantFunctor<R, Tuple1<A1> >(t);
2670 }
2671 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2672
2673 #if defined (OS_WIN)
2674 template <typename R, typename T, typename U, typename P1, typename P2,
2675 typename P3, typename A1, typename X1, typename X2, typename X3>
2676 inline MutantFunctor<R, Tuple1<A1> >
2677 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
2678 const P2& p2, const P3& p3) {
2679 MutantRunner<R, Tuple1<A1> >* t =
2680 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
2681 Tuple3<P1, P2, P3>, Tuple1<A1> >
2682 (obj, method, MakeTuple(p1, p2, p3));
2683 return MutantFunctor<R, Tuple1<A1> >(t);
2684 }
2685
2686 template <typename R, typename P1, typename P2, typename P3, typename A1,
2687 typename X1, typename X2, typename X3>
2688 inline MutantFunctor<R, Tuple1<A1> >
2689 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1,
2690 const P2& p2, const P3& p3) {
2691 MutantRunner<R, Tuple1<A1> >* t =
2692 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1),
2693 Tuple3<P1, P2, P3>, Tuple1<A1> >
2694 (function, MakeTuple(p1, p2, p3));
2695 return MutantFunctor<R, Tuple1<A1> >(t);
2696 }
2697 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2698 template <typename R, typename T, typename U, typename P1, typename P2,
2699 typename P3, typename A1, typename X1, typename X2, typename X3>
2700 inline MutantFunctor<R, Tuple1<A1> >
2701 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
2702 const P2& p2, const P3& p3) {
2703 MutantRunner<R, Tuple1<A1> >* t =
2704 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
2705 Tuple3<P1, P2, P3>, Tuple1<A1> >
2706 (obj, method, MakeTuple(p1, p2, p3));
2707 return MutantFunctor<R, Tuple1<A1> >(t);
2708 }
2709 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2710 #endif // OS_WIN
2711
2712 // 3 - 2
2713 template <typename R, typename T, typename U, typename P1, typename P2,
2714 typename P3, typename A1, typename A2, typename X1, typename X2,
2715 typename X3>
2716 inline MutantFunctor<R, Tuple2<A1, A2> >
2717 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
2718 const P2& p2, const P3& p3) {
2719 MutantRunner<R, Tuple2<A1, A2> >* t =
2720 new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2),
2721 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2722 (obj, method, MakeTuple(p1, p2, p3));
2723 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2724 }
2725
2726 template <typename R, typename P1, typename P2, typename P3, typename A1,
2727 typename A2, typename X1, typename X2, typename X3>
2728 inline MutantFunctor<R, Tuple2<A1, A2> >
2729 CreateFunctor(R (*function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2,
2730 const P3& p3) {
2731 MutantRunner<R, Tuple2<A1, A2> >* t =
2732 new MutantFunction<R, R (*)(X1, X2, X3, A1, A2),
2733 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2734 (function, MakeTuple(p1, p2, p3));
2735 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2736 }
2737
2738 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2739 template <typename R, typename T, typename U, typename P1, typename P2,
2740 typename P3, typename A1, typename A2, typename X1, typename X2,
2741 typename X3>
2742 inline MutantFunctor<R, Tuple2<A1, A2> >
2743 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
2744 const P2& p2, const P3& p3) {
2745 MutantRunner<R, Tuple2<A1, A2> >* t =
2746 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2),
2747 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2748 (obj, method, MakeTuple(p1, p2, p3));
2749 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2750 }
2751 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2752
2753 #if defined (OS_WIN)
2754 template <typename R, typename T, typename U, typename P1, typename P2,
2755 typename P3, typename A1, typename A2, typename X1, typename X2,
2756 typename X3>
2757 inline MutantFunctor<R, Tuple2<A1, A2> >
2758 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
2759 const P1& p1, const P2& p2, const P3& p3) {
2760 MutantRunner<R, Tuple2<A1, A2> >* t =
2761 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
2762 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2763 (obj, method, MakeTuple(p1, p2, p3));
2764 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2765 }
2766
2767 template <typename R, typename P1, typename P2, typename P3, typename A1,
2768 typename A2, typename X1, typename X2, typename X3>
2769 inline MutantFunctor<R, Tuple2<A1, A2> >
2770 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1,
2771 const P2& p2, const P3& p3) {
2772 MutantRunner<R, Tuple2<A1, A2> >* t =
2773 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2),
2774 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2775 (function, MakeTuple(p1, p2, p3));
2776 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2777 }
2778 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2779 template <typename R, typename T, typename U, typename P1, typename P2,
2780 typename P3, typename A1, typename A2, typename X1, typename X2,
2781 typename X3>
2782 inline MutantFunctor<R, Tuple2<A1, A2> >
2783 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
2784 const P1& p1, const P2& p2, const P3& p3) {
2785 MutantRunner<R, Tuple2<A1, A2> >* t =
2786 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
2787 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
2788 (obj, method, MakeTuple(p1, p2, p3));
2789 return MutantFunctor<R, Tuple2<A1, A2> >(t);
2790 }
2791 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2792 #endif // OS_WIN
2793
2794 // 3 - 3
2795 template <typename R, typename T, typename U, typename P1, typename P2,
2796 typename P3, typename A1, typename A2, typename A3, typename X1,
2797 typename X2, typename X3>
2798 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2799 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
2800 const P2& p2, const P3& p3) {
2801 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2802 new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
2803 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2804 (obj, method, MakeTuple(p1, p2, p3));
2805 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2806 }
2807
2808 template <typename R, typename P1, typename P2, typename P3, typename A1,
2809 typename A2, typename A3, typename X1, typename X2, typename X3>
2810 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2811 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2,
2812 const P3& p3) {
2813 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2814 new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3),
2815 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2816 (function, MakeTuple(p1, p2, p3));
2817 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2818 }
2819
2820 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2821 template <typename R, typename T, typename U, typename P1, typename P2,
2822 typename P3, typename A1, typename A2, typename A3, typename X1,
2823 typename X2, typename X3>
2824 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2825 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
2826 const P2& p2, const P3& p3) {
2827 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2828 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
2829 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2830 (obj, method, MakeTuple(p1, p2, p3));
2831 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2832 }
2833 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2834
2835 #if defined (OS_WIN)
2836 template <typename R, typename T, typename U, typename P1, typename P2,
2837 typename P3, typename A1, typename A2, typename A3, typename X1,
2838 typename X2, typename X3>
2839 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2840 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
2841 const P1& p1, const P2& p2, const P3& p3) {
2842 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2843 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
2844 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2845 (obj, method, MakeTuple(p1, p2, p3));
2846 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2847 }
2848
2849 template <typename R, typename P1, typename P2, typename P3, typename A1,
2850 typename A2, typename A3, typename X1, typename X2, typename X3>
2851 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2852 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1,
2853 const P2& p2, const P3& p3) {
2854 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2855 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3),
2856 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2857 (function, MakeTuple(p1, p2, p3));
2858 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2859 }
2860 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2861 template <typename R, typename T, typename U, typename P1, typename P2,
2862 typename P3, typename A1, typename A2, typename A3, typename X1,
2863 typename X2, typename X3>
2864 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
2865 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
2866 const P1& p1, const P2& p2, const P3& p3) {
2867 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
2868 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
2869 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
2870 (obj, method, MakeTuple(p1, p2, p3));
2871 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
2872 }
2873 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2874 #endif // OS_WIN
2875
2876 // 3 - 4
2877 template <typename R, typename T, typename U, typename P1, typename P2,
2878 typename P3, typename A1, typename A2, typename A3, typename A4,
2879 typename X1, typename X2, typename X3>
2880 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2881 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
2882 const P2& p2, const P3& p3) {
2883 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2884 new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
2885 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2886 (obj, method, MakeTuple(p1, p2, p3));
2887 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2888 }
2889
2890 template <typename R, typename P1, typename P2, typename P3, typename A1,
2891 typename A2, typename A3, typename A4, typename X1, typename X2,
2892 typename X3>
2893 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2894 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
2895 const P2& p2, const P3& p3) {
2896 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2897 new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4),
2898 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2899 (function, MakeTuple(p1, p2, p3));
2900 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2901 }
2902
2903 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2904 template <typename R, typename T, typename U, typename P1, typename P2,
2905 typename P3, typename A1, typename A2, typename A3, typename A4,
2906 typename X1, typename X2, typename X3>
2907 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2908 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
2909 const P2& p2, const P3& p3) {
2910 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2911 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
2912 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2913 (obj, method, MakeTuple(p1, p2, p3));
2914 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2915 }
2916 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2917
2918 #if defined (OS_WIN)
2919 template <typename R, typename T, typename U, typename P1, typename P2,
2920 typename P3, typename A1, typename A2, typename A3, typename A4,
2921 typename X1, typename X2, typename X3>
2922 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2923 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
2924 const P1& p1, const P2& p2, const P3& p3) {
2925 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2926 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
2927 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2928 (obj, method, MakeTuple(p1, p2, p3));
2929 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2930 }
2931
2932 template <typename R, typename P1, typename P2, typename P3, typename A1,
2933 typename A2, typename A3, typename A4, typename X1, typename X2,
2934 typename X3>
2935 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2936 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
2937 const P2& p2, const P3& p3) {
2938 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2939 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4),
2940 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2941 (function, MakeTuple(p1, p2, p3));
2942 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2943 }
2944 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2945 template <typename R, typename T, typename U, typename P1, typename P2,
2946 typename P3, typename A1, typename A2, typename A3, typename A4,
2947 typename X1, typename X2, typename X3>
2948 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
2949 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
2950 const P1& p1, const P2& p2, const P3& p3) {
2951 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
2952 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
2953 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
2954 (obj, method, MakeTuple(p1, p2, p3));
2955 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
2956 }
2957 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2958 #endif // OS_WIN
2959
2960 // 3 - 5
2961 template <typename R, typename T, typename U, typename P1, typename P2,
2962 typename P3, typename A1, typename A2, typename A3, typename A4,
2963 typename A5, typename X1, typename X2, typename X3>
2964 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2965 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
2966 const P1& p1, const P2& p2, const P3& p3) {
2967 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2968 new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
2969 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
2970 (obj, method, MakeTuple(p1, p2, p3));
2971 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2972 }
2973
2974 template <typename R, typename P1, typename P2, typename P3, typename A1,
2975 typename A2, typename A3, typename A4, typename A5, typename X1,
2976 typename X2, typename X3>
2977 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2978 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1,
2979 const P2& p2, const P3& p3) {
2980 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2981 new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5),
2982 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
2983 (function, MakeTuple(p1, p2, p3));
2984 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2985 }
2986
2987 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
2988 template <typename R, typename T, typename U, typename P1, typename P2,
2989 typename P3, typename A1, typename A2, typename A3, typename A4,
2990 typename A5, typename X1, typename X2, typename X3>
2991 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
2992 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
2993 const P1& p1, const P2& p2, const P3& p3) {
2994 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
2995 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
2996 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
2997 (obj, method, MakeTuple(p1, p2, p3));
2998 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
2999 }
3000 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3001
3002 #if defined (OS_WIN)
3003 template <typename R, typename T, typename U, typename P1, typename P2,
3004 typename P3, typename A1, typename A2, typename A3, typename A4,
3005 typename A5, typename X1, typename X2, typename X3>
3006 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3007 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
3008 const P1& p1, const P2& p2, const P3& p3) {
3009 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3010 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
3011 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
3012 (obj, method, MakeTuple(p1, p2, p3));
3013 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3014 }
3015
3016 template <typename R, typename P1, typename P2, typename P3, typename A1,
3017 typename A2, typename A3, typename A4, typename A5, typename X1,
3018 typename X2, typename X3>
3019 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3020 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5),
3021 const P1& p1, const P2& p2, const P3& p3) {
3022 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3023 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5),
3024 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
3025 (function, MakeTuple(p1, p2, p3));
3026 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3027 }
3028 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3029 template <typename R, typename T, typename U, typename P1, typename P2,
3030 typename P3, typename A1, typename A2, typename A3, typename A4,
3031 typename A5, typename X1, typename X2, typename X3>
3032 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3033 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
3034 const P1& p1, const P2& p2, const P3& p3) {
3035 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3036 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
3037 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
3038 (obj, method, MakeTuple(p1, p2, p3));
3039 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3040 }
3041 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3042 #endif // OS_WIN
3043
3044 // 3 - 6
3045 template <typename R, typename T, typename U, typename P1, typename P2,
3046 typename P3, typename A1, typename A2, typename A3, typename A4,
3047 typename A5, typename A6, typename X1, typename X2, typename X3>
3048 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3049 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3050 const P1& p1, const P2& p2, const P3& p3) {
3051 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3052 new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3053 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3054 (obj, method, MakeTuple(p1, p2, p3));
3055 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3056 }
3057
3058 template <typename R, typename P1, typename P2, typename P3, typename A1,
3059 typename A2, typename A3, typename A4, typename A5, typename A6,
3060 typename X1, typename X2, typename X3>
3061 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3062 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1,
3063 const P2& p2, const P3& p3) {
3064 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3065 new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3066 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3067 (function, MakeTuple(p1, p2, p3));
3068 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3069 }
3070
3071 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3072 template <typename R, typename T, typename U, typename P1, typename P2,
3073 typename P3, typename A1, typename A2, typename A3, typename A4,
3074 typename A5, typename A6, typename X1, typename X2, typename X3>
3075 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3076 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3077 const P1& p1, const P2& p2, const P3& p3) {
3078 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3079 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3080 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3081 (obj, method, MakeTuple(p1, p2, p3));
3082 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3083 }
3084 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3085
3086 #if defined (OS_WIN)
3087 template <typename R, typename T, typename U, typename P1, typename P2,
3088 typename P3, typename A1, typename A2, typename A3, typename A4,
3089 typename A5, typename A6, typename X1, typename X2, typename X3>
3090 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3091 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
3092 A6), const P1& p1, const P2& p2, const P3& p3) {
3093 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3094 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3095 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3096 (obj, method, MakeTuple(p1, p2, p3));
3097 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3098 }
3099
3100 template <typename R, typename P1, typename P2, typename P3, typename A1,
3101 typename A2, typename A3, typename A4, typename A5, typename A6,
3102 typename X1, typename X2, typename X3>
3103 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3104 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3105 const P1& p1, const P2& p2, const P3& p3) {
3106 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3107 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3108 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3109 (function, MakeTuple(p1, p2, p3));
3110 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3111 }
3112 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3113 template <typename R, typename T, typename U, typename P1, typename P2,
3114 typename P3, typename A1, typename A2, typename A3, typename A4,
3115 typename A5, typename A6, typename X1, typename X2, typename X3>
3116 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3117 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
3118 A6), const P1& p1, const P2& p2, const P3& p3) {
3119 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3120 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
3121 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
3122 (obj, method, MakeTuple(p1, p2, p3));
3123 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3124 }
3125 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3126 #endif // OS_WIN
3127
3128 // 4 - 0
3129 template <typename R, typename T, typename U, typename P1, typename P2,
3130 typename P3, typename P4, typename X1, typename X2, typename X3,
3131 typename X4>
3132 inline MutantFunctor<R, Tuple0>
3133 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
3134 const P2& p2, const P3& p3, const P4& p4) {
3135 MutantRunner<R, Tuple0>* t =
3136 new Mutant<R, T, R (U::*)(X1, X2, X3, X4),
3137 Tuple4<P1, P2, P3, P4>, Tuple0>
3138 (obj, method, MakeTuple(p1, p2, p3, p4));
3139 return MutantFunctor<R, Tuple0>(t);
3140 }
3141
3142 template <typename R, typename P1, typename P2, typename P3, typename P4,
3143 typename X1, typename X2, typename X3, typename X4>
3144 inline MutantFunctor<R, Tuple0>
3145 CreateFunctor(R (*function)(X1, X2, X3, X4), const P1& p1, const P2& p2,
3146 const P3& p3, const P4& p4) {
3147 MutantRunner<R, Tuple0>* t =
3148 new MutantFunction<R, R (*)(X1, X2, X3, X4),
3149 Tuple4<P1, P2, P3, P4>, Tuple0>
3150 (function, MakeTuple(p1, p2, p3, p4));
3151 return MutantFunctor<R, Tuple0>(t);
3152 }
3153
3154 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3155 template <typename R, typename T, typename U, typename P1, typename P2,
3156 typename P3, typename P4, typename X1, typename X2, typename X3,
3157 typename X4>
3158 inline MutantFunctor<R, Tuple0>
3159 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
3160 const P2& p2, const P3& p3, const P4& p4) {
3161 MutantRunner<R, Tuple0>* t =
3162 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4),
3163 Tuple4<P1, P2, P3, P4>, Tuple0>
3164 (obj, method, MakeTuple(p1, p2, p3, p4));
3165 return MutantFunctor<R, Tuple0>(t);
3166 }
3167 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3168
3169 #if defined (OS_WIN)
3170 template <typename R, typename T, typename U, typename P1, typename P2,
3171 typename P3, typename P4, typename X1, typename X2, typename X3,
3172 typename X4>
3173 inline MutantFunctor<R, Tuple0>
3174 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
3175 const P2& p2, const P3& p3, const P4& p4) {
3176 MutantRunner<R, Tuple0>* t =
3177 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
3178 Tuple4<P1, P2, P3, P4>, Tuple0>
3179 (obj, method, MakeTuple(p1, p2, p3, p4));
3180 return MutantFunctor<R, Tuple0>(t);
3181 }
3182
3183 template <typename R, typename P1, typename P2, typename P3, typename P4,
3184 typename X1, typename X2, typename X3, typename X4>
3185 inline MutantFunctor<R, Tuple0>
3186 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1,
3187 const P2& p2, const P3& p3, const P4& p4) {
3188 MutantRunner<R, Tuple0>* t =
3189 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4),
3190 Tuple4<P1, P2, P3, P4>, Tuple0>
3191 (function, MakeTuple(p1, p2, p3, p4));
3192 return MutantFunctor<R, Tuple0>(t);
3193 }
3194 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3195 template <typename R, typename T, typename U, typename P1, typename P2,
3196 typename P3, typename P4, typename X1, typename X2, typename X3,
3197 typename X4>
3198 inline MutantFunctor<R, Tuple0>
3199 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
3200 const P2& p2, const P3& p3, const P4& p4) {
3201 MutantRunner<R, Tuple0>* t =
3202 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
3203 Tuple4<P1, P2, P3, P4>, Tuple0>
3204 (obj, method, MakeTuple(p1, p2, p3, p4));
3205 return MutantFunctor<R, Tuple0>(t);
3206 }
3207 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3208 #endif // OS_WIN
3209
3210 // 4 - 1
3211 template <typename R, typename T, typename U, typename P1, typename P2,
3212 typename P3, typename P4, typename A1, typename X1, typename X2,
3213 typename X3, typename X4>
3214 inline MutantFunctor<R, Tuple1<A1> >
3215 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
3216 const P2& p2, const P3& p3, const P4& p4) {
3217 MutantRunner<R, Tuple1<A1> >* t =
3218 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1),
3219 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3220 (obj, method, MakeTuple(p1, p2, p3, p4));
3221 return MutantFunctor<R, Tuple1<A1> >(t);
3222 }
3223
3224 template <typename R, typename P1, typename P2, typename P3, typename P4,
3225 typename A1, typename X1, typename X2, typename X3, typename X4>
3226 inline MutantFunctor<R, Tuple1<A1> >
3227 CreateFunctor(R (*function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2,
3228 const P3& p3, const P4& p4) {
3229 MutantRunner<R, Tuple1<A1> >* t =
3230 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1),
3231 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3232 (function, MakeTuple(p1, p2, p3, p4));
3233 return MutantFunctor<R, Tuple1<A1> >(t);
3234 }
3235
3236 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3237 template <typename R, typename T, typename U, typename P1, typename P2,
3238 typename P3, typename P4, typename A1, typename X1, typename X2,
3239 typename X3, typename X4>
3240 inline MutantFunctor<R, Tuple1<A1> >
3241 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
3242 const P2& p2, const P3& p3, const P4& p4) {
3243 MutantRunner<R, Tuple1<A1> >* t =
3244 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1),
3245 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3246 (obj, method, MakeTuple(p1, p2, p3, p4));
3247 return MutantFunctor<R, Tuple1<A1> >(t);
3248 }
3249 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3250
3251 #if defined (OS_WIN)
3252 template <typename R, typename T, typename U, typename P1, typename P2,
3253 typename P3, typename P4, typename A1, typename X1, typename X2,
3254 typename X3, typename X4>
3255 inline MutantFunctor<R, Tuple1<A1> >
3256 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
3257 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3258 MutantRunner<R, Tuple1<A1> >* t =
3259 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
3260 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3261 (obj, method, MakeTuple(p1, p2, p3, p4));
3262 return MutantFunctor<R, Tuple1<A1> >(t);
3263 }
3264
3265 template <typename R, typename P1, typename P2, typename P3, typename P4,
3266 typename A1, typename X1, typename X2, typename X3, typename X4>
3267 inline MutantFunctor<R, Tuple1<A1> >
3268 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1,
3269 const P2& p2, const P3& p3, const P4& p4) {
3270 MutantRunner<R, Tuple1<A1> >* t =
3271 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1),
3272 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3273 (function, MakeTuple(p1, p2, p3, p4));
3274 return MutantFunctor<R, Tuple1<A1> >(t);
3275 }
3276 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3277 template <typename R, typename T, typename U, typename P1, typename P2,
3278 typename P3, typename P4, typename A1, typename X1, typename X2,
3279 typename X3, typename X4>
3280 inline MutantFunctor<R, Tuple1<A1> >
3281 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
3282 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3283 MutantRunner<R, Tuple1<A1> >* t =
3284 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
3285 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
3286 (obj, method, MakeTuple(p1, p2, p3, p4));
3287 return MutantFunctor<R, Tuple1<A1> >(t);
3288 }
3289 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3290 #endif // OS_WIN
3291
3292 // 4 - 2
3293 template <typename R, typename T, typename U, typename P1, typename P2,
3294 typename P3, typename P4, typename A1, typename A2, typename X1,
3295 typename X2, typename X3, typename X4>
3296 inline MutantFunctor<R, Tuple2<A1, A2> >
3297 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
3298 const P2& p2, const P3& p3, const P4& p4) {
3299 MutantRunner<R, Tuple2<A1, A2> >* t =
3300 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
3301 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3302 (obj, method, MakeTuple(p1, p2, p3, p4));
3303 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3304 }
3305
3306 template <typename R, typename P1, typename P2, typename P3, typename P4,
3307 typename A1, typename A2, typename X1, typename X2, typename X3,
3308 typename X4>
3309 inline MutantFunctor<R, Tuple2<A1, A2> >
3310 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2,
3311 const P3& p3, const P4& p4) {
3312 MutantRunner<R, Tuple2<A1, A2> >* t =
3313 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2),
3314 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3315 (function, MakeTuple(p1, p2, p3, p4));
3316 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3317 }
3318
3319 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3320 template <typename R, typename T, typename U, typename P1, typename P2,
3321 typename P3, typename P4, typename A1, typename A2, typename X1,
3322 typename X2, typename X3, typename X4>
3323 inline MutantFunctor<R, Tuple2<A1, A2> >
3324 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
3325 const P2& p2, const P3& p3, const P4& p4) {
3326 MutantRunner<R, Tuple2<A1, A2> >* t =
3327 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
3328 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3329 (obj, method, MakeTuple(p1, p2, p3, p4));
3330 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3331 }
3332 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3333
3334 #if defined (OS_WIN)
3335 template <typename R, typename T, typename U, typename P1, typename P2,
3336 typename P3, typename P4, typename A1, typename A2, typename X1,
3337 typename X2, typename X3, typename X4>
3338 inline MutantFunctor<R, Tuple2<A1, A2> >
3339 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
3340 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3341 MutantRunner<R, Tuple2<A1, A2> >* t =
3342 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
3343 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3344 (obj, method, MakeTuple(p1, p2, p3, p4));
3345 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3346 }
3347
3348 template <typename R, typename P1, typename P2, typename P3, typename P4,
3349 typename A1, typename A2, typename X1, typename X2, typename X3,
3350 typename X4>
3351 inline MutantFunctor<R, Tuple2<A1, A2> >
3352 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1,
3353 const P2& p2, const P3& p3, const P4& p4) {
3354 MutantRunner<R, Tuple2<A1, A2> >* t =
3355 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2),
3356 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3357 (function, MakeTuple(p1, p2, p3, p4));
3358 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3359 }
3360 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3361 template <typename R, typename T, typename U, typename P1, typename P2,
3362 typename P3, typename P4, typename A1, typename A2, typename X1,
3363 typename X2, typename X3, typename X4>
3364 inline MutantFunctor<R, Tuple2<A1, A2> >
3365 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
3366 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3367 MutantRunner<R, Tuple2<A1, A2> >* t =
3368 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
3369 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
3370 (obj, method, MakeTuple(p1, p2, p3, p4));
3371 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3372 }
3373 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3374 #endif // OS_WIN
3375
3376 // 4 - 3
3377 template <typename R, typename T, typename U, typename P1, typename P2,
3378 typename P3, typename P4, typename A1, typename A2, typename A3,
3379 typename X1, typename X2, typename X3, typename X4>
3380 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3381 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
3382 const P2& p2, const P3& p3, const P4& p4) {
3383 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3384 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
3385 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3386 (obj, method, MakeTuple(p1, p2, p3, p4));
3387 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3388 }
3389
3390 template <typename R, typename P1, typename P2, typename P3, typename P4,
3391 typename A1, typename A2, typename A3, typename X1, typename X2,
3392 typename X3, typename X4>
3393 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3394 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
3395 const P2& p2, const P3& p3, const P4& p4) {
3396 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3397 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3),
3398 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3399 (function, MakeTuple(p1, p2, p3, p4));
3400 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3401 }
3402
3403 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3404 template <typename R, typename T, typename U, typename P1, typename P2,
3405 typename P3, typename P4, typename A1, typename A2, typename A3,
3406 typename X1, typename X2, typename X3, typename X4>
3407 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3408 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
3409 const P2& p2, const P3& p3, const P4& p4) {
3410 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3411 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
3412 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3413 (obj, method, MakeTuple(p1, p2, p3, p4));
3414 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3415 }
3416 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3417
3418 #if defined (OS_WIN)
3419 template <typename R, typename T, typename U, typename P1, typename P2,
3420 typename P3, typename P4, typename A1, typename A2, typename A3,
3421 typename X1, typename X2, typename X3, typename X4>
3422 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3423 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
3424 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3425 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3426 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
3427 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3428 (obj, method, MakeTuple(p1, p2, p3, p4));
3429 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3430 }
3431
3432 template <typename R, typename P1, typename P2, typename P3, typename P4,
3433 typename A1, typename A2, typename A3, typename X1, typename X2,
3434 typename X3, typename X4>
3435 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3436 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
3437 const P2& p2, const P3& p3, const P4& p4) {
3438 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3439 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3),
3440 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3441 (function, MakeTuple(p1, p2, p3, p4));
3442 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3443 }
3444 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3445 template <typename R, typename T, typename U, typename P1, typename P2,
3446 typename P3, typename P4, typename A1, typename A2, typename A3,
3447 typename X1, typename X2, typename X3, typename X4>
3448 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3449 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
3450 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3451 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3452 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
3453 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
3454 (obj, method, MakeTuple(p1, p2, p3, p4));
3455 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3456 }
3457 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3458 #endif // OS_WIN
3459
3460 // 4 - 4
3461 template <typename R, typename T, typename U, typename P1, typename P2,
3462 typename P3, typename P4, typename A1, typename A2, typename A3,
3463 typename A4, typename X1, typename X2, typename X3, typename X4>
3464 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3465 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
3466 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3467 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3468 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
3469 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3470 (obj, method, MakeTuple(p1, p2, p3, p4));
3471 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3472 }
3473
3474 template <typename R, typename P1, typename P2, typename P3, typename P4,
3475 typename A1, typename A2, typename A3, typename A4, typename X1,
3476 typename X2, typename X3, typename X4>
3477 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3478 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1,
3479 const P2& p2, const P3& p3, const P4& p4) {
3480 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3481 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4),
3482 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3483 (function, MakeTuple(p1, p2, p3, p4));
3484 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3485 }
3486
3487 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3488 template <typename R, typename T, typename U, typename P1, typename P2,
3489 typename P3, typename P4, typename A1, typename A2, typename A3,
3490 typename A4, typename X1, typename X2, typename X3, typename X4>
3491 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3492 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
3493 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3494 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3495 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
3496 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3497 (obj, method, MakeTuple(p1, p2, p3, p4));
3498 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3499 }
3500 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3501
3502 #if defined (OS_WIN)
3503 template <typename R, typename T, typename U, typename P1, typename P2,
3504 typename P3, typename P4, typename A1, typename A2, typename A3,
3505 typename A4, typename X1, typename X2, typename X3, typename X4>
3506 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3507 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
3508 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3509 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3510 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
3511 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3512 (obj, method, MakeTuple(p1, p2, p3, p4));
3513 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3514 }
3515
3516 template <typename R, typename P1, typename P2, typename P3, typename P4,
3517 typename A1, typename A2, typename A3, typename A4, typename X1,
3518 typename X2, typename X3, typename X4>
3519 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3520 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4),
3521 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3522 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3523 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4),
3524 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3525 (function, MakeTuple(p1, p2, p3, p4));
3526 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3527 }
3528 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3529 template <typename R, typename T, typename U, typename P1, typename P2,
3530 typename P3, typename P4, typename A1, typename A2, typename A3,
3531 typename A4, typename X1, typename X2, typename X3, typename X4>
3532 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
3533 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
3534 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3535 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
3536 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
3537 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
3538 (obj, method, MakeTuple(p1, p2, p3, p4));
3539 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
3540 }
3541 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3542 #endif // OS_WIN
3543
3544 // 4 - 5
3545 template <typename R, typename T, typename U, typename P1, typename P2,
3546 typename P3, typename P4, typename A1, typename A2, typename A3,
3547 typename A4, typename A5, typename X1, typename X2, typename X3,
3548 typename X4>
3549 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3550 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3551 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3552 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3553 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3554 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3555 (obj, method, MakeTuple(p1, p2, p3, p4));
3556 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3557 }
3558
3559 template <typename R, typename P1, typename P2, typename P3, typename P4,
3560 typename A1, typename A2, typename A3, typename A4, typename A5,
3561 typename X1, typename X2, typename X3, typename X4>
3562 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3563 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1,
3564 const P2& p2, const P3& p3, const P4& p4) {
3565 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3566 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3567 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3568 (function, MakeTuple(p1, p2, p3, p4));
3569 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3570 }
3571
3572 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3573 template <typename R, typename T, typename U, typename P1, typename P2,
3574 typename P3, typename P4, typename A1, typename A2, typename A3,
3575 typename A4, typename A5, typename X1, typename X2, typename X3,
3576 typename X4>
3577 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3578 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3579 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3580 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3581 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3582 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3583 (obj, method, MakeTuple(p1, p2, p3, p4));
3584 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3585 }
3586 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3587
3588 #if defined (OS_WIN)
3589 template <typename R, typename T, typename U, typename P1, typename P2,
3590 typename P3, typename P4, typename A1, typename A2, typename A3,
3591 typename A4, typename A5, typename X1, typename X2, typename X3,
3592 typename X4>
3593 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3594 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
3595 A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3596 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3597 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3598 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3599 (obj, method, MakeTuple(p1, p2, p3, p4));
3600 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3601 }
3602
3603 template <typename R, typename P1, typename P2, typename P3, typename P4,
3604 typename A1, typename A2, typename A3, typename A4, typename A5,
3605 typename X1, typename X2, typename X3, typename X4>
3606 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3607 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3608 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3609 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3610 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3611 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3612 (function, MakeTuple(p1, p2, p3, p4));
3613 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3614 }
3615 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3616 template <typename R, typename T, typename U, typename P1, typename P2,
3617 typename P3, typename P4, typename A1, typename A2, typename A3,
3618 typename A4, typename A5, typename X1, typename X2, typename X3,
3619 typename X4>
3620 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
3621 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
3622 A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3623 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
3624 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
3625 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
3626 (obj, method, MakeTuple(p1, p2, p3, p4));
3627 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
3628 }
3629 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3630 #endif // OS_WIN
3631
3632 // 4 - 6
3633 template <typename R, typename T, typename U, typename P1, typename P2,
3634 typename P3, typename P4, typename A1, typename A2, typename A3,
3635 typename A4, typename A5, typename A6, typename X1, typename X2,
3636 typename X3, typename X4>
3637 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3638 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3639 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3640 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3641 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3642 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3643 (obj, method, MakeTuple(p1, p2, p3, p4));
3644 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3645 }
3646
3647 template <typename R, typename P1, typename P2, typename P3, typename P4,
3648 typename A1, typename A2, typename A3, typename A4, typename A5,
3649 typename A6, typename X1, typename X2, typename X3, typename X4>
3650 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3651 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3652 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3653 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3654 new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3655 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3656 (function, MakeTuple(p1, p2, p3, p4));
3657 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3658 }
3659
3660 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3661 template <typename R, typename T, typename U, typename P1, typename P2,
3662 typename P3, typename P4, typename A1, typename A2, typename A3,
3663 typename A4, typename A5, typename A6, typename X1, typename X2,
3664 typename X3, typename X4>
3665 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3666 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3667 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3668 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3669 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3670 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3671 (obj, method, MakeTuple(p1, p2, p3, p4));
3672 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3673 }
3674 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3675
3676 #if defined (OS_WIN)
3677 template <typename R, typename T, typename U, typename P1, typename P2,
3678 typename P3, typename P4, typename A1, typename A2, typename A3,
3679 typename A4, typename A5, typename A6, typename X1, typename X2,
3680 typename X3, typename X4>
3681 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3682 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
3683 A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3684 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3685 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3686 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3687 (obj, method, MakeTuple(p1, p2, p3, p4));
3688 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3689 }
3690
3691 template <typename R, typename P1, typename P2, typename P3, typename P4,
3692 typename A1, typename A2, typename A3, typename A4, typename A5,
3693 typename A6, typename X1, typename X2, typename X3, typename X4>
3694 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3695 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3696 const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3697 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3698 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3699 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3700 (function, MakeTuple(p1, p2, p3, p4));
3701 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3702 }
3703 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3704 template <typename R, typename T, typename U, typename P1, typename P2,
3705 typename P3, typename P4, typename A1, typename A2, typename A3,
3706 typename A4, typename A5, typename A6, typename X1, typename X2,
3707 typename X3, typename X4>
3708 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
3709 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
3710 A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
3711 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
3712 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
3713 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
3714 (obj, method, MakeTuple(p1, p2, p3, p4));
3715 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
3716 }
3717 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3718 #endif // OS_WIN
3719
3720 // 5 - 0
3721 template <typename R, typename T, typename U, typename P1, typename P2,
3722 typename P3, typename P4, typename P5, typename X1, typename X2,
3723 typename X3, typename X4, typename X5>
3724 inline MutantFunctor<R, Tuple0>
3725 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
3726 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3727 MutantRunner<R, Tuple0>* t =
3728 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5),
3729 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3730 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3731 return MutantFunctor<R, Tuple0>(t);
3732 }
3733
3734 template <typename R, typename P1, typename P2, typename P3, typename P4,
3735 typename P5, typename X1, typename X2, typename X3, typename X4,
3736 typename X5>
3737 inline MutantFunctor<R, Tuple0>
3738 CreateFunctor(R (*function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2,
3739 const P3& p3, const P4& p4, const P5& p5) {
3740 MutantRunner<R, Tuple0>* t =
3741 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5),
3742 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3743 (function, MakeTuple(p1, p2, p3, p4, p5));
3744 return MutantFunctor<R, Tuple0>(t);
3745 }
3746
3747 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3748 template <typename R, typename T, typename U, typename P1, typename P2,
3749 typename P3, typename P4, typename P5, typename X1, typename X2,
3750 typename X3, typename X4, typename X5>
3751 inline MutantFunctor<R, Tuple0>
3752 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
3753 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3754 MutantRunner<R, Tuple0>* t =
3755 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5),
3756 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3757 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3758 return MutantFunctor<R, Tuple0>(t);
3759 }
3760 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3761
3762 #if defined (OS_WIN)
3763 template <typename R, typename T, typename U, typename P1, typename P2,
3764 typename P3, typename P4, typename P5, typename X1, typename X2,
3765 typename X3, typename X4, typename X5>
3766 inline MutantFunctor<R, Tuple0>
3767 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
3768 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3769 MutantRunner<R, Tuple0>* t =
3770 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
3771 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3772 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3773 return MutantFunctor<R, Tuple0>(t);
3774 }
3775
3776 template <typename R, typename P1, typename P2, typename P3, typename P4,
3777 typename P5, typename X1, typename X2, typename X3, typename X4,
3778 typename X5>
3779 inline MutantFunctor<R, Tuple0>
3780 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5), const P1& p1,
3781 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3782 MutantRunner<R, Tuple0>* t =
3783 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5),
3784 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3785 (function, MakeTuple(p1, p2, p3, p4, p5));
3786 return MutantFunctor<R, Tuple0>(t);
3787 }
3788 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3789 template <typename R, typename T, typename U, typename P1, typename P2,
3790 typename P3, typename P4, typename P5, typename X1, typename X2,
3791 typename X3, typename X4, typename X5>
3792 inline MutantFunctor<R, Tuple0>
3793 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
3794 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3795 MutantRunner<R, Tuple0>* t =
3796 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
3797 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
3798 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3799 return MutantFunctor<R, Tuple0>(t);
3800 }
3801 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3802 #endif // OS_WIN
3803
3804 // 5 - 1
3805 template <typename R, typename T, typename U, typename P1, typename P2,
3806 typename P3, typename P4, typename P5, typename A1, typename X1,
3807 typename X2, typename X3, typename X4, typename X5>
3808 inline MutantFunctor<R, Tuple1<A1> >
3809 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
3810 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3811 MutantRunner<R, Tuple1<A1> >* t =
3812 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
3813 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3814 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3815 return MutantFunctor<R, Tuple1<A1> >(t);
3816 }
3817
3818 template <typename R, typename P1, typename P2, typename P3, typename P4,
3819 typename P5, typename A1, typename X1, typename X2, typename X3,
3820 typename X4, typename X5>
3821 inline MutantFunctor<R, Tuple1<A1> >
3822 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2,
3823 const P3& p3, const P4& p4, const P5& p5) {
3824 MutantRunner<R, Tuple1<A1> >* t =
3825 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1),
3826 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3827 (function, MakeTuple(p1, p2, p3, p4, p5));
3828 return MutantFunctor<R, Tuple1<A1> >(t);
3829 }
3830
3831 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3832 template <typename R, typename T, typename U, typename P1, typename P2,
3833 typename P3, typename P4, typename P5, typename A1, typename X1,
3834 typename X2, typename X3, typename X4, typename X5>
3835 inline MutantFunctor<R, Tuple1<A1> >
3836 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
3837 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3838 MutantRunner<R, Tuple1<A1> >* t =
3839 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
3840 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3841 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3842 return MutantFunctor<R, Tuple1<A1> >(t);
3843 }
3844 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3845
3846 #if defined (OS_WIN)
3847 template <typename R, typename T, typename U, typename P1, typename P2,
3848 typename P3, typename P4, typename P5, typename A1, typename X1,
3849 typename X2, typename X3, typename X4, typename X5>
3850 inline MutantFunctor<R, Tuple1<A1> >
3851 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
3852 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3853 MutantRunner<R, Tuple1<A1> >* t =
3854 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
3855 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3856 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3857 return MutantFunctor<R, Tuple1<A1> >(t);
3858 }
3859
3860 template <typename R, typename P1, typename P2, typename P3, typename P4,
3861 typename P5, typename A1, typename X1, typename X2, typename X3,
3862 typename X4, typename X5>
3863 inline MutantFunctor<R, Tuple1<A1> >
3864 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1), const P1& p1,
3865 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3866 MutantRunner<R, Tuple1<A1> >* t =
3867 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1),
3868 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3869 (function, MakeTuple(p1, p2, p3, p4, p5));
3870 return MutantFunctor<R, Tuple1<A1> >(t);
3871 }
3872 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3873 template <typename R, typename T, typename U, typename P1, typename P2,
3874 typename P3, typename P4, typename P5, typename A1, typename X1,
3875 typename X2, typename X3, typename X4, typename X5>
3876 inline MutantFunctor<R, Tuple1<A1> >
3877 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
3878 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3879 MutantRunner<R, Tuple1<A1> >* t =
3880 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
3881 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
3882 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3883 return MutantFunctor<R, Tuple1<A1> >(t);
3884 }
3885 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3886 #endif // OS_WIN
3887
3888 // 5 - 2
3889 template <typename R, typename T, typename U, typename P1, typename P2,
3890 typename P3, typename P4, typename P5, typename A1, typename A2,
3891 typename X1, typename X2, typename X3, typename X4, typename X5>
3892 inline MutantFunctor<R, Tuple2<A1, A2> >
3893 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
3894 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3895 MutantRunner<R, Tuple2<A1, A2> >* t =
3896 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
3897 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3898 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3899 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3900 }
3901
3902 template <typename R, typename P1, typename P2, typename P3, typename P4,
3903 typename P5, typename A1, typename A2, typename X1, typename X2,
3904 typename X3, typename X4, typename X5>
3905 inline MutantFunctor<R, Tuple2<A1, A2> >
3906 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
3907 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3908 MutantRunner<R, Tuple2<A1, A2> >* t =
3909 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2),
3910 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3911 (function, MakeTuple(p1, p2, p3, p4, p5));
3912 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3913 }
3914
3915 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3916 template <typename R, typename T, typename U, typename P1, typename P2,
3917 typename P3, typename P4, typename P5, typename A1, typename A2,
3918 typename X1, typename X2, typename X3, typename X4, typename X5>
3919 inline MutantFunctor<R, Tuple2<A1, A2> >
3920 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
3921 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3922 MutantRunner<R, Tuple2<A1, A2> >* t =
3923 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
3924 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3925 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3926 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3927 }
3928 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3929
3930 #if defined (OS_WIN)
3931 template <typename R, typename T, typename U, typename P1, typename P2,
3932 typename P3, typename P4, typename P5, typename A1, typename A2,
3933 typename X1, typename X2, typename X3, typename X4, typename X5>
3934 inline MutantFunctor<R, Tuple2<A1, A2> >
3935 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
3936 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3937 MutantRunner<R, Tuple2<A1, A2> >* t =
3938 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
3939 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3940 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3941 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3942 }
3943
3944 template <typename R, typename P1, typename P2, typename P3, typename P4,
3945 typename P5, typename A1, typename A2, typename X1, typename X2,
3946 typename X3, typename X4, typename X5>
3947 inline MutantFunctor<R, Tuple2<A1, A2> >
3948 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
3949 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3950 MutantRunner<R, Tuple2<A1, A2> >* t =
3951 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2),
3952 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3953 (function, MakeTuple(p1, p2, p3, p4, p5));
3954 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3955 }
3956 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3957 template <typename R, typename T, typename U, typename P1, typename P2,
3958 typename P3, typename P4, typename P5, typename A1, typename A2,
3959 typename X1, typename X2, typename X3, typename X4, typename X5>
3960 inline MutantFunctor<R, Tuple2<A1, A2> >
3961 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
3962 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3963 MutantRunner<R, Tuple2<A1, A2> >* t =
3964 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
3965 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
3966 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3967 return MutantFunctor<R, Tuple2<A1, A2> >(t);
3968 }
3969 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
3970 #endif // OS_WIN
3971
3972 // 5 - 3
3973 template <typename R, typename T, typename U, typename P1, typename P2,
3974 typename P3, typename P4, typename P5, typename A1, typename A2,
3975 typename A3, typename X1, typename X2, typename X3, typename X4,
3976 typename X5>
3977 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3978 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
3979 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3980 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3981 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
3982 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
3983 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
3984 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3985 }
3986
3987 template <typename R, typename P1, typename P2, typename P3, typename P4,
3988 typename P5, typename A1, typename A2, typename A3, typename X1,
3989 typename X2, typename X3, typename X4, typename X5>
3990 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
3991 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1,
3992 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
3993 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
3994 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3),
3995 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
3996 (function, MakeTuple(p1, p2, p3, p4, p5));
3997 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
3998 }
3999
4000 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4001 template <typename R, typename T, typename U, typename P1, typename P2,
4002 typename P3, typename P4, typename P5, typename A1, typename A2,
4003 typename A3, typename X1, typename X2, typename X3, typename X4,
4004 typename X5>
4005 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4006 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
4007 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4008 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4009 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
4010 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
4011 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4012 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4013 }
4014 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4015
4016 #if defined (OS_WIN)
4017 template <typename R, typename T, typename U, typename P1, typename P2,
4018 typename P3, typename P4, typename P5, typename A1, typename A2,
4019 typename A3, typename X1, typename X2, typename X3, typename X4,
4020 typename X5>
4021 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4022 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
4023 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4024 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4025 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
4026 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
4027 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4028 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4029 }
4030
4031 template <typename R, typename P1, typename P2, typename P3, typename P4,
4032 typename P5, typename A1, typename A2, typename A3, typename X1,
4033 typename X2, typename X3, typename X4, typename X5>
4034 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4035 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3),
4036 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4037 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4038 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3),
4039 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
4040 (function, MakeTuple(p1, p2, p3, p4, p5));
4041 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4042 }
4043 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4044 template <typename R, typename T, typename U, typename P1, typename P2,
4045 typename P3, typename P4, typename P5, typename A1, typename A2,
4046 typename A3, typename X1, typename X2, typename X3, typename X4,
4047 typename X5>
4048 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4049 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
4050 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4051 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4052 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
4053 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
4054 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4055 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4056 }
4057 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4058 #endif // OS_WIN
4059
4060 // 5 - 4
4061 template <typename R, typename T, typename U, typename P1, typename P2,
4062 typename P3, typename P4, typename P5, typename A1, typename A2,
4063 typename A3, typename A4, typename X1, typename X2, typename X3,
4064 typename X4, typename X5>
4065 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4066 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4067 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4068 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4069 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4070 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4071 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4072 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4073 }
4074
4075 template <typename R, typename P1, typename P2, typename P3, typename P4,
4076 typename P5, typename A1, typename A2, typename A3, typename A4,
4077 typename X1, typename X2, typename X3, typename X4, typename X5>
4078 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4079 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1,
4080 const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4081 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4082 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4083 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4084 (function, MakeTuple(p1, p2, p3, p4, p5));
4085 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4086 }
4087
4088 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4089 template <typename R, typename T, typename U, typename P1, typename P2,
4090 typename P3, typename P4, typename P5, typename A1, typename A2,
4091 typename A3, typename A4, typename X1, typename X2, typename X3,
4092 typename X4, typename X5>
4093 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4094 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4095 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4096 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4097 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4098 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4099 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4100 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4101 }
4102 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4103
4104 #if defined (OS_WIN)
4105 template <typename R, typename T, typename U, typename P1, typename P2,
4106 typename P3, typename P4, typename P5, typename A1, typename A2,
4107 typename A3, typename A4, typename X1, typename X2, typename X3,
4108 typename X4, typename X5>
4109 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4110 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4111 A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4112 const P5& p5) {
4113 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4114 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4115 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4116 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4117 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4118 }
4119
4120 template <typename R, typename P1, typename P2, typename P3, typename P4,
4121 typename P5, typename A1, typename A2, typename A3, typename A4,
4122 typename X1, typename X2, typename X3, typename X4, typename X5>
4123 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4124 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4125 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4126 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4127 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4128 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4129 (function, MakeTuple(p1, p2, p3, p4, p5));
4130 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4131 }
4132 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4133 template <typename R, typename T, typename U, typename P1, typename P2,
4134 typename P3, typename P4, typename P5, typename A1, typename A2,
4135 typename A3, typename A4, typename X1, typename X2, typename X3,
4136 typename X4, typename X5>
4137 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4138 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4139 A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4140 const P5& p5) {
4141 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4142 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
4143 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
4144 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4145 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4146 }
4147 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4148 #endif // OS_WIN
4149
4150 // 5 - 5
4151 template <typename R, typename T, typename U, typename P1, typename P2,
4152 typename P3, typename P4, typename P5, typename A1, typename A2,
4153 typename A3, typename A4, typename A5, typename X1, typename X2,
4154 typename X3, typename X4, typename X5>
4155 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4156 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4157 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4158 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4159 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4160 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4161 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4162 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4163 }
4164
4165 template <typename R, typename P1, typename P2, typename P3, typename P4,
4166 typename P5, typename A1, typename A2, typename A3, typename A4,
4167 typename A5, typename X1, typename X2, typename X3, typename X4,
4168 typename X5>
4169 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4170 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4171 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4172 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4173 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4174 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4175 (function, MakeTuple(p1, p2, p3, p4, p5));
4176 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4177 }
4178
4179 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4180 template <typename R, typename T, typename U, typename P1, typename P2,
4181 typename P3, typename P4, typename P5, typename A1, typename A2,
4182 typename A3, typename A4, typename A5, typename X1, typename X2,
4183 typename X3, typename X4, typename X5>
4184 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4185 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4186 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4187 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4188 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4189 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4190 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4191 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4192 }
4193 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4194
4195 #if defined (OS_WIN)
4196 template <typename R, typename T, typename U, typename P1, typename P2,
4197 typename P3, typename P4, typename P5, typename A1, typename A2,
4198 typename A3, typename A4, typename A5, typename X1, typename X2,
4199 typename X3, typename X4, typename X5>
4200 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4201 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4202 A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4203 const P5& p5) {
4204 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4205 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4206 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4207 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4208 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4209 }
4210
4211 template <typename R, typename P1, typename P2, typename P3, typename P4,
4212 typename P5, typename A1, typename A2, typename A3, typename A4,
4213 typename A5, typename X1, typename X2, typename X3, typename X4,
4214 typename X5>
4215 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4216 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4217 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4218 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4219 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4220 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4221 (function, MakeTuple(p1, p2, p3, p4, p5));
4222 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4223 }
4224 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4225 template <typename R, typename T, typename U, typename P1, typename P2,
4226 typename P3, typename P4, typename P5, typename A1, typename A2,
4227 typename A3, typename A4, typename A5, typename X1, typename X2,
4228 typename X3, typename X4, typename X5>
4229 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4230 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4231 A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4232 const P5& p5) {
4233 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4234 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
4235 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
4236 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4237 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4238 }
4239 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4240 #endif // OS_WIN
4241
4242 // 5 - 6
4243 template <typename R, typename T, typename U, typename P1, typename P2,
4244 typename P3, typename P4, typename P5, typename A1, typename A2,
4245 typename A3, typename A4, typename A5, typename A6, typename X1,
4246 typename X2, typename X3, typename X4, typename X5>
4247 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4248 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
4249 A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4250 const P5& p5) {
4251 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4252 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4253 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4254 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4255 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4256 }
4257
4258 template <typename R, typename P1, typename P2, typename P3, typename P4,
4259 typename P5, typename A1, typename A2, typename A3, typename A4,
4260 typename A5, typename A6, typename X1, typename X2, typename X3,
4261 typename X4, typename X5>
4262 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4263 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4264 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
4265 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4266 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4267 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4268 (function, MakeTuple(p1, p2, p3, p4, p5));
4269 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4270 }
4271
4272 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4273 template <typename R, typename T, typename U, typename P1, typename P2,
4274 typename P3, typename P4, typename P5, typename A1, typename A2,
4275 typename A3, typename A4, typename A5, typename A6, typename X1,
4276 typename X2, typename X3, typename X4, typename X5>
4277 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4278 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
4279 A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4280 const P5& p5) {
4281 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4282 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4283 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4284 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4285 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4286 }
4287 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4288
4289 #if defined (OS_WIN)
4290 template <typename R, typename T, typename U, typename P1, typename P2,
4291 typename P3, typename P4, typename P5, typename A1, typename A2,
4292 typename A3, typename A4, typename A5, typename A6, typename X1,
4293 typename X2, typename X3, typename X4, typename X5>
4294 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4295 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4296 A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4297 const P5& p5) {
4298 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4299 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4300 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4301 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4302 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4303 }
4304
4305 template <typename R, typename P1, typename P2, typename P3, typename P4,
4306 typename P5, typename A1, typename A2, typename A3, typename A4,
4307 typename A5, typename A6, typename X1, typename X2, typename X3,
4308 typename X4, typename X5>
4309 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4310 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
4311 A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4312 const P5& p5) {
4313 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4314 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4315 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4316 (function, MakeTuple(p1, p2, p3, p4, p5));
4317 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4318 }
4319 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4320 template <typename R, typename T, typename U, typename P1, typename P2,
4321 typename P3, typename P4, typename P5, typename A1, typename A2,
4322 typename A3, typename A4, typename A5, typename A6, typename X1,
4323 typename X2, typename X3, typename X4, typename X5>
4324 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4325 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
4326 A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4327 const P5& p5) {
4328 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4329 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
4330 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
4331 (obj, method, MakeTuple(p1, p2, p3, p4, p5));
4332 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4333 }
4334 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4335 #endif // OS_WIN
4336
4337 // 6 - 0
4338 template <typename R, typename T, typename U, typename P1, typename P2,
4339 typename P3, typename P4, typename P5, typename P6, typename X1,
4340 typename X2, typename X3, typename X4, typename X5, typename X6>
4341 inline MutantFunctor<R, Tuple0>
4342 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
4343 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4344 MutantRunner<R, Tuple0>* t =
4345 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
4346 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4347 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4348 return MutantFunctor<R, Tuple0>(t);
4349 }
4350
4351 template <typename R, typename P1, typename P2, typename P3, typename P4,
4352 typename P5, typename P6, typename X1, typename X2, typename X3,
4353 typename X4, typename X5, typename X6>
4354 inline MutantFunctor<R, Tuple0>
4355 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2,
4356 const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4357 MutantRunner<R, Tuple0>* t =
4358 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6),
4359 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4360 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4361 return MutantFunctor<R, Tuple0>(t);
4362 }
4363
4364 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4365 template <typename R, typename T, typename U, typename P1, typename P2,
4366 typename P3, typename P4, typename P5, typename P6, typename X1,
4367 typename X2, typename X3, typename X4, typename X5, typename X6>
4368 inline MutantFunctor<R, Tuple0>
4369 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
4370 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4371 MutantRunner<R, Tuple0>* t =
4372 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
4373 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4374 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4375 return MutantFunctor<R, Tuple0>(t);
4376 }
4377 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4378
4379 #if defined (OS_WIN)
4380 template <typename R, typename T, typename U, typename P1, typename P2,
4381 typename P3, typename P4, typename P5, typename P6, typename X1,
4382 typename X2, typename X3, typename X4, typename X5, typename X6>
4383 inline MutantFunctor<R, Tuple0>
4384 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
4385 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4386 const P6& p6) {
4387 MutantRunner<R, Tuple0>* t =
4388 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
4389 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4390 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4391 return MutantFunctor<R, Tuple0>(t);
4392 }
4393
4394 template <typename R, typename P1, typename P2, typename P3, typename P4,
4395 typename P5, typename P6, typename X1, typename X2, typename X3,
4396 typename X4, typename X5, typename X6>
4397 inline MutantFunctor<R, Tuple0>
4398 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6), const P1& p1,
4399 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4400 MutantRunner<R, Tuple0>* t =
4401 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6),
4402 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4403 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4404 return MutantFunctor<R, Tuple0>(t);
4405 }
4406 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4407 template <typename R, typename T, typename U, typename P1, typename P2,
4408 typename P3, typename P4, typename P5, typename P6, typename X1,
4409 typename X2, typename X3, typename X4, typename X5, typename X6>
4410 inline MutantFunctor<R, Tuple0>
4411 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
4412 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4413 const P6& p6) {
4414 MutantRunner<R, Tuple0>* t =
4415 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
4416 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
4417 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4418 return MutantFunctor<R, Tuple0>(t);
4419 }
4420 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4421 #endif // OS_WIN
4422
4423 // 6 - 1
4424 template <typename R, typename T, typename U, typename P1, typename P2,
4425 typename P3, typename P4, typename P5, typename P6, typename A1,
4426 typename X1, typename X2, typename X3, typename X4, typename X5,
4427 typename X6>
4428 inline MutantFunctor<R, Tuple1<A1> >
4429 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
4430 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4431 MutantRunner<R, Tuple1<A1> >* t =
4432 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
4433 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4434 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4435 return MutantFunctor<R, Tuple1<A1> >(t);
4436 }
4437
4438 template <typename R, typename P1, typename P2, typename P3, typename P4,
4439 typename P5, typename P6, typename A1, typename X1, typename X2,
4440 typename X3, typename X4, typename X5, typename X6>
4441 inline MutantFunctor<R, Tuple1<A1> >
4442 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
4443 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4444 MutantRunner<R, Tuple1<A1> >* t =
4445 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1),
4446 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4447 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4448 return MutantFunctor<R, Tuple1<A1> >(t);
4449 }
4450
4451 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4452 template <typename R, typename T, typename U, typename P1, typename P2,
4453 typename P3, typename P4, typename P5, typename P6, typename A1,
4454 typename X1, typename X2, typename X3, typename X4, typename X5,
4455 typename X6>
4456 inline MutantFunctor<R, Tuple1<A1> >
4457 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
4458 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4459 MutantRunner<R, Tuple1<A1> >* t =
4460 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
4461 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4462 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4463 return MutantFunctor<R, Tuple1<A1> >(t);
4464 }
4465 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4466
4467 #if defined (OS_WIN)
4468 template <typename R, typename T, typename U, typename P1, typename P2,
4469 typename P3, typename P4, typename P5, typename P6, typename A1,
4470 typename X1, typename X2, typename X3, typename X4, typename X5,
4471 typename X6>
4472 inline MutantFunctor<R, Tuple1<A1> >
4473 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
4474 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4475 const P6& p6) {
4476 MutantRunner<R, Tuple1<A1> >* t =
4477 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
4478 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4479 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4480 return MutantFunctor<R, Tuple1<A1> >(t);
4481 }
4482
4483 template <typename R, typename P1, typename P2, typename P3, typename P4,
4484 typename P5, typename P6, typename A1, typename X1, typename X2,
4485 typename X3, typename X4, typename X5, typename X6>
4486 inline MutantFunctor<R, Tuple1<A1> >
4487 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
4488 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4489 MutantRunner<R, Tuple1<A1> >* t =
4490 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1),
4491 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4492 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4493 return MutantFunctor<R, Tuple1<A1> >(t);
4494 }
4495 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4496 template <typename R, typename T, typename U, typename P1, typename P2,
4497 typename P3, typename P4, typename P5, typename P6, typename A1,
4498 typename X1, typename X2, typename X3, typename X4, typename X5,
4499 typename X6>
4500 inline MutantFunctor<R, Tuple1<A1> >
4501 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
4502 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4503 const P6& p6) {
4504 MutantRunner<R, Tuple1<A1> >* t =
4505 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
4506 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
4507 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4508 return MutantFunctor<R, Tuple1<A1> >(t);
4509 }
4510 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4511 #endif // OS_WIN
4512
4513 // 6 - 2
4514 template <typename R, typename T, typename U, typename P1, typename P2,
4515 typename P3, typename P4, typename P5, typename P6, typename A1,
4516 typename A2, typename X1, typename X2, typename X3, typename X4,
4517 typename X5, typename X6>
4518 inline MutantFunctor<R, Tuple2<A1, A2> >
4519 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
4520 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4521 const P6& p6) {
4522 MutantRunner<R, Tuple2<A1, A2> >* t =
4523 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
4524 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4525 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4526 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4527 }
4528
4529 template <typename R, typename P1, typename P2, typename P3, typename P4,
4530 typename P5, typename P6, typename A1, typename A2, typename X1,
4531 typename X2, typename X3, typename X4, typename X5, typename X6>
4532 inline MutantFunctor<R, Tuple2<A1, A2> >
4533 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1,
4534 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4535 MutantRunner<R, Tuple2<A1, A2> >* t =
4536 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2),
4537 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4538 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4539 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4540 }
4541
4542 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4543 template <typename R, typename T, typename U, typename P1, typename P2,
4544 typename P3, typename P4, typename P5, typename P6, typename A1,
4545 typename A2, typename X1, typename X2, typename X3, typename X4,
4546 typename X5, typename X6>
4547 inline MutantFunctor<R, Tuple2<A1, A2> >
4548 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
4549 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4550 const P6& p6) {
4551 MutantRunner<R, Tuple2<A1, A2> >* t =
4552 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
4553 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4554 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4555 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4556 }
4557 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4558
4559 #if defined (OS_WIN)
4560 template <typename R, typename T, typename U, typename P1, typename P2,
4561 typename P3, typename P4, typename P5, typename P6, typename A1,
4562 typename A2, typename X1, typename X2, typename X3, typename X4,
4563 typename X5, typename X6>
4564 inline MutantFunctor<R, Tuple2<A1, A2> >
4565 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
4566 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4567 const P6& p6) {
4568 MutantRunner<R, Tuple2<A1, A2> >* t =
4569 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
4570 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4571 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4572 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4573 }
4574
4575 template <typename R, typename P1, typename P2, typename P3, typename P4,
4576 typename P5, typename P6, typename A1, typename A2, typename X1,
4577 typename X2, typename X3, typename X4, typename X5, typename X6>
4578 inline MutantFunctor<R, Tuple2<A1, A2> >
4579 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2),
4580 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4581 const P6& p6) {
4582 MutantRunner<R, Tuple2<A1, A2> >* t =
4583 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2),
4584 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4585 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4586 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4587 }
4588 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4589 template <typename R, typename T, typename U, typename P1, typename P2,
4590 typename P3, typename P4, typename P5, typename P6, typename A1,
4591 typename A2, typename X1, typename X2, typename X3, typename X4,
4592 typename X5, typename X6>
4593 inline MutantFunctor<R, Tuple2<A1, A2> >
4594 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
4595 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4596 const P6& p6) {
4597 MutantRunner<R, Tuple2<A1, A2> >* t =
4598 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
4599 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
4600 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4601 return MutantFunctor<R, Tuple2<A1, A2> >(t);
4602 }
4603 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4604 #endif // OS_WIN
4605
4606 // 6 - 3
4607 template <typename R, typename T, typename U, typename P1, typename P2,
4608 typename P3, typename P4, typename P5, typename P6, typename A1,
4609 typename A2, typename A3, typename X1, typename X2, typename X3,
4610 typename X4, typename X5, typename X6>
4611 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4612 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4613 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4614 const P6& p6) {
4615 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4616 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4617 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4618 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4619 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4620 }
4621
4622 template <typename R, typename P1, typename P2, typename P3, typename P4,
4623 typename P5, typename P6, typename A1, typename A2, typename A3,
4624 typename X1, typename X2, typename X3, typename X4, typename X5,
4625 typename X6>
4626 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4627 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1,
4628 const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
4629 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4630 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4631 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4632 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4633 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4634 }
4635
4636 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4637 template <typename R, typename T, typename U, typename P1, typename P2,
4638 typename P3, typename P4, typename P5, typename P6, typename A1,
4639 typename A2, typename A3, typename X1, typename X2, typename X3,
4640 typename X4, typename X5, typename X6>
4641 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4642 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4643 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4644 const P6& p6) {
4645 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4646 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4647 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4648 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4649 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4650 }
4651 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4652
4653 #if defined (OS_WIN)
4654 template <typename R, typename T, typename U, typename P1, typename P2,
4655 typename P3, typename P4, typename P5, typename P6, typename A1,
4656 typename A2, typename A3, typename X1, typename X2, typename X3,
4657 typename X4, typename X5, typename X6>
4658 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4659 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4660 A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4661 const P6& p6) {
4662 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4663 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4664 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4665 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4666 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4667 }
4668
4669 template <typename R, typename P1, typename P2, typename P3, typename P4,
4670 typename P5, typename P6, typename A1, typename A2, typename A3,
4671 typename X1, typename X2, typename X3, typename X4, typename X5,
4672 typename X6>
4673 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4674 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4675 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4676 const P6& p6) {
4677 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4678 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4679 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4680 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4681 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4682 }
4683 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4684 template <typename R, typename T, typename U, typename P1, typename P2,
4685 typename P3, typename P4, typename P5, typename P6, typename A1,
4686 typename A2, typename A3, typename X1, typename X2, typename X3,
4687 typename X4, typename X5, typename X6>
4688 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
4689 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4690 A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4691 const P6& p6) {
4692 MutantRunner<R, Tuple3<A1, A2, A3> >* t =
4693 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
4694 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
4695 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4696 return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
4697 }
4698 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4699 #endif // OS_WIN
4700
4701 // 6 - 4
4702 template <typename R, typename T, typename U, typename P1, typename P2,
4703 typename P3, typename P4, typename P5, typename P6, typename A1,
4704 typename A2, typename A3, typename A4, typename X1, typename X2,
4705 typename X3, typename X4, typename X5, typename X6>
4706 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4707 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4708 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4709 const P6& p6) {
4710 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4711 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4712 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4713 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4714 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4715 }
4716
4717 template <typename R, typename P1, typename P2, typename P3, typename P4,
4718 typename P5, typename P6, typename A1, typename A2, typename A3,
4719 typename A4, typename X1, typename X2, typename X3, typename X4,
4720 typename X5, typename X6>
4721 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4722 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4723 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4724 const P6& p6) {
4725 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4726 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4727 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4728 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4729 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4730 }
4731
4732 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4733 template <typename R, typename T, typename U, typename P1, typename P2,
4734 typename P3, typename P4, typename P5, typename P6, typename A1,
4735 typename A2, typename A3, typename A4, typename X1, typename X2,
4736 typename X3, typename X4, typename X5, typename X6>
4737 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4738 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4739 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4740 const P6& p6) {
4741 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4742 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4743 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4744 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4745 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4746 }
4747 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4748
4749 #if defined (OS_WIN)
4750 template <typename R, typename T, typename U, typename P1, typename P2,
4751 typename P3, typename P4, typename P5, typename P6, typename A1,
4752 typename A2, typename A3, typename A4, typename X1, typename X2,
4753 typename X3, typename X4, typename X5, typename X6>
4754 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4755 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4756 A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4757 const P5& p5, const P6& p6) {
4758 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4759 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4760 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4761 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4762 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4763 }
4764
4765 template <typename R, typename P1, typename P2, typename P3, typename P4,
4766 typename P5, typename P6, typename A1, typename A2, typename A3,
4767 typename A4, typename X1, typename X2, typename X3, typename X4,
4768 typename X5, typename X6>
4769 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4770 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4771 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4772 const P6& p6) {
4773 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4774 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4775 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4776 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4777 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4778 }
4779 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4780 template <typename R, typename T, typename U, typename P1, typename P2,
4781 typename P3, typename P4, typename P5, typename P6, typename A1,
4782 typename A2, typename A3, typename A4, typename X1, typename X2,
4783 typename X3, typename X4, typename X5, typename X6>
4784 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
4785 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4786 A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4787 const P5& p5, const P6& p6) {
4788 MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
4789 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
4790 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
4791 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4792 return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
4793 }
4794 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4795 #endif // OS_WIN
4796
4797 // 6 - 5
4798 template <typename R, typename T, typename U, typename P1, typename P2,
4799 typename P3, typename P4, typename P5, typename P6, typename A1,
4800 typename A2, typename A3, typename A4, typename A5, typename X1,
4801 typename X2, typename X3, typename X4, typename X5, typename X6>
4802 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4803 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
4804 A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4805 const P6& p6) {
4806 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4807 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4808 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4809 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4810 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4811 }
4812
4813 template <typename R, typename P1, typename P2, typename P3, typename P4,
4814 typename P5, typename P6, typename A1, typename A2, typename A3,
4815 typename A4, typename A5, typename X1, typename X2, typename X3,
4816 typename X4, typename X5, typename X6>
4817 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4818 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4819 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4820 const P6& p6) {
4821 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4822 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4823 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4824 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4825 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4826 }
4827
4828 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4829 template <typename R, typename T, typename U, typename P1, typename P2,
4830 typename P3, typename P4, typename P5, typename P6, typename A1,
4831 typename A2, typename A3, typename A4, typename A5, typename X1,
4832 typename X2, typename X3, typename X4, typename X5, typename X6>
4833 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4834 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
4835 A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4836 const P6& p6) {
4837 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4838 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4839 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4840 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4841 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4842 }
4843 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4844
4845 #if defined (OS_WIN)
4846 template <typename R, typename T, typename U, typename P1, typename P2,
4847 typename P3, typename P4, typename P5, typename P6, typename A1,
4848 typename A2, typename A3, typename A4, typename A5, typename X1,
4849 typename X2, typename X3, typename X4, typename X5, typename X6>
4850 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4851 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4852 A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4853 const P5& p5, const P6& p6) {
4854 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4855 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4856 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4857 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4858 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4859 }
4860
4861 template <typename R, typename P1, typename P2, typename P3, typename P4,
4862 typename P5, typename P6, typename A1, typename A2, typename A3,
4863 typename A4, typename A5, typename X1, typename X2, typename X3,
4864 typename X4, typename X5, typename X6>
4865 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4866 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
4867 A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4868 const P6& p6) {
4869 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4870 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4871 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4872 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4873 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4874 }
4875 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4876 template <typename R, typename T, typename U, typename P1, typename P2,
4877 typename P3, typename P4, typename P5, typename P6, typename A1,
4878 typename A2, typename A3, typename A4, typename A5, typename X1,
4879 typename X2, typename X3, typename X4, typename X5, typename X6>
4880 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
4881 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4882 A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4883 const P5& p5, const P6& p6) {
4884 MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
4885 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
4886 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
4887 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4888 return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
4889 }
4890 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4891 #endif // OS_WIN
4892
4893 // 6 - 6
4894 template <typename R, typename T, typename U, typename P1, typename P2,
4895 typename P3, typename P4, typename P5, typename P6, typename A1,
4896 typename A2, typename A3, typename A4, typename A5, typename A6,
4897 typename X1, typename X2, typename X3, typename X4, typename X5,
4898 typename X6>
4899 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4900 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
4901 A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4902 const P6& p6) {
4903 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4904 new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4905 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4906 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4907 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4908 }
4909
4910 template <typename R, typename P1, typename P2, typename P3, typename P4,
4911 typename P5, typename P6, typename A1, typename A2, typename A3,
4912 typename A4, typename A5, typename A6, typename X1, typename X2,
4913 typename X3, typename X4, typename X5, typename X6>
4914 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4915 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4916 const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4917 const P6& p6) {
4918 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4919 new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4920 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4921 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4922 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4923 }
4924
4925 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4926 template <typename R, typename T, typename U, typename P1, typename P2,
4927 typename P3, typename P4, typename P5, typename P6, typename A1,
4928 typename A2, typename A3, typename A4, typename A5, typename A6,
4929 typename X1, typename X2, typename X3, typename X4, typename X5,
4930 typename X6>
4931 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4932 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
4933 A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
4934 const P6& p6) {
4935 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4936 new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4937 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4938 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4939 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4940 }
4941 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4942
4943 #if defined (OS_WIN)
4944 template <typename R, typename T, typename U, typename P1, typename P2,
4945 typename P3, typename P4, typename P5, typename P6, typename A1,
4946 typename A2, typename A3, typename A4, typename A5, typename A6,
4947 typename X1, typename X2, typename X3, typename X4, typename X5,
4948 typename X6>
4949 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4950 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4951 A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4952 const P5& p5, const P6& p6) {
4953 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4954 new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4955 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4956 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4957 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4958 }
4959
4960 template <typename R, typename P1, typename P2, typename P3, typename P4,
4961 typename P5, typename P6, typename A1, typename A2, typename A3,
4962 typename A4, typename A5, typename A6, typename X1, typename X2,
4963 typename X3, typename X4, typename X5, typename X6>
4964 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4965 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
4966 A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4967 const P5& p5, const P6& p6) {
4968 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4969 new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4970 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4971 (function, MakeTuple(p1, p2, p3, p4, p5, p6));
4972 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4973 }
4974 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4975 template <typename R, typename T, typename U, typename P1, typename P2,
4976 typename P3, typename P4, typename P5, typename P6, typename A1,
4977 typename A2, typename A3, typename A4, typename A5, typename A6,
4978 typename X1, typename X2, typename X3, typename X4, typename X5,
4979 typename X6>
4980 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
4981 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
4982 A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
4983 const P5& p5, const P6& p6) {
4984 MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
4985 new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
4986 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
4987 (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
4988 return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
4989 }
4990 #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
4991 #endif // OS_WIN
4992
4993 } // namespace testing
4994
4995 #endif // TESTING_GMOCK_MUTANT_H_

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial