Import("env")

if env["TEST"] :

if env["PLATFORM"] == "win32" :

cppflags = ["/I" + Dir("src/include").abspath]

else :

cppflags = [("-isystem", Dir("src/include").abspath)]

################################################################################

# Module flags

################################################################################

if env["SCONS_STAGE"] == "flags" :

env["CPPUNIT_FLAGS"] = {

"CPPPATH": [env.Dir(".")],

"CPPFLAGS": cppflags,

"LIBPATH": [env.Dir(".")],

"LIBS": ["Swiften_CppUnit"]

}

################################################################################

# Build

################################################################################

if env["SCONS_STAGE"] == "build" :

myenv = env.Clone()

myenv.Replace(CXXFLAGS = [flag for flag in env["CXXFLAGS"] if not flag.startswith("-W")])

myenv.Append(CPPPATH = ["src/include", "."])

sources = [

"src/src/cppunit/TextTestRunner.cpp",

"src/src/cppunit/TextTestProgressListener.cpp",

"src/src/cppunit/BriefTestProgressListener.cpp",

"src/src/cppunit/TextOutputter.cpp",

"src/src/cppunit/XmlOutputter.cpp",

"src/src/cppunit/XmlElement.cpp",

"src/src/cppunit/XmlDocument.cpp",

"src/src/cppunit/StringTools.cpp",

"src/src/cppunit/DefaultProtector.cpp",

"src/src/cppunit/Protector.cpp",

"src/src/cppunit/ProtectorChain.cpp",

#ifndef HIPPOMOCKS_H

#define HIPPOMOCKS_H

#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_BASE 0

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

#endif

class MockRepository;

enum RegistrationType {

Never,

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

struct no_cref<const X &> { typedef X type; };

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

inline bool operator==(NotComparable, NotComparable)

{

return false;

}

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<F>::type f;

typename no_cref<G>::type g;

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

comparer<E>::compare(e, to.e) &&

comparer<F>::compare(f, to.f) &&

comparer<G>::compare(g, to.g) &&

comparer<H>::compare(h, to.h) &&

comparer<I>::compare(i, to.i) &&

comparer<J>::compare(j, to.j) &&

comparer<K>::compare(k, to.k) &&

comparer<L>::compare(l, to.l) &&

comparer<M>::compare(m, to.m) &&

comparer<N>::compare(n, to.n) &&

comparer<O>::compare(o, to.o) &&

comparer<P>::compare(p, to.p));

}

virtual void printTo(std::ostream &os) const

{

os << "(";

printArg<A>::print(os, a, false);

printArg<B>::print(os, b, true);

printArg<C>::print(os, c, true);

printArg<D>::print(os, d, true);

printArg<E>::print(os, e, true);

printArg<F>::print(os, f, true);

printArg<G>::print(os, g, true);

printArg<H>::print(os, h, true);

printArg<I>::print(os, i, true);

printArg<J>::print(os, j, true);

template <typename T, typename U>

T getNonvirtualMemberFunctionAddress(U u)

{

#ifdef __EDG__

// Edison Design Group C++ frontend (Comeau, Portland Group, Greenhills, etc)

union {

struct {

short delta;

short vindex;

T t;

} mfp_structure;

U u;

} conv;

#else

// Visual Studio, GCC, others

union {

struct {

T t;

} mfp_structure;

U u;

} conv;

#endif

conv.u = u;

return conv.mfp_structure.t;

}

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

}

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

};

template <typename T, typename Y,

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

class DoWrapper<T,Y,A,B,C,D,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D> {

T &t;

public:

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

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

{

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

}

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

};

template <typename T, typename Y,

typename A, typename B, typename C>

class DoWrapper<T,Y,A,B,C,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C> {

T &t;

public:

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

virtual Y operator()(A a, B b, C c, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c);

}

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

};

virtual Y operator()(NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t();

}

using Invocable<Y>::operator();

};

class ReturnValueHolder {

public:

virtual ~ReturnValueHolder() {}

};

template <class T>

class ReturnValueWrapper : public ReturnValueHolder {

public:

typename no_cref<T>::type rv;

ReturnValueWrapper(T rv) : rv(rv) {}

};

//Call wrapping

class Call {

public:

virtual bool matchesArgs(const base_tuple &tuple) = 0;

ReturnValueHolder *retVal;

ExceptionHolder *eHolder;

base_mock *mock;

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:

friend inline std::ostream &operator<<(std::ostream &os, const MockRepository &repo);

std::list<base_mock *> mocks;

std::list<Call *> neverCalls;

std::list<Call *> expectations;

std::list<Call *> optionals;

public:

bool autoExpect;

#ifdef _MSC_VER

#define OnCall(obj, func) RegisterExpect_<__COUNTER__, DontCare>(obj, &func, #func, __FILE__, __LINE__)

#define ExpectCall(obj, func) RegisterExpect_<__COUNTER__, Once>(obj, &func, #func, __FILE__, __LINE__)

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

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

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

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

#else

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

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

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

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

{

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 (!(*callsBefore)->satisfied)

{

allSatisfy = false;

}

}

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->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 expectation1(A a)

{

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

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

}

template <int X, typename A, typename B>

Y expectation2(A a, B b)

{

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

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

}

template <int X, typename A, typename B, typename C>

Y expectation3(A a, B b, C c)

{

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

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), tuple<A,B,C>(a,b,c));

}

template <int X, typename A, typename B, typename C, typename D>

Y expectation4(A a, B b, C c, D d)

{

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

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), tuple<A,B,C,D>(a,b,c,d));

}

template <int X, typename A, typename B, typename C, typename D, typename E>

Y expectation5(A a, B b, C c, D d, E e)

{

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L>

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

{

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>(a,b,c,d,e,f,g,h,i,j,k,l));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M>

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

{

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>(a,b,c,d,e,f,g,h,i,j,k,l,m));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N>

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

{

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>(a,b,c,d,e,f,g,h,i,j,k,l,m,n));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O>

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

{

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>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O, typename P>

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>

void expectation1(A a)

{

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

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

}

template <int X, typename A, typename B>

void expectation2(A a, B b)

{

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

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

}

template <int X, typename A, typename B, typename C>

void expectation3(A a, B b, C c)

{

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

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<A,B,C>(a,b,c));

}

template <int X, typename A, typename B, typename C, typename D>

void expectation4(A a, B b, C c, D d)

{

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

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<A,B,C,D>(a,b,c,d));

}

template <int X, typename A, typename B, typename C, typename D, typename E>

void expectation5(A a, B b, C c, D d, E e)

{

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

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<A,B,C,D,E,F,G,H,I,J,K,L,M>(a,b,c,d,e,f,g,h,i,j,k,l,m));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N>

void expectation14(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)

{

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

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(a,b,c,d,e,f,g,h,i,j,k,l,m,n));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O>

void expectation15(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)

{

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

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));

}

template <int X, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L, typename M, typename N, typename O, typename P>

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

repo->DoVoidExpectation(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>

void MockRepository::BasicRegisterExpect(mock<Z> *zMock, int funcIndex, void (base_mock::*func)(), int X)

{

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

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

}

}

{

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;

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>

base *MockRepository::InterfaceMock() {

mock<base> *m = new mock<base>(this);

mocks.push_back(m);

return reinterpret_cast<base *>(m);

}

template <typename base>

base *MockRepository::ClassMock() {

classMock<base> *m = new classMock<base>(this);

mocks.push_back(m);

return reinterpret_cast<base *>(m);

}

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

{

os << call.fileName << "(" << call.lineno << ") ";

if (call.expectation == Once)

os << "Expectation for ";

else

os << "Result set for ";

os << call.funcName;

if (call.getArgs())

call.getArgs()->printTo(os);

else

os << "(...)";

else

os << "used." << std::endl;

return os;

}

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

{

if (repo.expectations.size())

{

os << "Expections set:" << std::endl;

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

os << **exp;

os << std::endl;

}

if (repo.neverCalls.size())

{

os << "Functions explicitly expected to not be called:" << std::endl;

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

os << **exp;

os << std::endl;

}

if (repo.optionals.size())

{

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

# Dict to 'canonalize' the arch

_ARCH_TO_CANONICAL = {

"amd64" : "amd64",

"emt64" : "amd64",

"i386" : "x86",

"i486" : "x86",

"i586" : "x86",

"i686" : "x86",

"ia64" : "ia64",

"itanium" : "ia64",

"x86" : "x86",

"x86_64" : "amd64",

}

# Given a (host, target) tuple, return the argument for the bat file. Both host

# and targets should be canonalized.

_HOST_TARGET_ARCH_TO_BAT_ARCH = {

("x86", "x86"): "x86",

("x86", "amd64"): "x86_amd64",

("amd64", "amd64"): "amd64",

("amd64", "x86"): "x86",

("x86", "ia64"): "x86_ia64"

}

def get_host_target(env):

debug('vc.py:get_host_target()')

host_platform = env.get('HOST_ARCH')

if not host_platform:

host_platform = platform.machine()

# TODO(2.5): the native Python platform.machine() function returns

# '' on all Python versions before 2.6, after which it also uses

# PROCESSOR_ARCHITECTURE.

if not host_platform:

host_platform = os.environ.get('PROCESSOR_ARCHITECTURE', '')

# Retain user requested TARGET_ARCH

req_target_platform = env.get('TARGET_ARCH')

debug('vc.py:get_host_target() req_target_platform:%s'%req_target_platform)

if req_target_platform:

# If user requested a specific platform then only try that one.

target_platform = req_target_platform

else:

target_platform = host_platform

try:

host = _ARCH_TO_CANONICAL[host_platform.lower()]

except KeyError, e:

msg = "Unrecognized host architecture %s"

raise ValueError(msg % repr(host_platform))

try:

target = _ARCH_TO_CANONICAL[target_platform.lower()]

except KeyError, e:

raise ValueError("Unrecognized target architecture %s" % target_platform)

return (host, target,req_target_platform)

_VCVER_TO_PRODUCT_DIR = {

'10.0': [

r'Microsoft\VisualStudio\10.0\Setup\VC\ProductDir'],

'9.0': [

r'Microsoft\VisualStudio\9.0\Setup\VC\ProductDir'],

'9.0Exp' : [

r'Microsoft\VCExpress\9.0\Setup\VC\ProductDir'],

'8.0': [

r'Microsoft\VisualStudio\8.0\Setup\VC\ProductDir'],

'8.0Exp': [

r'Microsoft\VCExpress\8.0\Setup\VC\ProductDir'],

'7.1': [

r'Microsoft\VisualStudio\7.1\Setup\VC\ProductDir'],

'7.0': [

r'Microsoft\VisualStudio\7.0\Setup\VC\ProductDir'],

'6.0': [

r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual C++\ProductDir']

}

def msvc_version_to_maj_min(msvc_version):

msvc_version_numeric = ''.join([x for x in msvc_version if x in string_digits + '.'])

t = msvc_version_numeric.split(".")

if not len(t) == 2:

raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))

try:

maj = int(t[0])

min = int(t[1])

return maj, min

except ValueError, e:

raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))

def is_host_target_supported(host_target, msvc_version):

"""Return True if the given (host, target) tuple is supported given the

msvc version.

Parameters

----------

host_target: tuple

tuple of (canonalized) host-target, e.g. ("x86", "amd64") for cross

compilation from 32 bits windows to 64 bits.

msvc_version: str

msvc version (major.minor, e.g. 10.0)

Note

----

This only check whether a given version *may* support the given (host,

target), not that the toolchain is actually present on the machine.

"""

# We assume that any Visual Studio version supports x86 as a target

if host_target[1] != "x86":

maj, min = msvc_version_to_maj_min(msvc_version)

if maj < 8:

return False

If for some reason the requested version could not be found, an

exception which inherits from VisualCException will be raised."""

root = 'Software\\'

if common.is_win64():

root = root + 'Wow6432Node\\'

try:

hkeys = _VCVER_TO_PRODUCT_DIR[msvc_version]

except KeyError:

debug("Unknown version of MSVC: %s" % msvc_version)

raise UnsupportedVersion("Unknown version %s" % msvc_version)

for key in hkeys:

key = root + key

try:

comps = common.read_reg(key)

except WindowsError, e:

debug('find_vc_dir(): no VC registry key %s' % repr(key))

else:

debug('find_vc_dir(): found VC in registry: %s' % comps)

if os.path.exists(comps):

return comps

else:

debug('find_vc_dir(): reg says dir is %s, but it does not exist. (ignoring)'\

% comps)

raise MissingConfiguration("registry dir %s not found on the filesystem" % comps)

return None

def find_batch_file(env,msvc_version,host_arch,target_arch):

"""

Find the location of the batch script which should set up the compiler

for any TARGET_ARCH whose compilers were installed by Visual Studio/VCExpress

"""

pdir = find_vc_pdir(msvc_version)

if pdir is None:

raise NoVersionFound("No version of Visual Studio found")

debug('vc.py: find_batch_file() pdir:%s'%pdir)

# filter out e.g. "Exp" from the version name

msvc_ver_numeric = ''.join([x for x in msvc_version if x in string_digits + "."])

vernum = float(msvc_ver_numeric)

if 7 <= vernum < 8:

pdir = os.path.join(pdir, os.pardir, "Common7", "Tools")

batfilename = os.path.join(pdir, "vsvars32.bat")

elif vernum < 7:

pdir = os.path.join(pdir, "Bin")

batfilename = os.path.join(pdir, "vcvars32.bat")

else: # >= 8

batfilename = os.path.join(pdir, "vcvarsall.bat")

if not os.path.exists(batfilename):

debug("Not found: %s" % batfilename)

batfilename = None

installed_sdks=get_installed_sdks()

for _sdk in installed_sdks:

sdk_bat_file=_sdk.get_sdk_vc_script(host_arch,target_arch)

sdk_bat_file_path=os.path.join(pdir,sdk_bat_file)

debug('vc.py:find_batch_file() sdk_bat_file_path:%s'%sdk_bat_file_path)

if os.path.exists(sdk_bat_file_path):

return (batfilename,sdk_bat_file_path)

else:

debug("vc.py:find_batch_file() not found:%s"%sdk_bat_file_path)

else:

return (batfilename,None)

__INSTALLED_VCS_RUN = None

def cached_get_installed_vcs():

global __INSTALLED_VCS_RUN

if __INSTALLED_VCS_RUN is None:

ret = get_installed_vcs()

__INSTALLED_VCS_RUN = ret

return __INSTALLED_VCS_RUN

def get_installed_vcs():

installed_versions = []

for ver in _VCVER:

debug('trying to find VC %s' % ver)

try:

if find_vc_pdir(ver):

debug('found VC %s' % ver)

installed_versions.append(ver)

else:

debug('find_vc_pdir return None for ver %s' % ver)

except VisualCException, e:

debug('did not find VC %s: caught exception %s' % (ver, str(e)))

return installed_versions

def reset_installed_vcs():

"""Make it try again to find VC. This is just for the tests."""

__INSTALLED_VCS_RUN = None

def script_env(script, args=None):

stdout = common.get_output(script, args)

# Stupid batch files do not set return code: we take a look at the

# beginning of the output for an error message instead

olines = stdout.splitlines()

if olines[0].startswith("The specified configuration type is missing"):

raise BatchFileExecutionError("\n".join(olines[:2]))

return common.parse_output(stdout)

def get_default_version(env):

debug('get_default_version()')

msvc_version = env.get('MSVC_VERSION')

msvs_version = env.get('MSVS_VERSION')

debug('get_default_version(): msvc_version:%s msvs_version:%s'%(msvc_version,msvs_version))

if msvs_version and not msvc_version:

SCons.Warnings.warn(

SCons.Warnings.DeprecatedWarning,

"MSVS_VERSION is deprecated: please use MSVC_VERSION instead ")

return msvs_version

elif msvc_version and msvs_version:

if not msvc_version == msvs_version:

SCons.Warnings.warn(

SCons.Warnings.VisualVersionMismatch,

"Requested msvc version (%s) and msvs version (%s) do " \

"not match: please use MSVC_VERSION only to request a " \

"visual studio version, MSVS_VERSION is deprecated" \

% (msvc_version, msvs_version))

return msvs_version

if not msvc_version:

installed_vcs = cached_get_installed_vcs()

debug('installed_vcs:%s' % installed_vcs)

if not installed_vcs:

msg = 'No installed VCs'

debug('msv %s\n' % repr(msg))

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, msg)

return None

msvc_version = installed_vcs[0]

debug('msvc_setup_env: using default installed MSVC version %s\n' % repr(msvc_version))

return msvc_version

def msvc_setup_env_once(env):

try:

has_run = env["MSVC_SETUP_RUN"]

except KeyError:

has_run = False

if not has_run:

msvc_setup_env(env)

env["MSVC_SETUP_RUN"] = True

def msvc_find_valid_batch_script(env,version):

debug('vc.py:msvc_find_valid_batch_script()')

# Find the host platform, target platform, and if present the requested

# target platform

(host_platform, target_platform,req_target_platform) = get_host_target(env)

# If the user hasn't specifically requested a TARGET_ARCH, and

# The TARGET_ARCH is amd64 then also try 32 bits if there are no viable

# 64 bit tools installed

try_target_archs = [target_platform]

if target_platform=='amd64':

try_target_archs.append('x86')

d = None

for tp in try_target_archs:

# Set to current arch.

env['TARGET_ARCH']=tp

debug("vc.py:msvc_find_valid_batch_script() trying target_platform:%s"%tp)

host_target = (host_platform, tp)

if not is_host_target_supported(host_target, version):

warn_msg = "host, target = %s not supported for MSVC version %s" % \

(host_target, version)

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

arg = _HOST_TARGET_ARCH_TO_BAT_ARCH[host_target]

# Try to locate a batch file for this host/target platform combo

try:

(vc_script,sdk_script) = find_batch_file(env,version,host_platform,tp)

debug('vc.py:msvc_find_valid_batch_script() vc_script:%s sdk_script:%s'%(vc_script,sdk_script))

except VisualCException, e:

msg = str(e)

debug('Caught exception while looking for batch file (%s)' % msg)

warn_msg = "VC version %s not installed. " + \

"C/C++ compilers are most likely not set correctly.\n" + \

" Installed versions are: %s"

warn_msg = warn_msg % (version, cached_get_installed_vcs())

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

continue

# Try to use the located batch file for this host/target platform combo

debug('vc.py:msvc_find_valid_batch_script() use_script 2 %s, args:%s\n' % (repr(vc_script), arg))

if vc_script:

try:

d = script_env(vc_script, args=arg)

except BatchFileExecutionError, e:

debug('vc.py:msvc_find_valid_batch_script() use_script 3: failed running VC script %s: %s: Error:%s'%(repr(vc_script),arg,e))

vc_script=None

if not vc_script and sdk_script:

debug('vc.py:msvc_find_valid_batch_script() use_script 4: trying sdk script: %s'%(sdk_script))

try:

d = script_env(sdk_script,args=[])

except BatchFileExecutionError,e:

debug('vc.py:msvc_find_valid_batch_script() use_script 5: failed running SDK script %s: Error:%s'%(repr(sdk_script),e))

continue

elif not vc_script and not sdk_script:

debug('vc.py:msvc_find_valid_batch_script() use_script 6: Neither VC script nor SDK script found')

continue

# If we cannot find a viable installed compiler, reset the TARGET_ARCH

# To it's initial value

if not d:

env['TARGET_ARCH']=req_target_platform

return d

def msvc_setup_env(env):

debug('msvc_setup_env()')

version = get_default_version(env)

if version is None:

warn_msg = "No version of Visual Studio compiler found - C/C++ " \

"compilers most likely not set correctly"

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

return None

debug('msvc_setup_env: using specified MSVC version %s\n' % repr(version))

# XXX: we set-up both MSVS version for backward

# compatibility with the msvs tool

env['MSVC_VERSION'] = version

env['MSVS_VERSION'] = version

env['MSVS'] = {}

use_script = env.get('MSVC_USE_SCRIPT', True)

if SCons.Util.is_String(use_script):

debug('vc.py:msvc_setup_env() use_script 1 %s\n' % repr(use_script))

d = script_env(use_script)

d = msvc_find_valid_batch_script(env,version)

debug('vc.py:msvc_setup_env() use_script 2 %s\n' % d)

if not d:

return d

else:

debug('MSVC_USE_SCRIPT set to False')

warn_msg = "MSVC_USE_SCRIPT set to False, assuming environment " \

"set correctly."

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

return None

for k, v in d.items():

debug('vc.py:msvc_setup_env() env:%s -> %s'%(k,v))

env.PrependENVPath(k, v, delete_existing=True)

def msvc_exists(version=None):

vcs = cached_get_installed_vcs()

if version is None:

return len(vcs) > 0

return version in vcs