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