ExpectedFunctionTest.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 "Imports.cpp"

#define TEST_MESSAGE(summary, description)  \
    CPPUNIT_ASSERT (e.message() == Message (summary, description))

#define TEST_SOURCELINE(filename, line)     \
    CPPUNIT_ASSERT (e.sourceLine() == SourceLine (filename, line))

namespace Utils {
namespace CalitkoMocks {
namespace Testing {


class ExpectedFunctionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (ExpectedFunctionTest);
    CPPUNIT_TEST (testVoidVoidChecked);
    CPPUNIT_TEST (testVoidVoidNotChecked);
    CPPUNIT_TEST (testIntIntOk);
    CPPUNIT_TEST (testIntIntCallFails);
    CPPUNIT_TEST_FAIL (testIntIntReturnFails);
    CPPUNIT_TEST (testIntIntNoReturnSetFail);
    CPPUNIT_TEST (testIntIntNoReturnSetFailWithContext);
    CPPUNIT_TEST (testIntRefVoidOk);
    CPPUNIT_TEST (testVoidConstIntRefOk);
    CPPUNIT_TEST (testVoidIntRefOk);
    CPPUNIT_TEST_FAIL (testVoidIntRefNotSameIdentity);
    CPPUNIT_TEST (testVoidVoidWithCallsOk);
    CPPUNIT_TEST (testVoidVoidWithCallReturnIncorrect);
    CPPUNIT_TEST_SUITE_END();

public:
    void testVoidVoidChecked()
    {
        ExpectedFunction <void ()> foo;
        foo.check();
        foo.verifyChecked();
    }

    void testVoidVoidNotChecked()
    {
        ExpectedFunction <void ()> foo;
        try {
            foo.verifyChecked();
        } catch (CPPUNIT_NS::Exception &e) {
            TEST_MESSAGE ("function not called", "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // Should have thrown above!
    }

    void testIntIntOk()
    {
        ExpectedFunction <int (int)> foo (1);
        foo.willReturn (2);
        CPPUNIT_ASSERT (foo.check (1) == 2);
    }

    void testIntIntCallFails()
    {
        ExpectedFunction <int (int)> foo (1);
        foo.willReturn (2);
        try {
            foo.check (2);
        } catch (CPPUNIT_NS::Exception &e) {
            TEST_MESSAGE ("willCall() expectation failed",
                          "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch returns
    }

    void testIntIntReturnFails()
    {
        ExpectedFunction <int (int)> foo (1);
        foo.willReturn (2);
        CPPUNIT_ASSERT (foo.check (1) == 1);
    }

    void testIntIntNoReturnSetFail()
    {
        ExpectedFunction <int (int)> foo (1);
        try {
            foo.check (1);
        } catch (CPPUNIT_NS::Exception &e) {
            TEST_MESSAGE ("willReturn() not called for",
                          "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch returns
    }

    void testIntIntNoReturnSetFailWithContext()
    {
        ExpectedFunction <int (int)> foo (1);
        foo.setContext ("test expectation string",
                        CPPUNIT_NS::SourceLine ("file.cpp", 123));
        try {
            foo.check (1);
        } catch (CPPUNIT_NS::Exception &e) {
            TEST_MESSAGE ("willReturn() not called for",
                          "test expectation string");
            TEST_SOURCELINE ("file.cpp", 123);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch returns
    }

    void testIntRefVoidOk()
    {
        ExpectedFunction <int & ()> foo;
        int i = 0;
        foo.willReturn (i);
        int &y = foo.check();
        CPPUNIT_ASSERT (&y == &i);
    }


    void testVoidConstIntRefOk()
    {
        ExpectedFunction <void (const int &)> foo (1);
        foo.check (1);
    }

    void testVoidIntRefOk()
    {
        int x = 1;
        ExpectedFunction <void (int &)> foo (x);
        foo.check (x);
    }

    void testVoidIntRefNotSameIdentity()
    {
        int x = 1;
        int y = 1;
        ExpectedFunction <void (int &)> foo (x);
        foo.check (y);
    }

    void VoidVoidCall (int &a) { ++a; }
    typedef BoundFunction <ExpectedFunctionTest, void (int &)> VoidVoidCallType;
    void testVoidVoidWithCallsOk()
    {
        int a = 0;
        ExpectedFunction <void ()> foo;
        // Prepare the bound function, which foo is supposed to call:
        auto_ptr <VoidVoidCallType> call1 (new VoidVoidCallType
            (this, &ExpectedFunctionTest::VoidVoidCall, a));
        auto_ptr <VoidVoidCallType> call2 (new VoidVoidCallType
            (this, &ExpectedFunctionTest::VoidVoidCall, a));
        // Register the calls:
        foo.addCall (auto_ptr <BoundFunctionBase> (call1.get()));
        call1.release(); // Now foo owns the BoundFunction object.
        foo.addCall (auto_ptr <BoundFunctionBase> (call2.get()));
        call2.release(); // Now foo owns the BoundFunction object.
        foo.check();
        // After checking the expectation, VoidVoidCall must have been called
        // twice with the value of a passed by reference:
        CPPUNIT_ASSERT (a == 2);
    }

    int VoidVoidCall2() { return 1; }
    typedef BoundFunction <ExpectedFunctionTest, int ()> VoidVoidCall2Type;
    void testVoidVoidWithCallReturnIncorrect()
    {
        ExpectedFunction <void ()> foo;
        // Prepare the bound function, which foo is supposed to call:
        auto_ptr <VoidVoidCall2Type> call1 (new VoidVoidCall2Type
            (this, &ExpectedFunctionTest::VoidVoidCall2));
        call1->willReturn (2);
        // Register the calls:
        foo.addCall (auto_ptr <BoundFunctionBase> (call1.get()));
        call1.release(); // Now foo owns the BoundFunction object.
        try {
            foo.check();
        } catch (CPPUNIT_NS::Exception &e) {
            TEST_MESSAGE ("willReturn() expectation failed",
                          "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (ExpectedFunctionTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.