CallDriver.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__CALL_DRIVER_H
#define UTILS__CALITKO_MOCKS__CALL_DRIVER_H

#include "Imports.h"
#include "BasicTypes.h"
#include "ExpectedFunction.h"
#include "ExpectationsList.h"

namespace Utils {
namespace CalitkoMocks {

class ExpectedFunctionBase;
template <typename Function> class ExpectedFunction;
template <typename CallDriver, typename Function> class ExpectationDriver;


template <typename Function>
class CallDriver
{
public:
    typedef typename Function::ReturnType           ReturnType;

    CallDriver (auto_ptr <Function> foo) : f (foo), throwing (false) { }
    CallDriver (const CallDriver &other) : f (other.f), throwing (false) { }

    ~CallDriver()
    {
        if (f.get() != 0 and !throwing) {
            f->checkCalled();
        }
    }


    template <typename Foo>
    ExpectationDriver <CallDriver, ExpectedFunction <Foo> >
    willCall (ExpectationPair <ExpectedFunction <Foo> > expectation)
    {
        ExpectedFunction <Foo> *expectedFunction = expectation.function.get();
        expectation.list.add (expectation.function); // add the foo to the list
        f->addExpectation (expectedFunction);
        return ExpectationDriver <CallDriver, ExpectedFunction <Foo> >
            (*this, *expectedFunction);
    }

    template <typename Foo>
    ExpectationDriver <CallDriver, ExpectedFunction <Foo> >
    willCallMsg (ExpectationPair <ExpectedFunction <Foo> > expectation,
                 const std::string &expressionString,
                 const SourceLine &sourceLine)
    {
        expectation.function->setContext (expressionString, sourceLine);
        return willCall (expectation);
    }

    void willReturn (const ReturnTypeWrapper <ReturnType> &returnValue)
    {
        f->willReturn (returnValue);
        try {
            f->call();
        } catch (Exception &e) {
            throwing = true;
            throw;
        }
    }

    void willReturnMsg (const ReturnTypeWrapper <ReturnType> &returnValue,
                        const std::string &expressionString,
                        const SourceLine &sourceLine)
    {
        f->setContext (expressionString, sourceLine);
        willReturn (returnValue);
    }

    void returns()
    {
        willReturn (ReturnTypeWrapper <void>());
    }

    template <typename Foo>
    CallDriver &
    willEmit (ExpectationPair <ExpectedFunction <Foo> > expectation)
    {
        ExpectedFunction <Foo> *signalExpectation = expectation.function.get();
        expectation.list.add (expectation.function);
        f->addExpectation (signalExpectation);
        return *this;
    }

    template <typename Foo>
    CallDriver &
    willEmitMsg (ExpectationPair <ExpectedFunction <Foo> > expectation,
                 const std::string &expressionString,
                 const CPPUNIT_NS::SourceLine &sourceLine)
    {
        expectation.function->setContext (expressionString, sourceLine);
        return willEmit (expectation);
    }

private:
    mutable auto_ptr <Function>     f;
    bool                            throwing;

    template <typename X, typename Y> friend class ExpectationDriver;
};

} // namespace CalitkoMocks
} // namespace Utils

#endif // UTILS__CALITKO_MOCKS__CALL_DRIVER_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.