ExpectedFunction.cpp

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

*/

#include "Qt.h"
#include "ExpectedFunction.h"
#include "BoundFunction.h"
#include "TesterApplication.h"
#include "Imports.cpp"


ExpectedFunctionBase::ExpectedFunctionBase()
 :  verifyCheckedWasCalled(), calls(),
    expectationString ("function name unavailable"), sourceLine(),
    minTimesInvoked (1), maxTimesInvoked (1), timesInvoked (0)
{
}

ExpectedFunctionBase::~ExpectedFunctionBase()
{
    // We DO own the registered BoundFunctions, so delete them:
    for (Calls::iterator it = calls.begin();
         it != calls.end(); ++it)
        delete *it;
}

void ExpectedFunctionBase::setContext (const std::string &expectationString_,
                                       const SourceLine &sourceLine_)
{
    expectationString = expectationString_;
    sourceLine = sourceLine_;
}

void ExpectedFunctionBase::verifyChecked()
{
    Q_ASSERT (verifyCheckedWasCalled == false);
    verifyCheckedWasCalled = true;

    if (timesInvoked < minTimesInvoked ||
        (maxTimesInvoked > -1 && timesInvoked > maxTimesInvoked)) {
        if (timesInvoked == 0)
            fail ("function not called");
        else
            fail ("function not called the expected numberOfTimes()");
    }
}

// That's for ExpectationsList to decide whether to ignore the expectation or
// not, cause by the fact that call-more-than-once expectations practically
// never get removed from ExpectationsList. Because expectations are verified
// only when the CallDriver is destroyed, we can be sure that once it is
// verified it is no longer needed.
bool ExpectedFunctionBase::wasVerified()
{
    return verifyCheckedWasCalled;
}

void ExpectedFunctionBase::setNumberOfTimesShouldBeInvoked (int from, int to)
{
    minTimesInvoked = from;
    maxTimesInvoked = to;
}

bool ExpectedFunctionBase::isLastExpectedCall()
{
    return maxTimesInvoked > 0 && timesInvoked + 1 == maxTimesInvoked;
}

void ExpectedFunctionBase::fail (const std::string &reason)
{
    Asserter::failIf (
        true,
        Message (reason, expectationString),
        sourceLine);
}

void ExpectedFunctionBase::addCall (auto_ptr <BoundFunctionBase> call)
{
    calls.push_back (call.get()); // allocate memory and store the pointer
    call.release(); // release ownership - no leak if exception thrown above
}

void ExpectedFunctionBase::callAll()
{
    for (Calls::iterator it = calls.begin();
         it != calls.end(); ++it)
        (*it)->call();
}

void ExpectedFunctionBase::stopWaiting()
{
    TesterApplication::exit (0);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.