BoundFunction.h

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef UTILS__CALITKO_MOCKS__BOUND_FUNCTION_H
#define UTILS__CALITKO_MOCKS__BOUND_FUNCTION_H

#include "Imports.h"
#include "BasicTypes.h"

// Define some macros to help us define the template specializations:
#include "HelperMacros.h"

namespace Utils {
namespace CalitkoMocks {

class ExpectedFunctionBase;

class BoundFunctionBase
{
public:
                    BoundFunctionBase();
    virtual         ~BoundFunctionBase();

    void            addExpectation (ExpectedFunctionBase *);
    void            setContext (const std::string &expectationString_,
                                const SourceLine &sourceLine_);
    virtual void    call() = 0;
    void            checkCalled();

protected:
    void            fail (const std::string &reason);
    void            checkExpectations();

    bool            wasCalled;

protected:
    std::string     expectationString;
    SourceLine      sourceLine;

private:
    Q_DISABLE_COPY (BoundFunctionBase)

    typedef std::list <ExpectedFunctionBase *>  Expectations;
    Expectations                                expectations;
};


template <typename Host, typename Func = void()>
class BoundFunction;

#define DEFINE_BOUND_FUNCTION(N)                                            \
    template <typename Host,                                                \
              typename R COMMA_ARGUMENTS_TYPE_LIST_##N (typename P)>        \
    class BoundFunction <Host, R (ARGUMENTS_TYPE_LIST_##N(P))>              \
        : public BoundFunctionBase                                          \
    {                                                                       \
        REFERENCE_OBJECT (BoundFunction)                                    \
    public:                                                                 \
        typedef BoundFunctionBase   Base;                                   \
        typedef R   (Host::*FunctionPointer) (ARGUMENTS_TYPE_LIST_##N(P));  \
        typedef R   (Host::*ConstFunctionPointer)                           \
                                    (ARGUMENTS_TYPE_LIST_##N(P)) const;     \
        typedef R   ReturnType;                                             \
                                                                            \
        BoundFunction (Host *h, FunctionPointer f COMMA_PARAMETER_LIST_##N) \
        : host (h), function (f), stubbedReturnValue()                      \
          INITIALIZER_LIST_##N {}                                           \
                                                                            \
        /* This ctor is a quick HACK to bind const member functions too */  \
        BoundFunction (const Host *h, ConstFunctionPointer f                \
                                                COMMA_PARAMETER_LIST_##N)   \
        : host (const_cast <Host*> (h)),                                    \
          function (reinterpret_cast <FunctionPointer> (f)),                \
          stubbedReturnValue()                                              \
          INITIALIZER_LIST_##N {}                                           \
                                                                            \
        void willReturn (ReturnTypeWrapper <ReturnType> r)                  \
        { stubbedReturnValue.reset (new ReturnTypeWrapper <ReturnType>(r));}\
                                                                            \
        void call()                                                         \
        { this->wasCalled = true;                                           \
          if (!IsSameType <ReturnType, void>::value                         \
              && (stubbedReturnValue.get() == 0))                           \
            this->fail ("willReturn() not called for");                     \
          try {                                                             \
            if (!doCall (*stubbedReturnValue.get()))                        \
                this->fail ("willReturn() expectation failed");             \
          } catch (Exception &e) {                                          \
            /* If no context is given, set ours, but keep the message.*/    \
            if (e.sourceLine() == SourceLine())                             \
                throw Exception (e.message(), this->sourceLine);            \
            else                                                            \
                throw;                                                      \
          }                                                                 \
        }                                                                   \
                                                                            \
    private:                                                                \
        R operator() ()                                                     \
        { return (host->*function) (ARGUMENTS_TYPE_LIST_##N(a)); }          \
                                                                            \
        template <typename T> bool doCall(const ReturnTypeWrapper <T> &r)   \
        { bool ok = (r.value == (*this)());                                 \
          this->checkExpectations(); return ok; }                           \
                                                                            \
        bool doCall (const ReturnTypeWrapper <void> &)                      \
        { (*this)(); this->checkExpectations(); return true; }              \
                                                                            \
        Host                                *host;                          \
        FunctionPointer                     function;                       \
        auto_ptr <ReturnTypeWrapper <ReturnType> >                          \
                                            stubbedReturnValue;             \
        DECLARE_BOUND_VARIABLES_##N                                         \
    };

DEFINE_BOUND_FUNCTION(0)
DEFINE_BOUND_FUNCTION(1)
DEFINE_BOUND_FUNCTION(2)
DEFINE_BOUND_FUNCTION(3)
DEFINE_BOUND_FUNCTION(4)
DEFINE_BOUND_FUNCTION(5)
DEFINE_BOUND_FUNCTION(6)
DEFINE_BOUND_FUNCTION(7)
DEFINE_BOUND_FUNCTION(8)
DEFINE_BOUND_FUNCTION(9)

#undef DEFINE_BOUND_FUNCTION

} // namespace CalitkoMocks
} // namespace Utils

// Undefine the helper macros. Yes, including the file again undefs them all!
#include "HelperMacros.h"

#endif // UTILS__CALITKO_MOCKS__BOUND_FUNCTION_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.