#define EXCEPTION_BUFFER_SIZE 65536

#endif

#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

#include <iostream>

#include <sstream>

#include <cstring>

#ifdef _MSC_VER

#pragma warning(push)

// If you can't generate an assignment operator the least you can do is shut up.

#pragma warning(disable: 4512)

public:

void destroy() { unwriteVft(); delete this; }

virtual ~base_mock() {}

{

void *oldVf = *(void **)this;

*(void **)this = newVf;

return oldVf;

}

{

*(void **)this = (*(void ***)this)[-1];

}

};

{

{

}

};

}

template <typename T>

{

static inline void print(std::ostream &os, T arg, bool withComma)

{

}

};

{

protected:

{

{

}

virtual bool operator==(const base_tuple &) const = 0;

}

};

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class tuple : public base_tuple

{

typename no_cref<N>::type n;

typename no_cref<O>::type o;

typename no_cref<P>::type p;

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<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)

{}

// mock types

template <class T>

{

friend class MockRepository;

unsigned char remaining[sizeof(T)];

MockRepository *repo;

public:

int funcMap[VIRT_FUNC_LIMIT];

: repo(repo)

{

{

funcs[i] = getNonvirtualMemberFunctionAddress<void (*)()>(&mock<T>::NotImplemented);

funcMap[i] = -1;

memset(remaining, 0, sizeof(remaining));

oldVft = base_mock::rewriteVft(funcs);

}

{

{

if (funcMap[i] == x) return i;

}

{

void *backupVft;

public:

: mock<T>(repo)

{

mock<T>::oldVft = base_mock::rewriteVft((void *)mock<T>::funcs);

};

//Type-safe exception wrapping

public:

virtual ~ExceptionHolder() {}

};

template <class T>

class VirtualDestructable { public: virtual ~VirtualDestructable() {} };

template <typename Y>

{

public:

virtual Y operator()(const base_tuple &tupl) = 0;

};

template <typename Y,

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class Invocable : public TupleInvocable<Y>

{

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);

rTupl.i, rTupl.j, rTupl.k, rTupl.l, rTupl.m, rTupl.n, rTupl.o, rTupl.p);

}

};

template <typename T, typename Y,

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;

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 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;

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 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;

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H,I,J>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H,I>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G,H>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F,G>::operator();

};

template <typename T, typename Y,

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;

using Invocable<Y,A,B,C,D,E,F>::operator();

};

template <typename T, typename Y,

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;

const char *funcName;

const char *fileName;

protected:

functor(0),

expectation(expectation),

satisfied(false),

lineno(X),

}

public:

virtual const base_tuple *getArgs() const = 0;

{

delete eHolder;

delete functor;

std::ostream &operator<<(std::ostream &os, const Call &call);

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class TCall : public Call {

private:

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); }

}

previousCalls.push_back(&call);

}

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; }

Call &Throw(Ex exception) { eHolder = new ExceptionWrapper<Ex>(exception); return *this; }

};

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:

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)); }

}

previousCalls.push_back(&call);

}

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; }

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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> &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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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> &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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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> &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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

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); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

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);

{

{

Call *call = *i;

if (call->mock == mock &&

if (!allSatisfy) continue;

call->satisfied = true;

if (call->eHolder)

call->eHolder->rethrow();

return;

}

}

{

Call *call = *i;

if (call->mock == mock &&

throw ExpectationException(this, call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

}

}

const char *funcName = NULL;

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

}

throw ExpectationException(this, &tuple, funcName);

}

: autoExpect(true)

{

}

{

if (!std::uncaught_exception())

VerifyAll();

reset();

{

(*i)->destroy();

}

mocks.clear();

}

{

{

delete *i;

}

expectations.clear();

{

delete *i;

}

neverCalls.clear();

{

delete *i;

}

optionals.clear();

}

{

{

if (!(*i)->satisfied)

throw CallMissingException(this);

// mock function providers

template <typename Z, typename Y>

class mockFuncs : public mock<Z> {

mockFuncs();

public:

template <int X>

template <typename Z>

class mockFuncs<Z, void> : public mock<Z> {

mockFuncs();

public:

template <int X>

// Mock repository implementation

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)();

mfp = &mockFuncs<Z2, Y>::template expectation0<X>;

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)

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

return *call;

}

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A);

mfp = &mockFuncs<Z2, Y>::template expectation1<X,A>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename A, typename B>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B);

mfp = &mockFuncs<Z2, Y>::template expectation2<X,A,B>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename A, typename B, typename C>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C);

mfp = &mockFuncs<Z2, Y>::template expectation3<X,A,B,C>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename A, typename B, typename C, typename D>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D);

mfp = &mockFuncs<Z2, Y>::template expectation4<X,A,B,C,D>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

{

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>;

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)

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

{

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>;

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)

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

{

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>;

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);

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

}

template <typename Z>

{

{

Call *call = *i;

if (call->mock == mock &&

throw NoResultSetUpException(call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

throw ExpectationException(this, call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

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;

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

return os;

}

{

std::stringstream text;

text << description;

#endif

#endif