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
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-contrib-a2296b00c88df201b0eb58e867aeb17a87e6332c.zip
swift-contrib-a2296b00c88df201b0eb58e867aeb17a87e6332c.tar.bz2
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
-
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-contrib-a2296b00c88df201b0eb58e867aeb17a87e6332c.zip swift-contrib-a2296b00c88df201b0eb58e867aeb17a87e6332c.tar.bz2