Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(732)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: testing/gmock_mutant.h

Issue 604014: First batch of context menu tests... (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: '' Created 10 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« testing/generate_gmock_mutant.py ('K') | « testing/generate_gmock_mutant.py ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: testing/gmock_mutant.h
===================================================================
--- testing/gmock_mutant.h (revision 38776)
+++ testing/gmock_mutant.h (working copy)
@@ -181,6 +181,38 @@
return (*function)(c.a, c.b, c.c, c.d);
}
+// 0 - 5
+template <typename R, typename T, typename Method, typename C1, typename C2,
+ typename C3, typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple0& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename C1, typename C2, typename C3,
+ typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple0& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(c.a, c.b, c.c, c.d, c.e);
+}
+
+// 0 - 6
+template <typename R, typename T, typename Method, typename C1, typename C2,
+ typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple0& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename C1, typename C2, typename C3,
+ typename C4, typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple0& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
// 1 - 0
template <typename R, typename T, typename Method, typename P1>
inline R DispatchToMethod(T* obj, Method method,
@@ -256,6 +288,38 @@
return (*function)(p.a, c.a, c.b, c.c, c.d);
}
+// 1 - 5
+template <typename R, typename T, typename Method, typename P1, typename C1,
+ typename C2, typename C3, typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple1<P1>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename C1, typename C2,
+ typename C3, typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple1<P1>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 1 - 6
+template <typename R, typename T, typename Method, typename P1, typename C1,
+ typename C2, typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple1<P1>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename C1, typename C2,
+ typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple1<P1>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
// 2 - 0
template <typename R, typename T, typename Method, typename P1, typename P2>
inline R DispatchToMethod(T* obj, Method method,
@@ -333,6 +397,39 @@
return (*function)(p.a, p.b, c.a, c.b, c.c, c.d);
}
+// 2 - 5
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename C1, typename C2, typename C3, typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple2<P1, P2>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename C1,
+ typename C2, typename C3, typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple2<P1, P2>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 2 - 6
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename C1, typename C2, typename C3, typename C4, typename C5,
+ typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple2<P1, P2>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename C1,
+ typename C2, typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple2<P1, P2>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
// 3 - 0
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3>
@@ -412,6 +509,41 @@
return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
}
+// 3 - 5
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename C1, typename C2, typename C3, typename C4,
+ typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple3<P1, P2, P3>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename C1, typename C2, typename C3, typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple3<P1, P2, P3>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 3 - 6
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename C1, typename C2, typename C3, typename C4,
+ typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple3<P1, P2, P3>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename C1, typename C2, typename C3, typename C4, typename C5,
+ typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple3<P1, P2, P3>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
// 4 - 0
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4>
@@ -493,6 +625,282 @@
return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
}
+// 4 - 5
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename C1, typename C2, typename C3,
+ typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple4<P1, P2, P3, P4>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename C1, typename C2, typename C3, typename C4,
+ typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple4<P1, P2, P3, P4>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 4 - 6
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename C1, typename C2, typename C3,
+ typename C4, typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple4<P1, P2, P3, P4>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename C1, typename C2, typename C3, typename C4,
+ typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple4<P1, P2, P3, P4>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
+// 5 - 0
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple0& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple0& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e);
+}
+
+// 5 - 1
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple1<C1>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple1<C1>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a);
+}
+
+// 5 - 2
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1, typename C2>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple2<C1, C2>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1, typename C2>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple2<C1, C2>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
+}
+
+// 5 - 3
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1, typename C2,
+ typename C3>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple3<C1, C2, C3>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1, typename C2, typename C3>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple3<C1, C2, C3>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
+}
+
+// 5 - 4
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1, typename C2,
+ typename C3, typename C4>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple4<C1, C2, C3, C4>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1, typename C2, typename C3,
+ typename C4>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple4<C1, C2, C3, C4>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
+}
+
+// 5 - 5
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1, typename C2,
+ typename C3, typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1, typename C2, typename C3,
+ typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 5 - 6
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename C1, typename C2,
+ typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename C1, typename C2, typename C3,
+ typename C4, typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple5<P1, P2, P3, P4, P5>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
+// 6 - 0
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple0& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple0& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f);
+}
+
+// 6 - 1
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple1<C1>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple1<C1>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
+}
+
+// 6 - 2
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1,
+ typename C2>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple2<C1, C2>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1, typename C2>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple2<C1, C2>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
+}
+
+// 6 - 3
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1,
+ typename C2, typename C3>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple3<C1, C2, C3>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1, typename C2,
+ typename C3>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple3<C1, C2, C3>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
+}
+
+// 6 - 4
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1,
+ typename C2, typename C3, typename C4>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple4<C1, C2, C3, C4>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1, typename C2,
+ typename C3, typename C4>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple4<C1, C2, C3, C4>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
+}
+
+// 6 - 5
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1,
+ typename C2, typename C3, typename C4, typename C5>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1, typename C2,
+ typename C3, typename C4, typename C5>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple5<C1, C2, C3, C4, C5>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
+}
+
+// 6 - 6
+template <typename R, typename T, typename Method, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename C1,
+ typename C2, typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToMethod(T* obj, Method method,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+template <typename R, typename Function, typename P1, typename P2, typename P3,
+ typename P4, typename P5, typename P6, typename C1, typename C2,
+ typename C3, typename C4, typename C5, typename C6>
+inline R DispatchToFunction(Function function,
+ const Tuple6<P1, P2, P3, P4, P5, P6>& p,
+ const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
+}
+
// Interface that is exposed to the consumer, that does the actual calling
// of the method.
template <typename R, typename Params>
@@ -945,6 +1353,150 @@
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // OS_WIN
+// 0 - 5
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+ typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+ typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
+ Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 0 - 6
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
+ Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple());
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
// 1 - 0
template <typename R, typename T, typename U, typename P1, typename X1>
inline MutantFunctor<R, Tuple0>
@@ -1297,6 +1849,161 @@
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // OS_WIN
+// 1 - 5
+template <typename R, typename T, typename U, typename P1, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
+ const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
+ const P1& p1) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
+ Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 1 - 6
+template <typename R, typename T, typename U, typename P1, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
+ const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6,
+ typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
+ const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
+ const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6),
+ const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6,
+ typename X1>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
+ const P1& p1) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
+ Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
// 2 - 0
template <typename R, typename T, typename U, typename P1, typename P2,
typename X1, typename X2>
@@ -1680,6 +2387,172 @@
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // OS_WIN
+// 2 - 5
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5,
+ typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5,
+ typename X1, typename X2>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
+ Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 2 - 6
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename X1, typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1,
+ const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5,
+ typename A6, typename X1, typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename X1, typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5,
+ typename A6, typename X1, typename X2>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+ Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
// 3 - 0
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename X1, typename X2, typename X3>
@@ -2084,6 +2957,174 @@
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // OS_WIN
+// 3 - 5
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+ Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 3 - 6
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1,
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+ Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
// 4 - 0
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename X1, typename X2, typename X3,
@@ -2500,6 +3541,1455 @@
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // OS_WIN
+// 4 - 5
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1, typename X2, typename X3,
+ typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1, typename X2, typename X3,
+ typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1, typename X2, typename X3,
+ typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(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 A5, typename X1, typename X2, typename X3,
+ typename X4>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+ Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 4 - 6
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(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 A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
+ Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 0
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple0>(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2,
+ const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple0>(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple0>(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple0>(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 1
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2,
+ const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 2
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 3
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename A3, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename A3, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 4
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename A3, typename A4, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename X1, typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ 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 P5, typename A1, typename A2,
+ typename A3, typename A4, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 5
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename X1, typename X2, typename X3, typename X4,
+ typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename X1, typename X2,
+ typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 5 - 6
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename A1, typename A2, typename A3, typename A4,
+ typename A5, typename A6, typename X1, typename X2, typename X3,
+ typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename A1, typename A2,
+ typename A3, typename A4, typename A5, typename A6, typename X1,
+ typename X2, typename X3, typename X4, typename X5>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
+ A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
+ Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 0
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple0>(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2,
+ const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple0>(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple0>(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple0>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple0>(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 1
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple1<A1> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 2
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple2<A1, A2> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 3
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1,
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename A3, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename A3, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 4
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename X1, typename X2, typename X3, typename X4,
+ typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ 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 P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 5
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename X1, typename X2, typename X3,
+ typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename X1,
+ typename X2, typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
+// 6 - 6
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+
+template <typename R, typename P1, typename P2, typename P3, typename P4,
+ typename P5, typename P6, typename A1, typename A2, typename A3,
+ typename A4, typename A5, typename A6, typename X1, typename X2,
+ typename X3, typename X4, typename X5, typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+ typename P3, typename P4, typename P5, typename P6, typename A1,
+ typename A2, typename A3, typename A4, typename A5, typename A6,
+ typename X1, typename X2, typename X3, typename X4, typename X5,
+ typename X6>
+inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
+ A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
+ Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+ (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif // OS_WIN
+
} // namespace testing
#endif // TESTING_GMOCK_MUTANT_H_
« testing/generate_gmock_mutant.py ('K') | « testing/generate_gmock_mutant.py ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698