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

#define TEST_VOID_FOO(type)             \
    type##Ok = false; foo.call();       \
    CPPUNIT_ASSERT (type##Ok == true)

#define TEST_FOO(type, ret)             \
    type##Ok = false;                   \
    foo.willReturn (ret);               \
    foo.call();                         \
    CPPUNIT_ASSERT (type##Ok == true)

#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 BoundFunctionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (BoundFunctionTest);
    CPPUNIT_TEST (testVoidVoid);
    CPPUNIT_TEST (testIntVoid);
    CPPUNIT_TEST (testIntVoidReturnIncorrect);
    CPPUNIT_TEST (testIntVoidReturnNotSet);
    CPPUNIT_TEST (testIntVoidReturnNotSetWithContext);
    CPPUNIT_TEST (testIntInt);
    CPPUNIT_TEST (testBoolRefIntRefConstIntRef);
    CPPUNIT_TEST (testIntIntWithExpectationsOk);
    CPPUNIT_TEST (testIntIntWithExpectationsBadCheckFail);
    CPPUNIT_TEST (testIntIntWithExpectationsNotCheckedFail);
    CPPUNIT_TEST (testVoidIntWithExpectationsNotCheckedFail);
    CPPUNIT_TEST (testVoidIntFailSetOwnContextIfNotSet);
    CPPUNIT_TEST_SUITE_END();

public:
    bool VoidVoidOk;
    void VoidVoid() { VoidVoidOk = true; }
    void testVoidVoid()
    {
        BoundFunction <BoundFunctionTest, void ()>
            foo (this, &BoundFunctionTest::VoidVoid);
        TEST_VOID_FOO (VoidVoid);
    }

    bool IntVoidOk;
    int IntVoid() { IntVoidOk = true; return 3; }
    void testIntVoid()
    {
        BoundFunction <BoundFunctionTest, int ()>
            foo (this, &BoundFunctionTest::IntVoid);
        TEST_FOO (IntVoid, 3);
    }

    void testIntVoidReturnIncorrect()
    {
        BoundFunction <BoundFunctionTest, int ()>
            foo (this, &BoundFunctionTest::IntVoid);
        try {
            TEST_FOO (IntVoid, 2);
        } catch (Exception &e) {
            TEST_MESSAGE ("willReturn() expectation failed",
                          "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }

    void testIntVoidReturnNotSet()
    {
        BoundFunction <BoundFunctionTest, int ()>
            foo (this, &BoundFunctionTest::IntVoid);
        try {
            foo.call();
        } catch (Exception &e) {
            TEST_MESSAGE ("willReturn() not called for",
                          "function name unavailable");
            TEST_SOURCELINE ("", -1);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }

    void testIntVoidReturnNotSetWithContext()
    {
        BoundFunction <BoundFunctionTest, int ()>
            foo (this, &BoundFunctionTest::IntVoid);
        foo.setContext ("test expectation string",
                        SourceLine ("file.cpp", 123));
        try {
            foo.call();
        } catch (Exception &e) {
            TEST_MESSAGE ("willReturn() not called for",
                          "test expectation string");
            TEST_SOURCELINE ("file.cpp", 123);
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }

    bool IntIntOk;
    int IntInt (int a) { IntIntOk = (a == 1); return 3; }
    void testIntInt()
    {
        BoundFunction <BoundFunctionTest, int (int)>
            foo (this, &BoundFunctionTest::IntInt, 1);
        TEST_FOO (IntInt, 3);
    }

    bool BoolRefIntRefConstIntRefOk;
    bool & BoolRefIntRefConstIntRef (int &a, const int &b)
    { BoolRefIntRefConstIntRefOk = (a == 1 && b == 2);
      return BoolRefIntRefConstIntRefOk; }
    void testBoolRefIntRefConstIntRef()
    {
        int a = 1;
        bool res = true;
        BoundFunction <BoundFunctionTest, bool & (int &, const int &)>
            foo (this, &BoundFunctionTest::BoolRefIntRefConstIntRef, a, 2);
        TEST_FOO (BoolRefIntRefConstIntRef, res);
    }

    auto_ptr <ExpectedFunction <void (int)> > IntIntExpectation1;
    auto_ptr <ExpectedFunction <void (int)> > IntIntExpectation2;

    int IntIntWithExpectations (int)
    {
        IntIntExpectation1->check (1);
        IntIntExpectation2->check (2);
        return 3;
    }

    void testIntIntWithExpectationsOk()
    {
        BoundFunction <BoundFunctionTest, int (int)>
            foo (this, &BoundFunctionTest::IntIntWithExpectations, 1);
        // Setup the expectations manipulated in IntIntWithExpectations():
        IntIntExpectation1.reset (new ExpectedFunction <void (int)> (1));
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Register the expectations, which the bound function should verify:
        foo.addExpectation (IntIntExpectation1.get());
        foo.addExpectation (IntIntExpectation2.get());
        foo.willReturn (3);
        foo.call();
    }

    void testIntIntWithExpectationsBadCheckFail()
    {
        BoundFunction <BoundFunctionTest, int (int)>
            foo (this, &BoundFunctionTest::IntIntWithExpectations, 1);
        // Setup the expectations manipulated in IntIntWithExpectations():
        IntIntExpectation1.reset (new ExpectedFunction <void (int)> (1));
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (3));
        // Register the expectations, which the bound function should verify:
        foo.addExpectation (IntIntExpectation1.get());
        foo.addExpectation (IntIntExpectation2.get());
        foo.willReturn (3);
        try {
            foo.call();
        } catch (Exception &e) {
            // The exception must have been thrown by ExpectedFunction.
            TEST_MESSAGE ("willCall() expectation failed",
                          "function name unavailable");
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }

    void testIntIntWithExpectationsNotCheckedFail()
    {
        BoundFunction <BoundFunctionTest, int (int)>
            foo (this, &BoundFunctionTest::IntIntWithExpectations, 1);
        // Setup the expectations manipulated in IntIntWithExpectations():
        IntIntExpectation1.reset (new ExpectedFunction <void (int)> (1));
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Make a local expectation that we register but do not actually check:
        auto_ptr <ExpectedFunction <void (int)> > IntIntExpectation2;
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Register the expectations, which the bound function should verify:
        foo.addExpectation (IntIntExpectation1.get());
        foo.addExpectation (IntIntExpectation2.get());
        foo.willReturn (3);
        try {
            foo.call();
        } catch (Exception &e) {
            // The exception must have been thrown by ExpectedFunction.
            TEST_MESSAGE ("function not called", "function name unavailable");
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }

    void VoidIntWithExpectations (int v)
    {
        IntIntWithExpectations (v);
    }

    void testVoidIntWithExpectationsNotCheckedFail()
    {
        BoundFunction <BoundFunctionTest, void (int)>
            foo (this, &BoundFunctionTest::VoidIntWithExpectations, 1);
        // Setup the expectations manipulated in IntIntWithExpectations():
        IntIntExpectation1.reset (new ExpectedFunction <void (int)> (1));
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Make a local expectation that we register but do not actually check:
        auto_ptr <ExpectedFunction <void (int)> > IntIntExpectation2;
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Register the expectations, which the bound function should verify:
        foo.addExpectation (IntIntExpectation1.get());
        foo.addExpectation (IntIntExpectation2.get());
        try {
            foo.call();
        } catch (Exception &e) {
            // The exception must have been thrown by ExpectedFunction.
            TEST_MESSAGE ("function not called", "function name unavailable");
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }


    void testVoidIntFailSetOwnContextIfNotSet()
    {
        BoundFunction <BoundFunctionTest, void (int)>
            foo (this, &BoundFunctionTest::VoidIntWithExpectations, 1);
        foo.setContext ("blah", SourceLine ("file.cpp", 123));
        // Setup the expectations manipulated in IntIntWithExpectations():
        IntIntExpectation1.reset (new ExpectedFunction <void (int)> (1));
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Make a local expectation that we register but do not actually check:
        auto_ptr <ExpectedFunction <void (int)> > IntIntExpectation2;
        IntIntExpectation2.reset (new ExpectedFunction <void (int)> (2));
        // Register the expectations, which the bound function should verify:
        foo.addExpectation (IntIntExpectation1.get());
        foo.addExpectation (IntIntExpectation2.get());
        try {
            foo.call();
        } catch (Exception &e) {
            // The exception must have been thrown by ExpectedFunction.
            TEST_MESSAGE ("function not called", "function name unavailable");
            CPPUNIT_ASSERT (e.sourceLine() == SourceLine ("file.cpp", 123));
            return;
        }
        CPPUNIT_ASSERT (false); // we expect the catch to return
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (BoundFunctionTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.