testing/gmock_mutant.h

   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_