Functor for functions with STDCALL calling conventions. Allows invoking Windo...

testing/gmock_mutant.h

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file automatically generated by testing/generate_gmock_mutant.py.
 // DO NOT EDIT.
 
 #ifndef TESTING_GMOCK_MUTANT_H_
 #define TESTING_GMOCK_MUTANT_H_
 
@@ skipping 632 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)()) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(),
                  Tuple0, Tuple0>
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple0>(t);
 }
+
+template <typename R>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)()) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantFunction<R, R (__stdcall *)(),
+                         Tuple0, Tuple0>
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple0>(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (__stdcall U::*method)()) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(),
                                Tuple0, Tuple0>
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple0>(t);
 }
@@ skipping 36 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename A1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1),
                  Tuple0, Tuple1<A1> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+
+template <typename R, typename A1>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(A1)) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantFunction<R, R (__stdcall *)(A1),
+                         Tuple0, Tuple1<A1> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1),
                                Tuple0, Tuple1<A1> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
@@ skipping 36 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2),
                  Tuple0, Tuple2<A1, A2> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+
+template <typename R, typename A1, typename A2>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(A1, A2)) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantFunction<R, R (__stdcall *)(A1, A2),
+                         Tuple0, Tuple2<A1, A2> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2),
                                Tuple0, Tuple2<A1, A2> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
@@ skipping 39 matching lines @@
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3),
                  Tuple0, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+
+template <typename R, typename A1, typename A2, typename A3>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3)) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantFunction<R, R (__stdcall *)(A1, A2, A3),
+                         Tuple0, Tuple3<A1, A2, A3> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3),
                                Tuple0, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
@@ skipping 40 matching lines @@
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
                  Tuple0, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4),
+                         Tuple0, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
                                Tuple0, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
@@ skipping 37 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename P1, typename X1>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1),
                  Tuple1<P1>, Tuple0>
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple0>(t);
 }
+
+template <typename R, typename P1, typename X1>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1), const P1& p1) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantFunction<R, R (__stdcall *)(X1),
+                         Tuple1<P1>, Tuple0>
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple0>(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename X1>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1),
                                Tuple1<P1>, Tuple0>
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple0>(t);
 }
@@ skipping 39 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1),
                  Tuple1<P1>, Tuple1<A1> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+
+template <typename R, typename P1, typename A1, typename X1>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, A1),
+                         Tuple1<P1>, Tuple1<A1> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1),
                                Tuple1<P1>, Tuple1<A1> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple1<A1> >(t);
@@ skipping 40 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2),
                  Tuple1<P1>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+
+template <typename R, typename P1, typename A1, typename A2, typename X1>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, A1, A2),
+                         Tuple1<P1>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2),
                                Tuple1<P1>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
@@ skipping 41 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
                  Tuple1<P1>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+          typename X1>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3),
+                         Tuple1<P1>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
                                Tuple1<P1>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
@@ skipping 42 matching lines @@
           typename A2, typename A3, typename A4, typename X1>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
     const P1& p1) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
                  Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+          typename A4, typename X1>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4),
+                         Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
     const P1& p1) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
                                Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1));
@@ skipping 42 matching lines @@
           typename X1, typename X2>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2),
                  Tuple2<P1, P2>, Tuple0>
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple0>(t);
 }
+
+template <typename R, typename P1, typename P2, typename X1, typename X2>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2),
+                         Tuple2<P1, P2>, Tuple0>
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple0>(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2),
                                Tuple2<P1, P2>, Tuple0>
           (obj, method, MakeTuple(p1, p2));
@@ skipping 43 matching lines @@
           typename A1, typename X1, typename X2>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1),
                  Tuple2<P1, P2>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename A1, typename X1,
+          typename X2>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1),
+                         Tuple2<P1, P2>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1),
                                Tuple2<P1, P2>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2));
@@ skipping 45 matching lines @@
           typename A1, typename A2, typename X1, typename X2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
                  Tuple2<P1, P2>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+          typename X1, typename X2>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2),
+                         Tuple2<P1, P2>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
                                Tuple2<P1, P2>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2));
@@ skipping 45 matching lines @@
           typename A1, typename A2, typename A3, typename X1, typename X2>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
                  Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+          typename A3, typename X1, typename X2>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3),
+                         Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
                                Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2));
@@ skipping 49 matching lines @@
           typename X2>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
                  Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+          typename A3, typename A4, typename X1, typename X2>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4),
+                         Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
                                Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
@@ skipping 47 matching lines @@
           typename P3, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3),
                  Tuple3<P1, P2, P3>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3));
   return MutantFunctor<R, Tuple0>(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename X1,
+          typename X2, typename X3>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2,
+    const P3& p3) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3),
+                         Tuple3<P1, P2, P3>, Tuple0>
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple0>(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3),
                                Tuple3<P1, P2, P3>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3));
@@ skipping 46 matching lines @@
           typename P3, typename A1, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
                  Tuple3<P1, P2, P3>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2, p3));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+          typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1),
+                         Tuple3<P1, P2, P3>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
                                Tuple3<P1, P2, P3>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2, p3));
@@ skipping 49 matching lines @@
           typename X3>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
                  Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2, p3));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+          typename A2, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2),
+                         Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
                                Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
@@ skipping 50 matching lines @@
           typename X2, typename X3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
                  Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2, p3));
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+          typename A2, typename A3, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3),
+                         Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
                                Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
@@ skipping 51 matching lines @@
           typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
                  Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2, p3));
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+          typename A2, typename A3, typename A4, typename X1, typename X2,
+          typename X3>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4),
+                         Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
                                Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
@@ skipping 50 matching lines @@
           typename X4>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
                  Tuple4<P1, P2, P3, P4>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple0>(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+          typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1,
+    const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4),
+                         Tuple4<P1, P2, P3, P4>, Tuple0>
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple0>(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
           typename X4>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
                                Tuple4<P1, P2, P3, P4>, Tuple0>
@@ skipping 50 matching lines @@
           typename X3, typename X4>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
                  Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+          typename A1, typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1,
+    const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1),
+                         Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
                                Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
@@ skipping 51 matching lines @@
           typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
                  Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+          typename A1, typename A2, typename X1, typename X2, typename X3,
+          typename X4>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1,
+    const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2),
+                         Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
                                Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
@@ skipping 51 matching lines @@
           typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
                  Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+          typename A1, typename A2, typename A3, typename X1, typename X2,
+          typename X3, typename X4>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
+    const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3),
+                         Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
                                Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
@@ skipping 51 matching lines @@
           typename A4, typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
                  Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+          typename A1, typename A2, typename A3, typename A4, typename X1,
+          typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4),
+    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4),
+                         Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
                                Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 }  // namespace testing
 
 #endif  // TESTING_GMOCK_MUTANT_H_