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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: testing/gmock_mutant.h

Issue 1159553007: Move Tuple to base namespace. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 7 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
« no previous file with comments | « testing/generate_gmock_mutant.py ('k') | tools/ipc_fuzzer/fuzzer/fuzzer.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: testing/gmock_mutant.h
diff --git a/testing/gmock_mutant.h b/testing/gmock_mutant.h
index 964d56b3388ac8af3390c5d980b2cf447639a53d..acc1ae92496294bac622a6ef1a8fc7f07c17513f 100644
--- a/testing/gmock_mutant.h
+++ b/testing/gmock_mutant.h
@@ -104,313 +104,335 @@
//
#include "base/memory/linked_ptr.h"
-#include "base/tuple.h" // for Tuple
+#include "base/tuple.h"
namespace testing {
// 0 - 0
template <typename R, typename T, typename Method>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<>& p,
- const Tuple<>& c) {
+ const base::Tuple<>& p,
+ const base::Tuple<>& c) {
return (obj->*method)();
}
template <typename R, typename Function>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<>& c) {
+ const base::Tuple<>& p,
+ const base::Tuple<>& c) {
return (*function)();
}
// 0 - 1
template <typename R, typename T, typename Method, typename C1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(c));
}
template <typename R, typename Function, typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(c));
}
// 0 - 2
template <typename R, typename T, typename Method, typename C1, typename C2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(c), get<1>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(c), base::get<1>(c));
}
template <typename R, typename Function, typename C1, typename C2>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(c), get<1>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(c), base::get<1>(c));
}
// 0 - 3
template <typename R, typename T, typename Method, typename C1, typename C2,
typename C3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
template <typename R, typename Function, typename C1, typename C2, typename C3>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
// 0 - 4
template <typename R, typename T, typename Method, typename C1, typename C2,
typename C3, typename C4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c));
}
template <typename R, typename Function, typename C1, typename C2, typename C3,
typename C4>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c));
}
// 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 Tuple<>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c));
}
template <typename R, typename Function, typename C1, typename C2, typename C3,
typename C4, typename C5>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c));
}
// 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 Tuple<>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
template <typename R, typename Function, typename C1, typename C2, typename C3,
typename C4, typename C5, typename C6>
inline R DispatchToFunction(Function function,
- const Tuple<>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
// 1 - 0
template <typename R, typename T, typename Method, typename P1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p));
+ const base::Tuple<P1>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p));
}
template <typename R, typename Function, typename P1>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p));
+ const base::Tuple<P1>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p));
}
// 1 - 1
template <typename R, typename T, typename Method, typename P1, typename C1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<0>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c));
}
template <typename R, typename Function, typename P1, typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<0>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c));
}
// 1 - 2
template <typename R, typename T, typename Method, typename P1, typename C1,
typename C2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c));
}
template <typename R, typename Function, typename P1, typename C1, typename C2>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c));
}
// 1 - 3
template <typename R, typename T, typename Method, typename P1, typename C1,
typename C2, typename C3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c));
}
template <typename R, typename Function, typename P1, typename C1, typename C2,
typename C3>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c));
}
// 1 - 4
template <typename R, typename T, typename Method, typename P1, typename C1,
typename C2, typename C3, typename C4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c));
}
template <typename R, typename Function, typename P1, typename C1, typename C2,
typename C3, typename C4>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c));
}
// 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 Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
template <typename R, typename Function, typename P1, typename C1, typename C2,
typename C3, typename C4, typename C5>
inline R DispatchToFunction(Function function,
- const Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
// 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 Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
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 Tuple<P1>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
// 2 - 0
template <typename R, typename T, typename Method, typename P1, typename P2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p), get<1>(p));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p));
}
template <typename R, typename Function, typename P1, typename P2>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p), get<1>(p));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p));
}
// 2 - 1
template <typename R, typename T, typename Method, typename P1, typename P2,
typename C1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c));
}
// 2 - 2
template <typename R, typename T, typename Method, typename P1, typename P2,
typename C1, typename C2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename C1,
typename C2>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c));
}
// 2 - 3
template <typename R, typename T, typename Method, typename P1, typename P2,
typename C1, typename C2, typename C3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename C1,
typename C2, typename C3>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c));
}
// 2 - 4
template <typename R, typename T, typename Method, typename P1, typename P2,
typename C1, typename C2, typename C3, typename C4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename C1,
typename C2, typename C3, typename C4>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
// 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 Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
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 Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
// 2 - 6
@@ -418,95 +440,107 @@ 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 Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c),
+ base::get<5>(c));
}
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 Tuple<P1, P2>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c),
+ base::get<5>(c));
}
// 3 - 0
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p));
}
template <typename R, typename Function, typename P1, typename P2, typename P3>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p));
}
// 3 - 1
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename C1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c));
}
// 3 - 2
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename C1, typename C2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename C1, typename C2>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c));
}
// 3 - 3
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename C1, typename C2, typename C3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename C1, typename C2, typename C3>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
// 3 - 4
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename C1, typename C2, typename C3, typename C4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename C1, typename C2, typename C3, typename C4>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
// 3 - 5
@@ -514,16 +548,20 @@ 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 Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c),
+ base::get<4>(c));
}
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 Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c),
+ base::get<4>(c));
}
// 3 - 6
@@ -531,81 +569,93 @@ 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 Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c),
+ base::get<4>(c), base::get<5>(c));
}
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 Tuple<P1, P2, P3>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c),
+ base::get<4>(c), base::get<5>(c));
}
// 4 - 0
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p));
}
// 4 - 1
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4, typename C1>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c));
}
// 4 - 2
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4, typename C1, typename C2>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename C1, typename C2>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c));
}
// 4 - 3
template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4, typename C1, typename C2, typename C3>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename C1, typename C2, typename C3>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c));
}
// 4 - 4
@@ -613,16 +663,20 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
typename P3, typename P4, typename C1, typename C2, typename C3,
typename C4>
inline R DispatchToMethod(T* obj, Method method,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename C1, typename C2, typename C3, typename C4>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c));
}
// 4 - 5
@@ -630,17 +684,21 @@ 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 Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c));
}
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 Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c));
}
// 4 - 6
@@ -648,65 +706,75 @@ 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 Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
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 Tuple<P1, P2, P3, P4>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c),
+ base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
// 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename P5>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p));
}
// 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename P5, typename C1>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c));
}
// 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c));
}
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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c));
}
// 5 - 3
@@ -714,16 +782,20 @@ 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c));
}
// 5 - 4
@@ -731,17 +803,21 @@ 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c));
}
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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c));
}
// 5 - 5
@@ -749,17 +825,21 @@ 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
// 5 - 6
@@ -767,49 +847,57 @@ 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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
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 Tuple<P1, P2, P3, P4, P5>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4, P5>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c),
+ base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c));
}
// 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p));
}
template <typename R, typename Function, typename P1, typename P2, typename P3,
typename P4, typename P5, typename P6>
inline R DispatchToFunction(Function function,
- const Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p));
}
// 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c));
}
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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c));
}
// 6 - 2
@@ -817,16 +905,20 @@ 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c));
}
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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c));
}
// 6 - 3
@@ -834,17 +926,21 @@ 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c));
}
// 6 - 4
@@ -852,17 +948,21 @@ 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c));
}
// 6 - 5
@@ -870,17 +970,21 @@ 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4, C5>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4, C5>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c));
}
// 6 - 6
@@ -888,17 +992,23 @@ 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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c),
+ base::get<5>(c));
}
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 Tuple<P1, P2, P3, P4, P5, P6>& p,
- const Tuple<C1, C2, C3, C4, C5, C6>& c) {
- return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
+ const base::Tuple<P1, P2, P3, P4, P5, P6>& p,
+ const base::Tuple<C1, C2, C3, C4, C5, C6>& c) {
+ return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p),
+ base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c),
+ base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c),
+ base::get<5>(c));
}
// Interface that is exposed to the consumer, that does the actual calling
@@ -984,7 +1094,7 @@ struct MutantFunctor {
}
inline R operator()() {
- return impl_->RunWithParams(Tuple<>());
+ return impl_->RunWithParams(base::Tuple<>());
}
template <typename Arg1>
@@ -1017,198 +1127,198 @@ struct MutantFunctor {
// 0 - 0
template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (U::*method)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(),
- Tuple<>, Tuple<>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (*function)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(),
- Tuple<>, Tuple<>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (U::*method)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(),
- Tuple<>, Tuple<>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (__stdcall U::*method)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(),
- Tuple<>, Tuple<>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (__stdcall *function)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(),
- Tuple<>, Tuple<>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (__stdcall U::*method)()) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(),
- Tuple<>, Tuple<>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<>, base::Tuple<>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
// 0 - 1
template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (U::*method)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(A1),
- Tuple<>, Tuple<A1>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (*function)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(A1),
- Tuple<>, Tuple<A1>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (U::*method)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1),
- Tuple<>, Tuple<A1>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1),
- Tuple<>, Tuple<A1>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (__stdcall *function)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(A1),
- Tuple<>, Tuple<A1>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1),
- Tuple<>, Tuple<A1>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
// 0 - 2
template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (U::*method)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (*function)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (U::*method)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (__stdcall *function)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2),
- Tuple<>, Tuple<A1, A2>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1216,69 +1326,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
// 0 - 3
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename A1, typename A2, typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (*function)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename A1, typename A2, typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (__stdcall *function)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3),
- Tuple<>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1286,69 +1396,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
// 0 - 4
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename A1, typename A2, typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (*function)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename A1, typename A2, typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
- Tuple<>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1356,71 +1466,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
// 0 - 5
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
- Tuple<>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1428,137 +1538,137 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
// 0 - 6
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename A1, typename A2,
typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
- Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple());
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple());
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
// 1 - 0
template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1),
- Tuple<P1>, Tuple<>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (*function)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1),
- Tuple<P1>, Tuple<>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1),
- Tuple<P1>, Tuple<>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1),
- Tuple<P1>, Tuple<>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (__stdcall *function)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1),
- Tuple<P1>, Tuple<>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1),
- Tuple<P1>, Tuple<>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1566,69 +1676,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
// 1 - 1
template <typename R, typename T, typename U, typename P1, typename A1,
typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename A1, typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (*function)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename A1,
typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename A1, typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename X1>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1),
- Tuple<P1>, Tuple<A1>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1636,69 +1746,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
// 1 - 2
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (*function)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (U::*method)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2),
- Tuple<P1>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1706,71 +1816,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
// 1 - 3
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename A3,
typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (*function)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename A3,
typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
- Tuple<P1>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1778,73 +1888,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
// 1 - 4
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename A3,
typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (*function)(X1, A1, A2, A3, A4), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename A1, typename A2, typename A3,
typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
- Tuple<P1>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1852,73 +1962,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
// 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename A1,
typename A2, typename A3, typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1927,39 +2037,39 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -1967,39 +2077,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>
CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6),
- const P1& p1) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
- Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2007,71 +2117,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
// 2 - 0
template <typename R, typename T, typename U, typename P1, typename P2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (*function)(X1, X2), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2),
- Tuple<P1, P2>, Tuple<>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2079,74 +2189,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
// 2 - 1
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (*function)(X1, X2, A1), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1>>
-CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+inline MutantFunctor<R, base::Tuple<A1>>
+CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1),
- Tuple<P1, P2>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2154,76 +2263,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
// 2 - 2
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (*function)(X1, X2, A1, A2), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
- Tuple<P1, P2>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2231,76 +2340,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
// 2 - 3
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (*function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
- const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
- const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
- Tuple<P1, P2>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2309,40 +2418,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename A3, typename A4, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2350,39 +2459,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
- const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename A1, typename A2,
typename A3, typename A4, typename X1, typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
- const P1& p1, const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2391,40 +2500,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2432,39 +2541,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>
CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
- const P2& p2) {
- MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2473,41 +2582,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2515,40 +2625,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (function, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2556,77 +2667,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
// 3 - 0
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (*function)(X1, X2, X3), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3),
- Tuple<P1, P2, P3>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2634,77 +2745,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
// 3 - 1
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (*function)(X1, X2, X3, A1), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
- Tuple<P1, P2, P3>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2713,40 +2824,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (*function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2754,39 +2865,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
- Tuple<P1, P2, P3>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2795,40 +2906,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename A3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2,
- const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2836,39 +2947,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename A3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename X1,
typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2877,41 +2988,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename A4,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename A3, typename A4, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename A4,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -2919,40 +3030,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename A4,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename A1,
typename A2, typename A3, typename A4, typename X1, typename X2,
typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
- const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename A1, typename A2, typename A3, typename A4,
typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2961,41 +3072,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3003,40 +3115,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3045,41 +3158,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3087,40 +3201,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3>, base::Tuple<A1, A2, A3, A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3129,40 +3244,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (*function)(X1, X2, X3, X4), const P1& p1, const P2& p2,
- const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3170,39 +3285,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
- Tuple<P1, P2, P3, P4>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3211,40 +3326,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (*function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2,
- const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3252,39 +3367,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<A1>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
- Tuple<P1, P2, P3, P4>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3293,41 +3408,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2,
- const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3335,40 +3450,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename X1, typename X2, typename X3,
typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<A1, A2>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3377,41 +3492,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename A3, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3419,40 +3534,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename A3, typename X1, typename X2,
typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3461,41 +3576,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1,
- const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3503,40 +3619,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
template <typename R, typename P1, typename P2, typename P3, typename P4,
typename A1, typename A2, typename A3, typename A4, typename X1,
typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
template <typename R, typename T, typename U, typename P1, typename P2,
typename P3, typename P4, typename A1, typename A2, typename A3,
typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>
CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
- const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3546,27 +3663,28 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3574,14 +3692,14 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3590,41 +3708,42 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3634,27 +3753,29 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3662,14 +3783,15 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3678,41 +3800,47 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5,
+ A6),
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5,
+ A6),
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5,
+ A6),
+ base::Tuple<P1, P2, P3, P4>, base::Tuple<A1, A2, A3, A4, A5,
+ A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3721,41 +3849,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3763,40 +3891,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3805,41 +3933,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3847,40 +3975,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3889,41 +4017,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3931,40 +4059,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3974,27 +4102,28 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4002,14 +4131,14 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4018,41 +4147,42 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4062,27 +4192,28 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4090,14 +4221,14 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4106,43 +4237,44 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4152,28 +4284,30 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4181,14 +4315,15 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4197,44 +4332,50 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4,
+ A5),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4,
+ A5),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4,
+ A5),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4244,29 +4385,31 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4274,15 +4417,16 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4291,45 +4435,51 @@ 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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<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),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<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),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4,
+ A5, A6),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2,
+ A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<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),
- Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5) {
+ MutantRunner<R, base::Tuple<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),
+ base::Tuple<P1, P2, P3, P4, P5>, base::Tuple<A1, A2, A3, A4,
+ A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4338,41 +4488,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4380,42 +4530,42 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(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, Tuple<>>
+inline MutantFunctor<R, base::Tuple<>>
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, Tuple<>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4425,27 +4575,27 @@ 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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4453,14 +4603,14 @@ 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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4469,43 +4619,43 @@ 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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4515,28 +4665,29 @@ 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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4544,15 +4695,15 @@ 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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4561,44 +4712,45 @@ 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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4608,29 +4760,30 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4638,15 +4791,15 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4655,45 +4808,46 @@ 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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3>>* t =
+ A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3>>* t =
new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4703,30 +4857,32 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4734,15 +4890,16 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4751,45 +4908,51 @@ 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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
- new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4>>* t =
- new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
+ A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4>>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4799,30 +4962,32 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4830,15 +4995,16 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4847,45 +5013,51 @@ 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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4, A5),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4, A5),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4, A5>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5>>* t =
- new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
+ A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5>>* t =
+ new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4, A5),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4896,30 +5068,33 @@ template <typename R, typename T, typename U, typename P1, typename P2,
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<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),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
+ A6),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4928,15 +5103,16 @@ template <typename R, typename T, typename U, typename P1, typename P2,
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
+ const P6& p6) {
+ MutantRunner<R, base::Tuple<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),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4946,30 +5122,34 @@ template <typename R, typename T, typename U, typename P1, typename P2,
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<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),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<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),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<A1, A2, A3, A4, A5, A6>>* t =
- new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (function, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<A1, A2, A3, A4, A5, A6>>* t =
+ new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3,
+ A4, A5, A6),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1,
+ A2, A3, A4, A5, A6>>
+ (function, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<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,
@@ -4977,15 +5157,17 @@ template <typename R, typename T, typename U, typename P1, typename P2,
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, Tuple<A1, A2, A3, A4, A5, A6>>
+inline MutantFunctor<R, base::Tuple<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, Tuple<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),
- Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
- (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
- return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
+ A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+ const P5& p5, const P6& p6) {
+ MutantRunner<R, base::Tuple<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),
+ base::Tuple<P1, P2, P3, P4, P5, P6>, base::Tuple<A1, A2, A3,
+ A4, A5, A6>>
+ (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6));
+ return MutantFunctor<R, base::Tuple<A1, A2, A3, A4, A5, A6>>(t);
}
#endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
« no previous file with comments | « testing/generate_gmock_mutant.py ('k') | tools/ipc_fuzzer/fuzzer/fuzzer.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698