CallDriverTest.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 "../CallDriver.h"
#include "../ExpectationDriver.h"
#include "../BoundFunction.h"
#include "../ExpectedFunction.h"
#include "Imports.cpp"

namespace Utils {
namespace CalitkoMocks {
namespace Testing {


class CallDriverTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (CallDriverTest);
    CPPUNIT_TEST (testWillReturnOk);
    CPPUNIT_TEST_FAIL (testWillReturnFail);
    CPPUNIT_TEST_FAIL (testBoundFooWillCallNotCheckedFail);
    CPPUNIT_TEST (testReturnsOk);
    CPPUNIT_TEST (testWillCallOk);
    CPPUNIT_TEST (testReturnsNotCalled);
    CPPUNIT_TEST (testMultipleChainedWillCallOk);
    CPPUNIT_TEST_SUITE_END();

public:
    bool fooOk;
    int foo (int a) { fooOk = true; return a * 2; }
    typedef BoundFunction <CallDriverTest, int (int)> fooType;

    void testWillReturnOk()
    {
        CallDriver <fooType> driver (auto_ptr <fooType>
            (new fooType (this, &CallDriverTest::foo, 1)));
        fooOk = false;
        driver.willReturn (2);
        CPPUNIT_ASSERT (fooOk == true);
    }

    void testWillReturnFail()
    {
        CallDriver <fooType> driver (auto_ptr <fooType>
            (new fooType (this, &CallDriverTest::foo, 1)));
        fooOk = false;
        driver.willReturn (4); // this must throw
    }


    void testBoundFooWillCallNotCheckedFail()
    {
        typedef ExpectedFunction <void ()> Foo;
        // The list owns the expected functions so it should be destroyed after
        // the call driver:
        ExpectationsList <Foo> list;
        CallDriver <fooType> driver (auto_ptr <fooType>
            (new fooType (this, &CallDriverTest::foo, 1)));
        auto_ptr <Foo> foo (new Foo());
        ExpectationPair <Foo> pair (list, foo);
        driver.willCall (pair);
        driver.willReturn (2); // this must throw
    }

    bool foo2Ok;
    void foo2 (int a) { foo2Ok = true; }
    typedef BoundFunction <CallDriverTest, void (int)> foo2Type;
    void testReturnsOk()
    {
        CallDriver <foo2Type> driver (auto_ptr <foo2Type>
            (new foo2Type (this, &CallDriverTest::foo2, 1)));
        foo2Ok = false;
        driver.returns();
        CPPUNIT_ASSERT (foo2Ok == true);
    }

    void testWillCallOk()
    {
        typedef ExpectedFunction <void()> Foo;
        // The list owns the expected functions so it should be destroyed after
        // the call driver:
        ExpectationsList <Foo> list;
        CallDriver <foo2Type> driver (auto_ptr <foo2Type>
            (new foo2Type (this, &CallDriverTest::foo2, 1)));
        auto_ptr <Foo> foo (new Foo());
        ExpectationPair <Foo> pair (list, foo);
        ExpectationDriver <CallDriver <foo2Type>, ExpectedFunction <void()> >
            expectationDriver = driver.willCall (pair);
        list.take().check();
        driver.returns();
    }

    void testReturnsNotCalled()
    {
        try {
            CallDriver <foo2Type> driver (auto_ptr <foo2Type>
                (new foo2Type (this, &CallDriverTest::foo2, 1)));
        } catch (CPPUNIT_NS::Exception &e) {
            CPPUNIT_ASSERT (e.message() == CPPUNIT_NS::Message (
                "neither returns() nor willReturn() called for",
                "function name unavailable"));
            CPPUNIT_ASSERT (e.sourceLine() == CPPUNIT_NS::SourceLine());
            return;
        }
    }

    void testMultipleChainedWillCallOk()
    {
        typedef ExpectedFunction <void (int)> Foo;
        ExpectationsList <Foo> list;

        auto_ptr <Foo> foo1 (new Foo (1));
        auto_ptr <Foo> foo2 (new Foo (2));
        auto_ptr <Foo> foo3 (new Foo (3));

        CallDriver <foo2Type> driver (auto_ptr <foo2Type>
            (new foo2Type (this, &CallDriverTest::foo2, 1)));
        driver
            .willCall (ExpectationPair <Foo> (list, foo1))
            .returns()
            .willCall (ExpectationPair <Foo> (list, foo2))
            .returns()
            .willCall (ExpectationPair <Foo> (list, foo3))
            .returns();

        list.take().check (1);
        list.take().check (2);
        list.take().check (3);

        driver.returns();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (CallDriverTest);

} // namespace Testing
} // namespace CalitkoMocks
} // namespace Utils

Copyright © 2006 Peter Dimov.
Powered by Doxygen.