Swiftdiff options
| author | Kevin Smith <git@kismith.co.uk> | 2014-07-15 14:45:28 (GMT) |
|---|---|---|
| committer | Swift Review <review@swift.im> | 2014-10-01 12:15:02 (GMT) |
| commit | a2296b00c88df201b0eb58e867aeb17a87e6332c (patch) | |
| tree | 9fdebba1b5e9202ca669786a41dd94f080ba5807 /3rdParty/HippoMocks | |
| parent | a24d8c0e93d70312fc90d5fdf6214ade9a475e92 (diff) | |
| download | swift-a2296b00c88df201b0eb58e867aeb17a87e6332c.zip swift-a2296b00c88df201b0eb58e867aeb17a87e6332c.tar.bz2 | |
Port many of Isode's local fixes upstream
Includes fixes to:
Build with new Visual Studio and Boost
Avoid error caused when Avahi is present but Qt is not
Make declaration of XMPPRosterImpl::addContact consistent with implementation
Includes enhancements to:
Allow user-configurable mt.exe
Allow splitting openssl paths
Allow disabling gconf lookup
Make idn support optional
Allow disabling various library detections
Remove use of non-Python2.4 features in sconscripts
Test-Information:
Builds
Change-Id: Iee91ee80291a8bdf87cc169c915e4dad1cc1055b
Diffstat (limited to '3rdParty/HippoMocks')
| -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 @@ -10,7 +10,7 @@ #define EXCEPTION_BUFFER_SIZE 65536 #endif -#ifndef VIRT_FUNC_LIMIT +#ifndef VIRT_FUNC_LIMIT #define VIRT_FUNC_LIMIT 1024 #elif VIRT_FUNC_LIMIT > 1024 #error Adjust the code to support more than 1024 virtual functions before setting the VIRT_FUNC_LIMIT above 1024 @@ -30,9 +30,10 @@ #include <iostream> #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. #pragma warning(disable: 4512) @@ -56,24 +57,24 @@ class base_mock { public: void destroy() { unwriteVft(); delete this; } virtual ~base_mock() {} - void *rewriteVft(void *newVf) + void *rewriteVft(void *newVf) { void *oldVf = *(void **)this; *(void **)this = newVf; return oldVf; } - void unwriteVft() + void unwriteVft() { *(void **)this = (*(void ***)this)[-1]; } }; -class NullType +class NullType { -public: - bool operator==(const NullType &) const +public: + bool operator==(const NullType &) const { - return true; + return true; } }; @@ -86,7 +87,7 @@ 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) { @@ -103,14 +104,14 @@ struct printArg<NullType> } }; -class base_tuple +class base_tuple { protected: - base_tuple() + base_tuple() { - } -public: - virtual ~base_tuple() + } +public: + virtual ~base_tuple() { } virtual bool operator==(const base_tuple &) const = 0; @@ -139,9 +140,9 @@ 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 { @@ -162,13 +163,13 @@ public: typename no_cref<N>::type n; 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) {} @@ -570,7 +571,7 @@ int getFunctionIndex(T func) { // mock types template <class T> -class mock : public base_mock +class mock : public base_mock { friend class MockRepository; unsigned char remaining[sizeof(T)]; @@ -581,10 +582,10 @@ protected: MockRepository *repo; 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); funcMap[i] = -1; @@ -592,9 +593,9 @@ public: memset(remaining, 0, sizeof(remaining)); 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; } @@ -607,7 +608,7 @@ class classMock : public mock<T> { void *backupVft; public: - classMock(MockRepository *repo) + classMock(MockRepository *repo) : mock<T>(repo) { mock<T>::oldVft = base_mock::rewriteVft((void *)mock<T>::funcs); @@ -622,11 +623,11 @@ public: }; //Type-safe exception wrapping -class ExceptionHolder -{ +class ExceptionHolder +{ public: virtual ~ExceptionHolder() {} - virtual void rethrow() = 0; + virtual void rethrow() = 0; }; template <class T> @@ -641,16 +642,16 @@ public: class VirtualDestructable { public: virtual ~VirtualDestructable() {} }; template <typename Y> -class TupleInvocable : public VirtualDestructable +class TupleInvocable : public VirtualDestructable { public: virtual Y operator()(const base_tuple &tupl) = 0; }; 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> { @@ -658,14 +659,14 @@ public: virtual Y operator()(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()) = 0; 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> { T &t; @@ -678,9 +679,9 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>::operator(); }; 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> { T &t; @@ -693,9 +694,9 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>::operator(); }; 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> { T &t; @@ -708,9 +709,9 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N>::operator(); }; 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> { T &t; @@ -723,8 +724,8 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M>::operator(); }; 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> { T &t; @@ -737,8 +738,8 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L>::operator(); }; 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> { T &t; @@ -751,8 +752,8 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K>::operator(); }; 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> { T &t; @@ -765,8 +766,8 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I,J>::operator(); }; 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>{ T &t; @@ -779,7 +780,7 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H,I>::operator(); }; 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> { T &t; @@ -792,7 +793,7 @@ public: using Invocable<Y,A,B,C,D,E,F,G,H>::operator(); }; 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> { T &t; @@ -805,7 +806,7 @@ public: using Invocable<Y,A,B,C,D,E,F,G>::operator(); }; 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> { T &t; @@ -818,7 +819,7 @@ public: using Invocable<Y,A,B,C,D,E,F>::operator(); }; 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> { T &t; @@ -916,12 +917,12 @@ public: const char *funcName; 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), lineno(X), @@ -931,7 +932,7 @@ protected: } public: virtual const base_tuple *getArgs() const = 0; - virtual ~Call() + virtual ~Call() { delete eHolder; delete functor; @@ -941,10 +942,10 @@ 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 { private: @@ -954,13 +955,13 @@ public: TCall(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) : Call(expectation, mock, funcIndex, X, funcName, fileName), args(0) {} ~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> Call &Do(T &function) { functor = new DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(function); return *this; } @@ -969,9 +970,9 @@ public: Call &Throw(Ex exception) { eHolder = new ExceptionWrapper<Ex>(exception); return *this; } }; -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 { private: @@ -981,13 +982,13 @@ public: TCall(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) : Call(expectation, mock, funcIndex, X, funcName, fileName), args(0) {} ~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> Call &Do(T &function) { functor = new DoWrapper<T,void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(function); return *this; } @@ -1023,71 +1024,71 @@ public: TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *funcName, const char *fileName, unsigned long lineNo); 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, typename M, typename N, typename O, typename P> @@ -1099,71 +1100,71 @@ public: TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); } 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, typename M, typename N, typename O, typename P> @@ -1173,71 +1174,71 @@ public: TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); } 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, typename M, typename N, typename O, typename P> @@ -1247,71 +1248,71 @@ public: TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); } 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, typename M, typename N, typename O, typename P> @@ -1321,9 +1322,9 @@ public: void BasicRegisterExpect(mock<Z> *zMock, int funcIndex, void (base_mock::*func)(), int X); 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; if (call->mock == mock && @@ -1343,7 +1344,7 @@ public: if (!allSatisfy) continue; call->satisfied = true; - + if (call->eHolder) call->eHolder->rethrow(); @@ -1353,7 +1354,7 @@ public: return; } } - 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; if (call->mock == mock && @@ -1376,7 +1377,7 @@ public: throw ExpectationException(this, call->getArgs(), call->funcName); } } - 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; if (call->mock == mock && @@ -1406,21 +1407,21 @@ 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; if (call->mock == mock && call->funcIndex == funcno) 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; if (call->mock == mock && call->funcIndex == funcno) 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; if (call->mock == mock && @@ -1429,42 +1430,42 @@ 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(); } 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; } 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) throw CallMissingException(this); @@ -1479,7 +1480,7 @@ public: // mock function providers template <typename Z, typename Y> class mockFuncs : public mock<Z> { -private: +private: mockFuncs(); public: template <int X> @@ -1588,7 +1589,7 @@ public: template <typename Z> class mockFuncs<Z, void> : public mock<Z> { -private: +private: mockFuncs(); public: template <int X> @@ -1707,13 +1708,13 @@ 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); switch(expect) @@ -1721,7 +1722,7 @@ TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *f case Never: neverCalls.push_back(call); break; 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()); } @@ -1731,12 +1732,12 @@ TCall<Y> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *f return *call; } 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); TCall<Y,A> *call = new TCall<Y,A>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1745,7 +1746,7 @@ TCall<Y,A> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char case Never: neverCalls.push_back(call); break; 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()); } @@ -1754,14 +1755,14 @@ 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); TCall<Y,A,B> *call = new TCall<Y,A,B>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1770,7 +1771,7 @@ TCall<Y,A,B> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const case Never: neverCalls.push_back(call); break; 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()); } @@ -1779,14 +1780,14 @@ 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); TCall<Y,A,B,C> *call = new TCall<Y,A,B,C>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1795,7 +1796,7 @@ TCall<Y,A,B,C> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), co case Never: neverCalls.push_back(call); break; 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()); } @@ -1804,14 +1805,14 @@ 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); TCall<Y,A,B,C,D> *call = new TCall<Y,A,B,C,D>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1820,7 +1821,7 @@ TCall<Y,A,B,C,D> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) case Never: neverCalls.push_back(call); break; 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()); } @@ -1829,15 +1830,15 @@ 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); TCall<Y,A,B,C,D,E> *call = new TCall<Y,A,B,C,D,E>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1846,7 +1847,7 @@ TCall<Y,A,B,C,D,E> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C, case Never: neverCalls.push_back(call); break; 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()); } @@ -1855,15 +1856,15 @@ 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); TCall<Y,A,B,C,D,E,F> *call = new TCall<Y,A,B,C,D,E,F>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1872,7 +1873,7 @@ TCall<Y,A,B,C,D,E,F> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B, case Never: neverCalls.push_back(call); break; 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()); } @@ -1881,15 +1882,15 @@ 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); TCall<Y,A,B,C,D,E,F,G> *call = new TCall<Y,A,B,C,D,E,F,G>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1898,7 +1899,7 @@ TCall<Y,A,B,C,D,E,F,G> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)(A, case Never: neverCalls.push_back(call); break; 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()); } @@ -1907,15 +1908,15 @@ 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); TCall<Y,A,B,C,D,E,F,G,H> *call = new TCall<Y,A,B,C,D,E,F,G,H>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1924,7 +1925,7 @@ TCall<Y,A,B,C,D,E,F,G,H> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func)( case Never: neverCalls.push_back(call); break; 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()); } @@ -1933,16 +1934,16 @@ 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); TCall<Y,A,B,C,D,E,F,G,H,I> *call = new TCall<Y,A,B,C,D,E,F,G,H,I>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1951,7 +1952,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*func case Never: neverCalls.push_back(call); break; 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()); } @@ -1960,16 +1961,16 @@ 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); TCall<Y,A,B,C,D,E,F,G,H,I,J> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -1978,7 +1979,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::*fu case Never: neverCalls.push_back(call); break; 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()); } @@ -1987,16 +1988,16 @@ 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); TCall<Y,A,B,C,D,E,F,G,H,I,J,K> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2005,7 +2006,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z::* case Never: neverCalls.push_back(call); break; 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()); } @@ -2014,16 +2015,16 @@ 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); TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2032,7 +2033,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &MockRepository::RegisterExpect_(Z2 *mck, Y (Z: case Never: neverCalls.push_back(call); break; 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()); } @@ -2041,17 +2042,17 @@ 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); TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2060,7 +2061,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &MockRepository::RegisterExpect_(Z2 *mck, Y ( case Never: neverCalls.push_back(call); break; 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()); } @@ -2069,18 +2070,18 @@ 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); switch(expect) @@ -2088,7 +2089,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &MockRepository::RegisterExpect_(Z2 *mck, Y case Never: neverCalls.push_back(call); break; 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()); } @@ -2097,18 +2098,18 @@ 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); switch(expect) @@ -2116,7 +2117,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, case Never: neverCalls.push_back(call); break; 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()); } @@ -2126,17 +2127,17 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &MockRepository::RegisterExpect_(Z2 *mck, 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, 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); TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName); @@ -2145,7 +2146,7 @@ TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &MockRepository::RegisterExpect_(Z2 *mc case Never: neverCalls.push_back(call); break; 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()); } @@ -2156,9 +2157,9 @@ 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; if (call->mock == mock && @@ -2191,7 +2192,7 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t throw NoResultSetUpException(call->getArgs(), call->funcName); } } - 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; if (call->mock == mock && @@ -2214,7 +2215,7 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t throw ExpectationException(this, call->getArgs(), call->funcName); } } - 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; if (call->mock == mock && @@ -2233,35 +2234,35 @@ Z MockRepository::DoExpectation(base_mock *mock, int funcno, const base_tuple &t if (!allSatisfy) continue; call->satisfied = true; - + if (call->eHolder) call->eHolder->rethrow(); 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; if (call->mock == mock && call->funcIndex == funcno) 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; if (call->mock == mock && call->funcIndex == funcno) 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; if (call->mock == mock && @@ -2340,7 +2341,7 @@ inline std::ostream &operator<<(std::ostream &os, const MockRepository &repo) return os; } -inline void BaseException::setException(const char *description, MockRepository *repo) +inline void BaseException::setException(const char *description, MockRepository *repo) { std::stringstream text; text << description; @@ -2355,4 +2356,3 @@ inline void BaseException::setException(const char *description, MockRepository #endif #endif - |