#pragma GCC diagnostic ignored "-Wold-style-cast"

#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"

#pragma clang diagnostic ignored "-Wshorten-64-to-32"

#pragma clang diagnostic ignored "-Wunreachable-code"

#ifndef EXCEPTION_BUFFER_SIZE

#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

#endif

#ifdef __EDG__

#define FUNCTION_BASE 3

#define FUNCTION_STRIDE 2

#else

#define FUNCTION_STRIDE 1

#endif

#include <list>

#include <map>

#include <memory>

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

// Alignment not right in a union?

#pragma warning(disable: 4121)

// Template parameters have the tendency not to change between executions.

#pragma warning(disable: 4127)

// No deprecated warnings on functions that really aren't deprecated at all.

#pragma warning(disable: 4996)

Once,

DontCare

};

// base type

class base_mock {

public:

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

virtual ~base_mock() {}

{

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

*(void **)this = newVf;

return oldVf;

}

{

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

}

};

{

{

}

};

struct NotPrintable { template <typename T> NotPrintable(T const&) {} };

inline std::ostream &operator<<(std::ostream &os, NotPrintable const&)

{

os << "???";

return os;

}

template <typename T>

{

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

{

if (withComma) os << ",";

os << arg;

}

};

template <>

struct printArg<NullType>

{

static void print(std::ostream &, NullType , bool)

{

}

};

{

protected:

{

{

}

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

virtual void printTo(std::ostream &os) const = 0;

};

template <typename X>

struct no_cref { typedef X type; };

template <typename T>

struct comparer

{

static inline bool compare(T a, T b)

{

return a == b;

}

};

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

class tuple : public base_tuple

{

public:

typename no_cref<A>::type a;

typename no_cref<B>::type b;

typename no_cref<C>::type c;

typename no_cref<D>::type d;

typename no_cref<E>::type e;

typename no_cref<H>::type h;

typename no_cref<I>::type i;

typename no_cref<J>::type j;

typename no_cref<K>::type k;

typename no_cref<L>::type l;

typename no_cref<M>::type m;

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)

{}

bool operator==(const base_tuple &bo) const {

const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &to = (const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &)bo;

return (comparer<A>::compare(a, to.a) &&

comparer<B>::compare(b, to.b) &&

comparer<C>::compare(c, to.c) &&

comparer<D>::compare(d, to.d) &&

template <typename T>

int getFunctionIndex(T func) {

func_index idx;

return ((&idx)->*reinterpret_cast<int (func_index::*)()>(func))() * FUNCTION_STRIDE + FUNCTION_BASE;

}

// mock types

template <class T>

{

friend class MockRepository;

unsigned char remaining[sizeof(T)];

void NotImplemented() { throw NotImplementedException(repo); }

protected:

void *oldVft;

void (*funcs[VIRT_FUNC_LIMIT])();

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;

}

return -1;

}

};

template <class T>

class classMock : public mock<T>

{

void *backupVft;

public:

: mock<T>(repo)

{

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

new(this)T();

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

}

~classMock()

{

base_mock::rewriteVft(backupVft);

((T *)this)->~T();

}

};

//Type-safe exception wrapping

public:

virtual ~ExceptionHolder() {}

};

template <class T>

class ExceptionWrapper : public ExceptionHolder {

T exception;

public:

ExceptionWrapper(T exception) : exception(exception) {}

void rethrow() { throw exception; }

};

// Do() function wrapping

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>

{

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

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(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)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(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, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(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, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(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, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f);

}

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;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e);

}

VirtualDestructable *functor;

int funcIndex;

std::list<Call *> previousCalls;

RegistrationType expectation;

bool satisfied;

int lineno;

const char *funcName;

const char *fileName;

protected:

functor(0),

expectation(expectation),

satisfied(false),

lineno(X),

funcName(funcName),

fileName(fileName)

{

}

public:

virtual const base_tuple *getArgs() const = 0;

{

delete eHolder;

delete functor;

delete retVal;

}

};

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:

tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *args;

public:

const base_tuple *getArgs() const { return args; }

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 &Return(Y obj) { retVal = new ReturnValueWrapper<Y>(obj); return *this; }

template <typename Ex>

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:

tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *args;

public:

const base_tuple *getArgs() const { return args; }

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

template <typename Ex>

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

};

class MockRepository {

private:

#define NeverCall(obj, func) RegisterExpect_<__LINE__, Never>(obj, &func, #func, __FILE__, __LINE__)

#define OnCallOverload(obj, func) RegisterExpect_<__LINE__, DontCare>(obj, func, #func, __FILE__, __LINE__)

#define ExpectCallOverload(obj, func) RegisterExpect_<__LINE__, Once>(obj, func, #func, __FILE__, __LINE__)

#define NeverCallOverload(obj, func) RegisterExpect_<__LINE__, Never>(obj, func, #func, __FILE__, __LINE__)

#endif

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

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,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &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);

//GCC 3.x doesn't seem to understand overloading on const or non-const member function. Volatile appears to work though.

#if !defined(__GNUC__) || __GNUC__ > 3

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

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,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) 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,P))(func), funcName, fileName, lineNo); }

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

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,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) 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,P))(func), funcName, fileName, lineNo); }

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

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>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) 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,P))(func), funcName, fileName, lineNo); }

#endif

template <typename Z>

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

call->funcIndex == funcno &&

call->matchesArgs(tuple) &&

!call->satisfied)

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

{

if (!(*callsBefore)->satisfied)

{

allSatisfy = false;

}

}

if (!allSatisfy) continue;

call->satisfied = true;

if (call->eHolder)

call->eHolder->rethrow();

if (call->functor != NULL)

(*(TupleInvocable<void> *)(call->functor))(tuple);

return;

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

}

}

if (!allSatisfy) continue;

call->satisfied = true;

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

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

call->eHolder->rethrow();

if (call->functor != NULL)

(*(TupleInvocable<void> *)(call->functor))(tuple);

return;

}

}

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

call->funcIndex == funcno)

funcName = call->funcName;

}

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

}

}

template <typename base>

base *InterfaceMock();

template <typename base>

base *ClassMock();

};

// mock function providers

template <typename Z, typename Y>

class mockFuncs : public mock<Z> {

mockFuncs();

public:

template <int X>

Y expectation0()

{

MockRepository *repo = mock<Z>::repo;

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), tuple<>());

}

template <int X, typename A>

Y expectation16(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)

{

MockRepository *repo = mock<Z>::repo;

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), 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));

}

};

template <typename Z>

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

mockFuncs();

public:

template <int X>

void expectation0()

{

MockRepository *repo = mock<Z>::repo;

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<>());

}

template <int X, typename A>

if (zMock->funcMap[funcIndex] == -1)

{

zMock->funcs[funcIndex] = getNonvirtualMemberFunctionAddress<void (*)()>(func);

zMock->funcMap[funcIndex] = 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());

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

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

}

expectations.push_back(call);

break;

}

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

}

expectations.push_back(call);

break;

}

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

switch(expect)

{

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

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

case Once:

{

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

}

expectations.push_back(call);

break;

}

return *call;

}

template <typename Z>

{

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple) &&

!call->satisfied)

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

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

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

}

}

if (!allSatisfy) continue;

call->satisfied = true;

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

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

{

if (!(*callsBefore)->satisfied)

{

allSatisfy = false;

}

}

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

call->funcIndex == funcno)

funcName = call->funcName;

}

throw ExpectationException(this, &tuple, funcName);

}

template <typename base>

os << "Optional results set up:" << std::endl;

for (std::list<Call *>::const_iterator exp = repo.optionals.begin(); exp != repo.optionals.end(); ++exp)

os << **exp;

os << std::endl;

}

return os;

}

{

std::stringstream text;

text << description;

text << *repo;

std::string result = text.str();

strncpy(buffer, result.c_str(), sizeof(buffer)-1);

buffer[sizeof(buffer)-1] = '\0';

}

#ifdef _MSC_VER

#pragma warning(pop)

#endif

#endif