ExpectationDriver.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__EXPECTATION_DRIVER_H
#define UTILS__CALITKO_MOCKS__EXPECTATION_DRIVER_H

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

namespace Utils {
namespace CalitkoMocks {

template <typename Host, typename Function> class BoundFunction;
template <typename Function> class CallDriver;
template <typename ExpectationDrv, typename Function> class DelayedCallDriver;


template <typename OwningCallDriver, typename Function>
class ExpectationDriver
{
public:
    typedef typename Function::ReturnType           ReturnType;

    ExpectationDriver (OwningCallDriver &owningCallDriver_,
                       Function &expectedFunction_)
        : owningCallDriver (owningCallDriver_),
          expectedFunction (expectedFunction_)
    {
    }


    template <typename H, typename T>
    DelayedCallDriver <ExpectationDriver, BoundFunction <H, T> >
    willCall (auto_ptr <BoundFunction <H, T> > f)
    {
        DelayedCallDriver <ExpectationDriver, BoundFunction <H, T> >
                                    delayedCall (*this, *(f.get()));
        expectedFunction.addCall (
            auto_ptr <typename BoundFunction <H, T>::Base> (f.get()));
        f.release();
        return delayedCall;
    }

    template <typename H, typename T>
    DelayedCallDriver <ExpectationDriver, BoundFunction <H, T> >
    willCallMsg (auto_ptr <BoundFunction <H, T> > f,
                 const std::string &expressionString,
                 const SourceLine &sourceLine)
    {
        f->setContext (expressionString, sourceLine);
        return willCall (f);
    }


    OwningCallDriver & willReturn (ReturnTypeWrapper <ReturnType> r)
    {
        expectedFunction.willReturn (r);
        return owningCallDriver;
    }

    OwningCallDriver & willReturnMsg (ReturnTypeWrapper <ReturnType> r,
                                    const std::string &,
                                    const SourceLine &)
    {
        return willReturn (r);
    }

    OwningCallDriver & returns()
    {
        return willReturn (ReturnTypeWrapper <void>());
    }

    ExpectationDriver & numberOfTimes (int from)
    {
        expectedFunction.setNumberOfTimesShouldBeInvoked (from, from);
        return *this;
    }

    ExpectationDriver & numberOfTimes (int from, int to)
    {
        expectedFunction.setNumberOfTimesShouldBeInvoked (from, to);
        return *this;
    }

private:
    OwningCallDriver                    &owningCallDriver;
    Function                            &expectedFunction;
};

} // namespace CalitkoMocks
} // namespace Utils

#endif // UTILS__CALITKO_MOCKS__EXPECTATION_DRIVER_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.