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 | |
| 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')
| -rw-r--r-- | 3rdParty/CppUnit/SConscript | 2 | ||||
| -rw-r--r-- | 3rdParty/HippoMocks/hippomocks.h | 608 | ||||
| -rw-r--r-- | 3rdParty/SCons/scons-local-2.0.0.final.0/SCons/Tool/MSCommon/vc.py | 35 |
3 files changed, 325 insertions, 320 deletions
diff --git a/3rdParty/CppUnit/SConscript b/3rdParty/CppUnit/SConscript index ad287f3..addc8ab 100644 --- a/3rdParty/CppUnit/SConscript +++ b/3rdParty/CppUnit/SConscript @@ -4,6 +4,8 @@ if env["TEST"] : if env["PLATFORM"] == "win32" : cppflags = ["/I" + Dir("src/include").abspath] + elif env["PLATFORM"] == "sunos" : + cppflags = [("-I" + Dir("src/include").abspath)] else : cppflags = [("-isystem", Dir("src/include").abspath)] 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 - diff --git a/3rdParty/SCons/scons-local-2.0.0.final.0/SCons/Tool/MSCommon/vc.py b/3rdParty/SCons/scons-local-2.0.0.final.0/SCons/Tool/MSCommon/vc.py index bbdac1d..56af18a 100644 --- a/3rdParty/SCons/scons-local-2.0.0.final.0/SCons/Tool/MSCommon/vc.py +++ b/3rdParty/SCons/scons-local-2.0.0.final.0/SCons/Tool/MSCommon/vc.py @@ -104,7 +104,7 @@ def get_host_target(env): # PROCESSOR_ARCHITECTURE. if not host_platform: host_platform = os.environ.get('PROCESSOR_ARCHITECTURE', '') - + # Retain user requested TARGET_ARCH req_target_platform = env.get('TARGET_ARCH') debug('vc.py:get_host_target() req_target_platform:%s'%req_target_platform) @@ -114,7 +114,7 @@ def get_host_target(env): target_platform = req_target_platform else: target_platform = host_platform - + try: host = _ARCH_TO_CANONICAL[host_platform.lower()] except KeyError, e: @@ -128,9 +128,13 @@ def get_host_target(env): return (host, target,req_target_platform) -_VCVER = ["10.0", "9.0", "9.0Exp","8.0", "8.0Exp","7.1", "7.0", "6.0"] +_VCVER = ["12.0", "11.0", "10.0", "9.0", "9.0Exp","8.0", "8.0Exp","7.1", "7.0", "6.0"] _VCVER_TO_PRODUCT_DIR = { + '12.0': [ + r'Microsoft\VisualStudio\12.0\Setup\VC\ProductDir'], + '11.0': [ + r'Microsoft\VisualStudio\11.0\Setup\VC\ProductDir'], '10.0': [ r'Microsoft\VisualStudio\10.0\Setup\VC\ProductDir'], '9.0': [ @@ -148,7 +152,7 @@ _VCVER_TO_PRODUCT_DIR = { '6.0': [ r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual C++\ProductDir'] } - + def msvc_version_to_maj_min(msvc_version): msvc_version_numeric = ''.join([x for x in msvc_version if x in string_digits + '.']) @@ -228,7 +232,7 @@ def find_batch_file(env,msvc_version,host_arch,target_arch): pdir = find_vc_pdir(msvc_version) if pdir is None: raise NoVersionFound("No version of Visual Studio found") - + debug('vc.py: find_batch_file() pdir:%s'%pdir) # filter out e.g. "Exp" from the version name @@ -246,7 +250,7 @@ def find_batch_file(env,msvc_version,host_arch,target_arch): if not os.path.exists(batfilename): debug("Not found: %s" % batfilename) batfilename = None - + installed_sdks=get_installed_sdks() for _sdk in installed_sdks: sdk_bat_file=_sdk.get_sdk_vc_script(host_arch,target_arch) @@ -303,7 +307,7 @@ def get_default_version(env): msvc_version = env.get('MSVC_VERSION') msvs_version = env.get('MSVS_VERSION') - + debug('get_default_version(): msvc_version:%s msvs_version:%s'%(msvc_version,msvs_version)) if msvs_version and not msvc_version: @@ -360,7 +364,7 @@ def msvc_find_valid_batch_script(env,version): for tp in try_target_archs: # Set to current arch. env['TARGET_ARCH']=tp - + debug("vc.py:msvc_find_valid_batch_script() trying target_platform:%s"%tp) host_target = (host_platform, tp) if not is_host_target_supported(host_target, version): @@ -368,7 +372,7 @@ def msvc_find_valid_batch_script(env,version): (host_target, version) SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg) arg = _HOST_TARGET_ARCH_TO_BAT_ARCH[host_target] - + # Try to locate a batch file for this host/target platform combo try: (vc_script,sdk_script) = find_batch_file(env,version,host_platform,tp) @@ -382,7 +386,7 @@ def msvc_find_valid_batch_script(env,version): warn_msg = warn_msg % (version, cached_get_installed_vcs()) SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg) continue - + # Try to use the located batch file for this host/target platform combo debug('vc.py:msvc_find_valid_batch_script() use_script 2 %s, args:%s\n' % (repr(vc_script), arg)) if vc_script: @@ -401,14 +405,14 @@ def msvc_find_valid_batch_script(env,version): elif not vc_script and not sdk_script: debug('vc.py:msvc_find_valid_batch_script() use_script 6: Neither VC script nor SDK script found') continue - + # If we cannot find a viable installed compiler, reset the TARGET_ARCH # To it's initial value if not d: env['TARGET_ARCH']=req_target_platform - + return d - + def msvc_setup_env(env): debug('msvc_setup_env()') @@ -427,12 +431,12 @@ def msvc_setup_env(env): env['MSVS_VERSION'] = version env['MSVS'] = {} - + use_script = env.get('MSVC_USE_SCRIPT', True) if SCons.Util.is_String(use_script): debug('vc.py:msvc_setup_env() use_script 1 %s\n' % repr(use_script)) d = script_env(use_script) - elif use_script: + elif use_script: d = msvc_find_valid_batch_script(env,version) debug('vc.py:msvc_setup_env() use_script 2 %s\n' % d) if not d: @@ -453,4 +457,3 @@ def msvc_exists(version=None): if version is None: return len(vcs) > 0 return version in vcs - |