Swiftdiff options
Diffstat (limited to '3rdParty/HippoMocks/hippomocks.h')
| -rw-r--r-- | 3rdParty/HippoMocks/hippomocks.h | 608 |
1 files changed, 304 insertions, 304 deletions
diff --git a/3rdParty/HippoMocks/hippomocks.h b/3rdParty/HippoMocks/hippomocks.h index 802d719..3483dce 100644 --- a/3rdParty/HippoMocks/hippomocks.h +++ b/3rdParty/HippoMocks/hippomocks.h @@ -11,5 +11,5 @@ #endif -#ifndef VIRT_FUNC_LIMIT +#ifndef VIRT_FUNC_LIMIT #define VIRT_FUNC_LIMIT 1024 #elif VIRT_FUNC_LIMIT > 1024 @@ -31,7 +31,8 @@ #include <sstream> #include <cstring> +#include <string> #ifdef _MSC_VER -// these warnings are pointless and huge, and will confuse new users. +// these warnings are pointless and huge, and will confuse new users. #pragma warning(push) // If you can't generate an assignment operator the least you can do is shut up. @@ -57,5 +58,5 @@ public: void destroy() { unwriteVft(); delete this; } virtual ~base_mock() {} - void *rewriteVft(void *newVf) + void *rewriteVft(void *newVf) { void *oldVf = *(void **)this; @@ -63,5 +64,5 @@ public: return oldVf; } - void unwriteVft() + void unwriteVft() { *(void **)this = (*(void ***)this)[-1]; @@ -69,10 +70,10 @@ public: }; -class NullType +class NullType { -public: - bool operator==(const NullType &) const +public: + bool operator==(const NullType &) const { - return true; + return true; } }; @@ -87,5 +88,5 @@ inline std::ostream &operator<<(std::ostream &os, NotPrintable const&) template <typename T> -struct printArg +struct printArg { static inline void print(std::ostream &os, T arg, bool withComma) @@ -104,12 +105,12 @@ struct printArg<NullType> }; -class base_tuple +class base_tuple { protected: - base_tuple() + base_tuple() { - } -public: - virtual ~base_tuple() + } +public: + virtual ~base_tuple() { } @@ -140,7 +141,7 @@ struct comparer }; -template <typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, - typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, - typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, +template <typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, + typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, + typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType> class tuple : public base_tuple @@ -163,11 +164,11 @@ public: typename no_cref<O>::type o; typename no_cref<P>::type p; - tuple(typename no_cref<A>::type a = typename no_cref<A>::type(), typename no_cref<B>::type b = typename no_cref<B>::type(), - typename no_cref<C>::type c = typename no_cref<C>::type(), typename no_cref<D>::type d = typename no_cref<D>::type(), - typename no_cref<E>::type e = typename no_cref<E>::type(), typename no_cref<F>::type f = typename no_cref<F>::type(), + tuple(typename no_cref<A>::type a = typename no_cref<A>::type(), typename no_cref<B>::type b = typename no_cref<B>::type(), + typename no_cref<C>::type c = typename no_cref<C>::type(), typename no_cref<D>::type d = typename no_cref<D>::type(), + typename no_cref<E>::type e = typename no_cref<E>::type(), typename no_cref<F>::type f = typename no_cref<F>::type(), typename no_cref<G>::type g = typename no_cref<G>::type(), typename no_cref<H>::type h = typename no_cref<H>::type(), - typename no_cref<I>::type i = typename no_cref<I>::type(), typename no_cref<J>::type j = typename no_cref<J>::type(), - typename no_cref<K>::type k = typename no_cref<K>::type(), typename no_cref<L>::type l = typename no_cref<L>::type(), - typename no_cref<M>::type m = typename no_cref<M>::type(), typename no_cref<N>::type n = typename no_cref<N>::type(), + typename no_cref<I>::type i = typename no_cref<I>::type(), typename no_cref<J>::type j = typename no_cref<J>::type(), + typename no_cref<K>::type k = typename no_cref<K>::type(), typename no_cref<L>::type l = typename no_cref<L>::type(), + typename no_cref<M>::type m = typename no_cref<M>::type(), typename no_cref<N>::type n = typename no_cref<N>::type(), typename no_cref<O>::type o = typename no_cref<O>::type(), typename no_cref<P>::type p = typename no_cref<P>::type()) : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i), j(j), k(k), l(l), m(m), n(n), o(o), p(p) @@ -571,5 +572,5 @@ int getFunctionIndex(T func) { // mock types template <class T> -class mock : public base_mock +class mock : public base_mock { friend class MockRepository; @@ -582,8 +583,8 @@ protected: public: int funcMap[VIRT_FUNC_LIMIT]; - mock(MockRepository *repo) + mock(MockRepository *repo) : repo(repo) { - for (int i = 0; i < VIRT_FUNC_LIMIT; i++) + for (int i = 0; i < VIRT_FUNC_LIMIT; i++) { funcs[i] = getNonvirtualMemberFunctionAddress<void (*)()>(&mock<T>::NotImplemented); @@ -593,7 +594,7 @@ public: oldVft = base_mock::rewriteVft(funcs); } - int translateX(int x) + int translateX(int x) { - for (int i = 0; i < VIRT_FUNC_LIMIT; i++) + for (int i = 0; i < VIRT_FUNC_LIMIT; i++) { if (funcMap[i] == x) return i; @@ -608,5 +609,5 @@ class classMock : public mock<T> void *backupVft; public: - classMock(MockRepository *repo) + classMock(MockRepository *repo) : mock<T>(repo) { @@ -623,9 +624,9 @@ public: //Type-safe exception wrapping -class ExceptionHolder -{ +class ExceptionHolder +{ public: virtual ~ExceptionHolder() {} - virtual void rethrow() = 0; + virtual void rethrow() = 0; }; @@ -642,5 +643,5 @@ class VirtualDestructable { public: virtual ~VirtualDestructable() {} }; template <typename Y> -class TupleInvocable : public VirtualDestructable +class TupleInvocable : public VirtualDestructable { public: @@ -649,7 +650,7 @@ public: template <typename Y, - typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, - typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, - typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, + typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, + typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, + typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType> class Invocable : public TupleInvocable<Y> @@ -659,12 +660,12 @@ public: virtual Y operator()(const base_tuple &tupl) { const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &rTupl = reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl); - return (*this)(rTupl.a, rTupl.b, rTupl.c, rTupl.d, rTupl.e, rTupl.f, rTupl.g, rTupl.h, + return (*this)(rTupl.a, rTupl.b, rTupl.c, rTupl.d, rTupl.e, rTupl.f, rTupl.g, rTupl.h, rTupl.i, rTupl.j, rTupl.k, rTupl.l, rTupl.m, rTupl.n, rTupl.o, rTupl.p); } }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, - typename I, typename J, typename K, typename L, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, + typename I, typename J, typename K, typename L, typename M, typename N, typename O, typename P> class DoWrapper : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> { @@ -679,7 +680,7 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, - typename I, typename J, typename K, typename L, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, + typename I, typename J, typename K, typename L, typename M, typename N, typename O> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> { @@ -694,7 +695,7 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, - typename I, typename J, typename K, typename L, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, + typename I, typename J, typename K, typename L, typename M, typename N> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> { @@ -709,7 +710,7 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, - typename I, typename J, typename K, typename L, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, + typename I, typename J, typename K, typename L, typename M> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> { @@ -724,6 +725,6 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L> { @@ -738,6 +739,6 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, typename I, typename J, typename K> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K> { @@ -752,6 +753,6 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, typename I, typename J> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J> { @@ -766,6 +767,6 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, + typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, typename I> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I>{ @@ -780,5 +781,5 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> class DoWrapper<T,Y,A,B,C,D,E,F,G,H,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H> { @@ -793,5 +794,5 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> class DoWrapper<T,Y,A,B,C,D,E,F,G,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G> { @@ -806,5 +807,5 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, + typename A, typename B, typename C, typename D, typename E, typename F> class DoWrapper<T,Y,A,B,C,D,E,F,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F> { @@ -819,5 +820,5 @@ public: }; template <typename T, typename Y, - typename A, typename B, typename C, typename D, + typename A, typename B, typename C, typename D, typename E> class DoWrapper<T,Y,A,B,C,D,E,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E> { @@ -917,10 +918,10 @@ public: const char *fileName; protected: - Call(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) - : retVal(0), - eHolder(0), - mock(mock), + Call(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) + : retVal(0), + eHolder(0), + mock(mock), functor(0), - funcIndex(funcIndex), + funcIndex(funcIndex), expectation(expectation), satisfied(false), @@ -932,5 +933,5 @@ protected: public: virtual const base_tuple *getArgs() const = 0; - virtual ~Call() + virtual ~Call() { delete eHolder; @@ -942,8 +943,8 @@ public: std::ostream &operator<<(std::ostream &os, const Call &call); -template <typename Y, - typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, - typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, - typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, +template <typename Y, + typename A = NullType, typename B = NullType, typename C = NullType, typename D = NullType, + typename E = NullType, typename F = NullType, typename G = NullType, typename H = NullType, + typename I = NullType, typename J = NullType, typename K = NullType, typename L = NullType, typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType> class TCall : public Call { @@ -955,11 +956,11 @@ public: ~TCall() { delete args; } bool matchesArgs(const base_tuple &tupl) { return !args || *args == reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl); } - TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &With(A a = A(), B b = B(), C c = C(), D d = D(), E e = E(), F f = F(), G g = G(), H h = H(), I i = I(), J j = J(), K k = K(), L l = L(), M m = M(), N n = N(), O o = O(), P p = P()) { - args = new tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); - return *this; + TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &With(A a = A(), B b = B(), C c = C(), D d = D(), E e = E(), F f = F(), G g = G(), H h = H(), I i = I(), J j = J(), K k = K(), L l = L(), M m = M(), N n = N(), O o = O(), P p = P()) { + args = new tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); + return *this; } - TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &After(Call &call) { + TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &After(Call &call) { previousCalls.push_back(&call); - return *this; + return *this; } template <typename T> @@ -970,7 +971,7 @@ public: }; -template <typename A, typename B, typename C, typename D, - typename E, typename F, typename G, typename H, - typename I, typename J, typename K, typename L, +template <typename A, typename B, typename C, typename D, + typename E, typename F, typename G, typename H, + typename I, typename J, typename K, typename L, typename M, typename N, typename O, typename P> class TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> : public Call { @@ -982,11 +983,11 @@ public: ~TCall() { delete args; } bool matchesArgs(const base_tuple &tupl) { return (!args) || (*args == reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl)); } - TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &With(A a = A(), B b = B(), C c = C(), D d = D(), E e = E(), F f = F(), G g = G(), H h = H(), I i = I(), J j = J(), K k = K(), L l = L(), M m = M(), N n = N(), O o = O(), P p = P()) { - args = new tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); - return *this; + TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &With(A a = A(), B b = B(), C c = C(), D d = D(), E e = E(), F f = F(), G g = G(), H h = H(), I i = I(), J j = J(), K k = K(), L l = L(), M m = M(), N n = N(), O o = O(), P p = P()) { + args = new tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); + return *this; } - TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &After(Call &call) { + TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &After(Call &call) { previousCalls.push_back(&call); - return *this; + return *this; } template <typename T> @@ -1024,69 +1025,69 @@ public: template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A> TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B> TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C> TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C, typename D> TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E> TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F> TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O), const char *funcName, const char *fileName, unsigned long lineNo); - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, @@ -1100,69 +1101,69 @@ public: template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A> TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B> TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C> TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C, typename D> TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E> TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F> TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, @@ -1174,69 +1175,69 @@ public: template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A> TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B> TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C> TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C, typename D> TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E> TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F> TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, @@ -1248,69 +1249,69 @@ public: template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A> TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B> TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C> TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C, typename D> TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E> TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F> TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O> TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); } - template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, + template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, @@ -1322,7 +1323,7 @@ public: template <typename Z> Z DoExpectation(base_mock *mock, int funcno, const base_tuple &tuple); - void DoVoidExpectation(base_mock *mock, int funcno, const base_tuple &tuple) + void DoVoidExpectation(base_mock *mock, int funcno, const base_tuple &tuple) { - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); ++i) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); ++i) { Call *call = *i; @@ -1344,5 +1345,5 @@ public: call->satisfied = true; - + if (call->eHolder) call->eHolder->rethrow(); @@ -1354,5 +1355,5 @@ public: } } - for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); ++i) + for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); ++i) { Call *call = *i; @@ -1377,5 +1378,5 @@ public: } } - for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); ++i) + for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); ++i) { Call *call = *i; @@ -1407,5 +1408,5 @@ public: } const char *funcName = NULL; - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end() && !funcName; ++i) { Call *call = *i; @@ -1414,5 +1415,5 @@ public: funcName = call->funcName; } - for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end() && !funcName; ++i) { Call *call = *i; @@ -1421,5 +1422,5 @@ public: funcName = call->funcName; } - for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end() && !funcName; ++i) { Call *call = *i; @@ -1430,14 +1431,14 @@ public: throw ExpectationException(this, &tuple, funcName); } - MockRepository() + MockRepository() : autoExpect(true) { } - ~MockRepository() + ~MockRepository() { if (!std::uncaught_exception()) VerifyAll(); reset(); - for (std::list<base_mock *>::iterator i = mocks.begin(); i != mocks.end(); i++) + for (std::list<base_mock *>::iterator i = mocks.begin(); i != mocks.end(); i++) { (*i)->destroy(); @@ -1445,17 +1446,17 @@ public: mocks.clear(); } - void reset() + void reset() { - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); i++) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); i++) { delete *i; } expectations.clear(); - for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); i++) + for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); i++) { delete *i; } neverCalls.clear(); - for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); i++) + for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); i++) { delete *i; @@ -1463,7 +1464,7 @@ public: optionals.clear(); } - void VerifyAll() + void VerifyAll() { - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); i++) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); i++) { if (!(*i)->satisfied) @@ -1480,5 +1481,5 @@ public: template <typename Z, typename Y> class mockFuncs : public mock<Z> { -private: +private: mockFuncs(); public: @@ -1589,5 +1590,5 @@ public: template <typename Z> class mockFuncs<Z, void> : public mock<Z> { -private: +private: mockFuncs(); public: @@ -1708,11 +1709,11 @@ void MockRepository::BasicRegisterExpect(mock<Z> *zMock, int funcIndex, void (ba // Mock repository implementation template <int X, RegistrationType expect, typename Z2, typename Y, typename Z> -TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(); mfp = &mockFuncs<Z2, Y>::template expectation0<X>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), - funcIndex, + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); TCall<Y> *call = new TCall<Y>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1722,5 +1723,5 @@ TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *f case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1732,10 +1733,10 @@ TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *f } template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A> -TCall<Y,A> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A); mfp = &mockFuncs<Z2, Y>::template expectation1<X,A>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1746,5 +1747,5 @@ TCall<Y,A> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1755,12 +1756,12 @@ TCall<Y,A> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B> -TCall<Y,A,B> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B); mfp = &mockFuncs<Z2, Y>::template expectation2<X,A,B>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1771,5 +1772,5 @@ TCall<Y,A,B> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1780,12 +1781,12 @@ TCall<Y,A,B> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C> -TCall<Y,A,B,C> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C); mfp = &mockFuncs<Z2, Y>::template expectation3<X,A,B,C>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1796,5 +1797,5 @@ TCall<Y,A,B,C> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), co case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1805,12 +1806,12 @@ TCall<Y,A,B,C> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), co return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A, typename B, typename C, typename D> -TCall<Y,A,B,C,D> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D); mfp = &mockFuncs<Z2, Y>::template expectation4<X,A,B,C,D>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1821,5 +1822,5 @@ TCall<Y,A,B,C,D> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1830,13 +1831,13 @@ TCall<Y,A,B,C,D> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E> -TCall<Y,A,B,C,D,E> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E); mfp = &mockFuncs<Z2, Y>::template expectation5<X,A,B,C,D,E>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1847,5 +1848,5 @@ TCall<Y,A,B,C,D,E> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C, case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1856,13 +1857,13 @@ TCall<Y,A,B,C,D,E> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C, return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F> -TCall<Y,A,B,C,D,E,F> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F); mfp = &mockFuncs<Z2, Y>::template expectation6<X,A,B,C,D,E,F>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1873,5 +1874,5 @@ TCall<Y,A,B,C,D,E,F> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B, case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1882,13 +1883,13 @@ TCall<Y,A,B,C,D,E,F> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B, return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G> -TCall<Y,A,B,C,D,E,F,G> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G); mfp = &mockFuncs<Z2, Y>::template expectation7<X,A,B,C,D,E,F,G>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1899,5 +1900,5 @@ TCall<Y,A,B,C,D,E,F,G> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A, case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1908,13 +1909,13 @@ TCall<Y,A,B,C,D,E,F,G> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A, return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> -TCall<Y,A,B,C,D,E,F,G,H> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H); mfp = &mockFuncs<Z2, Y>::template expectation8<X,A,B,C,D,E,F,G,H>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1925,5 +1926,5 @@ TCall<Y,A,B,C,D,E,F,G,H> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)( case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1934,14 +1935,14 @@ TCall<Y,A,B,C,D,E,F,G,H> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)( return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> -TCall<Y,A,B,C,D,E,F,G,H,I> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I); mfp = &mockFuncs<Z2, Y>::template expectation9<X,A,B,C,D,E,F,G,H,I>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1952,5 +1953,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1961,14 +1962,14 @@ TCall<Y,A,B,C,D,E,F,G,H,I> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> -TCall<Y,A,B,C,D,E,F,G,H,I,J> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J); mfp = &mockFuncs<Z2, Y>::template expectation10<X,A,B,C,D,E,F,G,H,I,J>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -1979,5 +1980,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*fu case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -1988,14 +1989,14 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*fu return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K); mfp = &mockFuncs<Z2, Y>::template expectation11<X,A,B,C,D,E,F,G,H,I,J,K>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -2006,5 +2007,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::* case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2015,14 +2016,14 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::* return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L); mfp = &mockFuncs<Z2, Y>::template expectation12<X,A,B,C,D,E,F,G,H,I,J,K,L>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -2033,5 +2034,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z: case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2042,15 +2043,15 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z: return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M); mfp = &mockFuncs<Z2, Y>::template expectation13<X,A,B,C,D,E,F,G,H,I,J,K,L,M>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -2061,5 +2062,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &MockRepository::RegisterExpect_(Z2 *mck, Y ( case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2070,16 +2071,16 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &MockRepository::RegisterExpect_(Z2 *mck, Y ( return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N); mfp = &mockFuncs<Z2, Y>::template expectation14<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), - funcIndex, + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2089,5 +2090,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &MockRepository::RegisterExpect_(Z2 *mck, Y case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2098,16 +2099,16 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &MockRepository::RegisterExpect_(Z2 *mck, Y return *call; } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O); mfp = &mockFuncs<Z2, Y>::template expectation15<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), - funcIndex, + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2117,5 +2118,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2127,15 +2128,15 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, } -template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, - typename A, typename B, typename C, typename D, +template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, + typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O, typename P> -TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P), const char *funcName, const char *fileName, unsigned long lineNo) +TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P), const char *funcName, const char *fileName, unsigned long lineNo) { int funcIndex = getFunctionIndex(func); Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P); mfp = &mockFuncs<Z2, Y>::template expectation16<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>; - BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), + BasicRegisterExpect(reinterpret_cast<mock<Z2> *>(mck), funcIndex, reinterpret_cast<void (base_mock::*)()>(mfp),X); @@ -2146,5 +2147,5 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &MockRepository::RegisterExpect_(Z2 *mc case DontCare: optionals.push_back(call); break; case Once: - if (autoExpect && expectations.size() > 0) + if (autoExpect && expectations.size() > 0) { call->previousCalls.push_back(expectations.back()); @@ -2157,7 +2158,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &MockRepository::RegisterExpect_(Z2 *mc template <typename Z> -Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &tuple) +Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &tuple) { - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); ++i) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end(); ++i) { Call *call = *i; @@ -2192,5 +2193,5 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t } } - for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); ++i) + for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end(); ++i) { Call *call = *i; @@ -2215,5 +2216,5 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t } } - for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); ++i) + for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end(); ++i) { Call *call = *i; @@ -2234,5 +2235,5 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t call->satisfied = true; - + if (call->eHolder) call->eHolder->rethrow(); @@ -2240,13 +2241,13 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t if (call->retVal) return ((ReturnValueWrapper<Z> *)call->retVal)->rv; - + if (call->functor != NULL) return (*(TupleInvocable<Z> *)(call->functor))(tuple); - + throw NoResultSetUpException(call->getArgs(), call->funcName); } } const char *funcName = NULL; - for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = expectations.begin(); i != expectations.end() && !funcName; ++i) { Call *call = *i; @@ -2255,5 +2256,5 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t funcName = call->funcName; } - for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = neverCalls.begin(); i != neverCalls.end() && !funcName; ++i) { Call *call = *i; @@ -2262,5 +2263,5 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t funcName = call->funcName; } - for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end() && !funcName; ++i) + for (std::list<Call *>::iterator i = optionals.begin(); i != optionals.end() && !funcName; ++i) { Call *call = *i; @@ -2341,5 +2342,5 @@ inline std::ostream &operator<<(std::ostream &os, const MockRepository &repo) } -inline void BaseException::setException(const char *description, MockRepository *repo) +inline void BaseException::setException(const char *description, MockRepository *repo) { std::stringstream text; @@ -2356,3 +2357,2 @@ inline void BaseException::setException(const char *description, MockRepository #endif - |