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

else :

#define VIRT_FUNC_LIMIT 1024

#include <cstring>

#ifdef _MSC_VER

#pragma warning(push)

virtual ~base_mock() {}

{

}

{

{

{

}

template <typename T>

{

{

protected:

{

{

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

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

template <class T>

{

int funcMap[VIRT_FUNC_LIMIT];

: repo(repo)

{

{

}

{

{

public:

: mock<T>(repo)

//Type-safe exception wrapping

public:

virtual ~ExceptionHolder() {}

};

template <typename Y>

{

template <typename Y,

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

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>

template <typename T, typename Y,

typename M, typename N, typename O>

template <typename T, typename Y,

typename M, typename N>

template <typename T, typename Y,

typename M>

template <typename T, typename Y,

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

template <typename T, typename Y,

typename I, typename J, typename K>

template <typename T, typename Y,

typename I, typename J>

template <typename T, typename Y,

typename I>

template <typename T, typename Y,

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

template <typename T, typename Y,

typename E, typename F, typename G>

template <typename T, typename Y,

typename E, typename F>

template <typename T, typename Y,

typename E>

protected:

functor(0),

expectation(expectation),

virtual const base_tuple *getArgs() const = 0;

{

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

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

}

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

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

}

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

Z DoExpectation(base_mock *mock, int funcno, const base_tuple &tuple);

{

{

call->satisfied = true;

if (call->eHolder)

}

{

}

{

const char *funcName = NULL;

{

}

{

}

{

}

: autoExpect(true)

}

{

reset();

{

}

{

{

expectations.clear();

{

neverCalls.clear();

{

}

{

{

class mockFuncs : public mock<Z> {

mockFuncs();

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

mockFuncs();

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

{

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

reinterpret_cast<void (base_mock::*)()>(mfp),X);

case Once:

{

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

{

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

funcIndex,

case Once:

{

}

typename A, typename B>

{

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

funcIndex,

case Once:

{

}

typename A, typename B, typename C>

{

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

funcIndex,

case Once:

{

}

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

{

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

funcIndex,

case Once:

{

}

typename E>

{

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

funcIndex,

case Once:

{

}

typename E, typename F>

{

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

funcIndex,

case Once:

{

}

typename E, typename F, typename G>

{

mfp = &mockFuncs<Z2, Y>::template expectation7<X,A,B,C,D,E,F,G>;

funcIndex,

case Once:

{

}

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

{

mfp = &mockFuncs<Z2, Y>::template expectation8<X,A,B,C,D,E,F,G,H>;

funcIndex,

case Once:

{

}

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

typename I>

{

mfp = &mockFuncs<Z2, Y>::template expectation9<X,A,B,C,D,E,F,G,H,I>;

funcIndex,

case Once:

{

}

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

typename I, typename J>

{

mfp = &mockFuncs<Z2, Y>::template expectation10<X,A,B,C,D,E,F,G,H,I,J>;

funcIndex,

case Once:

{

}

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

typename I, typename J, typename K>

{

mfp = &mockFuncs<Z2, Y>::template expectation11<X,A,B,C,D,E,F,G,H,I,J,K>;

funcIndex,

case Once:

{

}

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

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

{

mfp = &mockFuncs<Z2, Y>::template expectation12<X,A,B,C,D,E,F,G,H,I,J,K,L>;

funcIndex,

case Once:

{

}

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

typename M>

{

mfp = &mockFuncs<Z2, Y>::template expectation13<X,A,B,C,D,E,F,G,H,I,J,K,L,M>;

funcIndex,

case Once:

{

}

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

typename M, typename 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);

case Once:

{

}

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

typename M, typename N, typename 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);

case Once:

{

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

typename M, typename N, typename O, typename 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,

case Once:

{

template <typename Z>

{

{

}

{

}

{

call->satisfied = true;

if (call->eHolder)

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;

{

}

{

}

{

{

#endif

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

# Retain user requested TARGET_ARCH

target_platform = host_platform

try:

_VCVER_TO_PRODUCT_DIR = {

'10.0': [

}

def msvc_version_to_maj_min(msvc_version):

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

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

batfilename = None

installed_sdks=get_installed_sdks()

msvs_version = env.get('MSVS_VERSION')

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

env['TARGET_ARCH']=tp

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

arg = _HOST_TARGET_ARCH_TO_BAT_ARCH[host_target]

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

continue

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

continue

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

env['TARGET_ARCH']=req_target_platform

return d

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

d = script_env(use_script)

d = msvc_find_valid_batch_script(env,version)

return version in vcs

vars.Add('linkflags', "Extra linker flags")

vars.Add(BoolVariable("ccache", "Use CCache", "no"))

vars.Add(PackageVariable("openssl", "OpenSSL location", "yes"))

vars.Add(BoolVariable("openssl_force_bundled", "Force use of the bundled OpenSSL", "no"))

vars.Add(PackageVariable("hunspell", "Hunspell location", False))

vars.Add(PathVariable("boost_libdir", "Boost library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_includedir", "Expat headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_libdir", "Expat library location", None, PathVariable.PathAccept))

vars.Add(PackageVariable("icu", "ICU library location", "no"))

vars.Add(PathVariable("libidn_includedir", "LibIDN headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libidn_libdir", "LibIDN library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_includedir", "LibMiniUPNPC headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("sqlite_libdir", "SQLite library location", None, PathVariable.PathAccept))

vars.Add("sqlite_force_bundled", "Force use of the bundled SQLite", None)

vars.Add(PathVariable("avahi_includedir", "Avahi headers location", None, PathVariable.PathAccept))

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

env_ENV = {

'LD_LIBRARY_PATH' : os.environ.get("LD_LIBRARY_PATH", ""),

}

if "MSVC_VERSION" in ARGUMENTS :

else :

if "TMP" in os.environ.keys() :

env.Tool("SLOCCount", toolpath = ["#/BuildTools/SCons/Tools"])

env["CXX"] = env["cxx"]

if "link" in env :

env.Append(CCFLAGS = [

"-arch", "ppc"])

env.Append(LINKFLAGS = [

"-arch", "ppc"])

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

env.Append(CXXFLAGS = ["/wd4068"])

else :

if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

# Testing

# Bit of a hack, because BOOST doesn't know the endianness for ARM

env.SConscript = SConscript

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

env["HAVE_ZLIB"] = True

else :

conf.Finish()

if env.get("boost_includedir", None) :

boost_flags["CPPPATH"] = [env["boost_includedir"]]

conf = Configure(boost_conf_env)

allLibsPresent = True

libName = "boost_" + lib

libName += "-mt"

allLibsPresent = False

env["BOOST_BUNDLED_UUID_ONLY"] = True

else :

env["HAVE_GCONF"] = 0

gconf_env = conf_env.Clone()

conf = Configure(conf_env, custom_tests = {"CheckVersion": CheckVersion})

#and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623) :

libxml_env = conf_env.Clone()

# Expat

expat_conf_env = conf_env.Clone()

use_icu = bool(env["icu"])

icu_flags = {}

conf = Configure(libidn_conf_env)

env["HAVE_LIBIDN"] = 1

if not env.get("HAVE_ICU", False) and not env.get("HAVE_LIBIDN", False) :

conf = Configure(avahi_conf_env)

env["HAVE_AVAHI"] = True

use_openssl = bool(env["openssl"])

openssl_flags = {}

if openssl_prefix :

openssl_flags["LIBPATH"] = [os.path.join(openssl_prefix, "lib", "VC")]

env["OPENSSL_FLAGS"] = openssl_flags

env["OPENSSL_FLAGS"]["LIBS"] = ["libeay32MD", "ssleay32MD"]

env["OPENSSL_FLAGS"] = {}

env["HAVE_SCHANNEL"] = True

bonjour_flags = {}

bonjour_prefix = env["bonjour"]

if env.Dir("#/.git").exists() :

env.Install("#/.git/hooks", Glob("#/BuildTools/Git/Hooks/*"))

print

if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

params = ""

params = " --xml > " + os.path.join(target[0].dir.path, "checker-report.xml")

ignore_prefix = ""

["adb shell mount -o rw,remount /system",

"adb shell SWIFT_CLIENTTEST_JID=\"" + os.getenv("SWIFT_CLIENTTEST_JID") + "\" SWIFT_CLIENTTEST_PASS=\"" + os.getenv("SWIFT_CLIENTTEST_PASS") + "\" " + env.get("TEST_RUNNER", "") + "/system/bin/" + exec_name], cmdstr = "$TESTCOMSTR"))

else :

SCons.Action.Action(ignore_prefix + env.get("TEST_RUNNER", "") + cmd + " " + params, cmdstr = "$TESTCOMSTR"))

return None

def git(cmd, root) :

p.stdin.close()

if gitVersion :

if len(build_string) > 0 :

if build_match :

return (major, minor, patch)

and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's

cpp0x = True

else :

newProgramLines.append(line)

return ("\n".join(newProgramLines), callouts)

# Parse program

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

"CPPPATH" : ["#/3rdParty/HippoMocks"],

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

}

if "Slimber" in env["PROJECTS"] :

env["SLIMBER_VERSION"] = "0.9.9." + datetime.date.today().strftime("%Y%m%d")

#include <unistd.h>

: boost::filesystem::path(dataDir)) / boost::to_lower_copy(getApplicationName());

#pragma once

#include <string>

#include <boost/function.hpp>

#include <list>

virtual ~EventLoop();

void postEvent(boost::function<void ()> event, boost::shared_ptr<EventOwner> owner = boost::shared_ptr<EventOwner>());

virtual void post(const Event& event) = 0;

void handleEvent(const Event& event);

/*

* Licensed under the GNU General Public License v3.

#include <Swiften/Base/ByteArray.h>

#include <Swiften/EventLoop/EventLoop.h>

class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

BonjourRegisterQuery(const std::string& name, int port, const ByteArray& txtRecord, boost::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {

DNSServiceErrorType result = DNSServiceRegister(

&BonjourRegisterQuery::handleServiceRegisteredStatic, this);

}

#else

sourceList += [ "WindowsNetworkEnvironment.cpp" ]

else :

# LibNATPMP classes

if myenv.get("HAVE_LIBNATPMP", False) :

natpmp_env.Append(CPPDEFINES = natpmp_env["LIBNATPMP_FLAGS"].get("INTERNAL_CPPDEFINES", []))

/*

* Licensed under the GNU General Public License v3.

void PayloadParserFactoryCollection::removeFactory(PayloadParserFactory* factory) {

}

std::vector<PayloadParserFactory*>::reverse_iterator i = std::find_if(

boost::bind(&PayloadParserFactory::canParse, _1, element, ns, attributes));

void removeContact(const JID& jid);

/*

* Licensed under the GNU General Public License v3.

void PayloadSerializerCollection::removeSerializer(PayloadSerializer* serializer) {

}

std::vector<PayloadSerializer*>::const_iterator i = std::find_if(

boost::bind(&PayloadSerializer::canSerialize, _1, payload));

BasicSessionStream::BasicSessionStream(

TimerFactory* timerFactory,

XMLParserFactory* xmlParserFactory) :

compressionLayer(NULL),

if (tlsLayer) {

tlsLayer->onConnected.disconnect(boost::bind(&BasicSessionStream::handleTLSConnected, this));