ExpectedFunction.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__EXPECTED_FUNCTION_H
#define UTILS__CALITKO_MOCKS__EXPECTED_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 BoundFunctionBase;


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

    void            addCall (auto_ptr <BoundFunctionBase>);
    void            setContext (const std::string &expectationString_,
                                const SourceLine &sourceLine_);
    void            verifyChecked();
    void            setNumberOfTimesShouldBeInvoked (int from, int to);
    bool            isLastExpectedCall();
    bool            wasVerified();

protected:
    void            fail(const std::string &reason);
    void            callAll();
    void            stopWaiting(); // \todo kind of hack.

private:
    Q_DISABLE_COPY (ExpectedFunctionBase)

    typedef std::list <BoundFunctionBase *> Calls;

    bool                        verifyCheckedWasCalled;
    Calls                       calls;
    std::string                 expectationString;
    SourceLine                  sourceLine;
    int                         minTimesInvoked;
    int                         maxTimesInvoked;
protected:
    int                         timesInvoked;
};


template <typename Func = void()>
        class ExpectedFunction;


template <typename Func, typename BoundFoo>
        class ExpectationChecker;

#define DEFINE_EXPECTED_FUNCTION(N)                                         \
    template <typename R COMMA_ARGUMENTS_TYPE_LIST_##N (typename P)>        \
    class ExpectedFunction <R (ARGUMENTS_TYPE_LIST_##N(P))>                 \
        : public ExpectedFunctionBase                                       \
    {                                                                       \
        REFERENCE_OBJECT (ExpectedFunction)                                 \
    public:                                                                 \
        typedef ExpectedFunctionBase    Base;                               \
        typedef R                       ReturnType;                         \
                                                                            \
        ExpectedFunction (PARAMETER_LIST_##N)                               \
        : stubbedReturnValue (0) INITIALIZER_LIST_##N                       \
        {}                                                                  \
                                                                            \
        void willReturn (ReturnTypeWrapper <ReturnType> r)                  \
        { stubbedReturnValue.reset (new ReturnTypeWrapper <ReturnType>(r));}\
                                                                            \
        virtual ReturnType check (PARAMETER_LIST_##N)                       \
        { this->stopWaiting(); ++this->timesInvoked;                        \
          if (!IsSameType <ReturnType, void>::value                         \
              && (stubbedReturnValue.get() == 0))                           \
            this->fail ("willReturn() not called for");                     \
          if (!(COMPARE_VARIABLES_##N))                                     \
            this->fail ("willCall() expectation failed");                   \
          this->callAll();                                                  \
          return returnHelper (*stubbedReturnValue); }                      \
                                                                            \
    protected:                                                              \
        struct Dummy{};                                                     \
        ExpectedFunction (Dummy)                                            \
        : stubbedReturnValue (0) DEFAULT_INITIALIZER_LIST_##N               \
        {}                                                                  \
                                                                            \
    protected:                                                              \
        template <typename T> T                                             \
        returnHelper (const ReturnTypeWrapper <T> &r)                       \
        { return r.value; }                                                 \
                                                                            \
        void returnHelper (const ReturnTypeWrapper <void> &) {}             \
        auto_ptr <ReturnTypeWrapper <ReturnType> >                          \
                                            stubbedReturnValue;             \
        DECLARE_BOUND_VARIABLES_##N                                         \
    };                                                                      \
                                                                            \
    template <typename R COMMA_ARGUMENTS_TYPE_LIST_##N (typename P),        \
              typename BoundFoo>                                            \
    class ExpectationChecker <R (ARGUMENTS_TYPE_LIST_##N(P)), BoundFoo>     \
    : public ExpectedFunction <R (ARGUMENTS_TYPE_LIST_##N(P))>              \
    {                                                                       \
    public:                                                                 \
        typedef ExpectedFunction <R (ARGUMENTS_TYPE_LIST_##N(P))>           \
                                        Base;                               \
        typedef R                       ReturnType;                         \
                                                                            \
        ExpectationChecker (auto_ptr <BoundFoo> checker_)                   \
        : Base (typename Base::Dummy()), checker (checker_) {}              \
                                                                            \
        virtual ReturnType check (PARAMETER_LIST_##N)                       \
        { this->stopWaiting(); ++this->timesInvoked;                        \
          if (!IsSameType <ReturnType, void>::value                         \
              && (this->stubbedReturnValue.get() == 0))                     \
            this->fail ("willReturn() not called for");                     \
          if (!checker->check (ARGUMENTS_TYPE_LIST_##N(p)))                 \
            this->fail ("willCall() expectation failed");                   \
          this->callAll();                                                  \
          return this->returnHelper (*this->stubbedReturnValue); }          \
    private:                                                                \
        auto_ptr <BoundFoo>     checker;                                    \
    };

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

#undef DEFINE_EXPECTED_FUNCTION

} // namespace CalitkoMocks
} // namespace Utils

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

#endif // UTILS__CALITKO_MOCKS__EXPECTED_FUNCTION_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.