ObjectDispatcherTest.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 "../ObjectDispatcher.h"
#include "Imports.cpp"

namespace Utils {
namespace Testing {

class Packet
{
public:
    virtual ~Packet() {}
            Packet() {}
};

class PacketA : public Packet
{
public:
    PacketA() {}
};

class PacketB : public Packet
{
public:
    PacketB() {}
};


class ObjectDispatcherTest : public CppUnit::TestFixture
{
    // \ŧodo Derive from a common base  that is a reference object!
    REFERENCE_OBJECT (ObjectDispatcherTest)

    CPPUNIT_TEST_SUITE (ObjectDispatcherTest);
    CPPUNIT_TEST (testNoHandlersSetNothingHappens);
    CPPUNIT_TEST (testSetStaticHandlersAndDispatchToThem);
    CPPUNIT_TEST (testSetMemberHandlersAndDispatchToThem);
    CPPUNIT_TEST (testSetCatchAllHandlerAndDispatchToIt);
    CPPUNIT_TEST (testHandlersCalledInTheirRegistrationOrder);
    CPPUNIT_TEST (testNotHandledHandlersOnlyCalledIfNoTypeHandlerRegistered);
    CPPUNIT_TEST (testStaticCatchAllHandlerWithSender);
    CPPUNIT_TEST (testUnregisterTypeHandlers);
    CPPUNIT_TEST_SUITE_END();

    typedef ObjectDispatcher <Packet, ObjectDispatcherTest> PacketDispatcher;
    auto_ptr <PacketDispatcher>         dispatcher;

    static const PacketA                packetA;
    static const PacketB                packetB;

    static bool hasCalledStaticHandlerPacketA;
    static void staticHandlerPacketA (const PacketA &packet)
    {
        CPPUNIT_ASSERT (&packet == &packetA);
        hasCalledStaticHandlerPacketA = true;
    }

    static bool hasCalledStaticHandlerPacketB;
    static void staticHandlerPacketB (const PacketB &packet)
    {
        CPPUNIT_ASSERT (&packet == &packetB);
        hasCalledStaticHandlerPacketB = true;
    }

    static bool hasCalledStaticCatchAllHandler;
    static void staticCatchAllHandler (const Packet &)
    {
        hasCalledStaticCatchAllHandler = true;
    }

    bool hasCalledMemberHandlerPacketA;
    void memberHandlerPacketA (const PacketA &packet)
    {
        CPPUNIT_ASSERT (&packet == &packetA);
        hasCalledMemberHandlerPacketA = true;
    }

    bool hasCalledMemberHandlerPacketA2;
    void memberHandlerPacketA2 (const PacketA &packet)
    {
        CPPUNIT_ASSERT (&packet == &packetA);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA == true);
        hasCalledMemberHandlerPacketA2 = true;
    }

    bool hasCalledMemberHandlerPacketB;
    void memberHandlerPacketB (const PacketB &packet)
    {
        CPPUNIT_ASSERT (&packet == &packetB);
        hasCalledMemberHandlerPacketB = true;
    }

    bool hasCalledMemberCatchAllHandler;
    void memberCatchAllHandler (const Packet &)
    {
        hasCalledMemberCatchAllHandler = true;
    }

    bool hasCalledMemberCatchAllHandlerWithSender;
    void memberCatchAllHandlerWithSender (const Packet &,
                                          ObjectDispatcherTest *sender)
    {
        hasCalledMemberCatchAllHandlerWithSender = true;
        CPPUNIT_ASSERT (sender == this);
    }

public:
    ObjectDispatcherTest()
     :  dispatcher(),
        hasCalledMemberHandlerPacketA (false),
        hasCalledMemberHandlerPacketA2 (false),
        hasCalledMemberHandlerPacketB (false),
        hasCalledMemberCatchAllHandler (false),
        hasCalledMemberCatchAllHandlerWithSender (false)
    {
    }

    void setUp()
    {
        dispatcher.reset (new PacketDispatcher);
    }

    void tearDown()
    {
        dispatcher.reset();
    }

    void testNoHandlersSetNothingHappens()
    {
        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == false);
    }

    void testSetStaticHandlersAndDispatchToThem()
    {
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (&staticHandlerPacketA));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketB &)> (&staticHandlerPacketB));

        hasCalledStaticHandlerPacketA = false;
        hasCalledStaticHandlerPacketB = false;

        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledStaticHandlerPacketA == true);
        CPPUNIT_ASSERT (hasCalledStaticHandlerPacketB == false);

        isDispatched = dispatcher->dispatch (packetB);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledStaticHandlerPacketB == true);
    }

    void testSetMemberHandlersAndDispatchToThem()
    {
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketB &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketB));

        hasCalledMemberHandlerPacketA = false;
        hasCalledMemberHandlerPacketB = false;

        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketB == false);

        isDispatched = dispatcher->dispatch (packetB);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketB == true);
    }

    void testSetCatchAllHandlerAndDispatchToIt()
    {
        dispatcher->registerCatchAllHandler (
            Callable <void (const Packet &)> (&staticCatchAllHandler));
        dispatcher->registerCatchAllHandler (
            Callable <void (const Packet &)> (
                this, &ObjectDispatcherTest::memberCatchAllHandler));

        hasCalledStaticCatchAllHandler = false;
        hasCalledMemberCatchAllHandler = false;
        dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (hasCalledStaticCatchAllHandler == true);
        CPPUNIT_ASSERT (hasCalledMemberCatchAllHandler == true);

        hasCalledStaticCatchAllHandler = false;
        hasCalledMemberCatchAllHandler = false;
        dispatcher->dispatch (packetB);
        CPPUNIT_ASSERT (hasCalledStaticCatchAllHandler == true);
        CPPUNIT_ASSERT (hasCalledMemberCatchAllHandler == true);
    }

    void testHandlersCalledInTheirRegistrationOrder()
    {
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA2));

        hasCalledMemberHandlerPacketA = false;
        hasCalledMemberHandlerPacketA2 = false;

        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA2 == true);
        // The call order is checked in memberHandlerPacketA2().
    }

    void testNotHandledHandlersOnlyCalledIfNoTypeHandlerRegistered()
    {
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA));
        dispatcher->registerNotHandledHandler (
            Callable <void (const Packet &)> (
                this, &ObjectDispatcherTest::memberCatchAllHandler));
        dispatcher->registerNotHandledHandler (
            Callable <void (const Packet &)> (&staticCatchAllHandler));

        hasCalledMemberHandlerPacketA = false;
        hasCalledMemberCatchAllHandler = false;
        hasCalledStaticCatchAllHandler = false;
        // Not-handled handlers not invoked as a type handler is found:
        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA == true);
        CPPUNIT_ASSERT (hasCalledMemberCatchAllHandler == false);
        CPPUNIT_ASSERT (hasCalledStaticCatchAllHandler == false);
        // No type handler found, the not-handled handlers get invoked:
        isDispatched = dispatcher->dispatch (packetB);
        CPPUNIT_ASSERT (isDispatched == false);
        CPPUNIT_ASSERT (hasCalledMemberCatchAllHandler == true);
        CPPUNIT_ASSERT (hasCalledStaticCatchAllHandler == true);
    }

    void testStaticCatchAllHandlerWithSender()
    {
        dispatcher->registerCatchAllHandler (
            Callable <void (const Packet &, ObjectDispatcherTest *)> (
                this, &ObjectDispatcherTest::memberCatchAllHandlerWithSender));

        hasCalledMemberCatchAllHandlerWithSender = false;
        bool isDispatched = dispatcher->dispatch (packetA, this);
        CPPUNIT_ASSERT (isDispatched == false);
        CPPUNIT_ASSERT (hasCalledMemberCatchAllHandlerWithSender == true);
    }

    void testUnregisterTypeHandlers()
    {
        // Register numerous type handlers first:
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (&staticHandlerPacketA));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketB &)> (&staticHandlerPacketB));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA));
        dispatcher->registerTypeHandler (
            Callable <void (const PacketB &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketB));
        // Unregister some of the registered type handlers next:
        dispatcher->unregisterTypeHandler (
            Callable <void (const PacketA &)> (&staticHandlerPacketA));
        dispatcher->unregisterTypeHandler (
            Callable <void (const PacketB &)> (&staticHandlerPacketB));

        // Verify that only the ones still registered were invoked:
        hasCalledStaticHandlerPacketA = false;
        hasCalledStaticHandlerPacketB = false;
        hasCalledMemberHandlerPacketA = false;
        hasCalledMemberHandlerPacketB = false;

        bool isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == true);
        CPPUNIT_ASSERT (hasCalledStaticHandlerPacketA == false);
        CPPUNIT_ASSERT (hasCalledStaticHandlerPacketB == false);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketA == true);
        CPPUNIT_ASSERT (hasCalledMemberHandlerPacketB == false);

        // Unregister the rest too:
        dispatcher->unregisterTypeHandler (
            Callable <void (const PacketA &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketA));
        dispatcher->unregisterTypeHandler (
            Callable <void (const PacketB &)> (
                this, &ObjectDispatcherTest::memberHandlerPacketB));
        // Finally check that the object could not be dispatched (no handlers):
        isDispatched = dispatcher->dispatch (packetA);
        CPPUNIT_ASSERT (isDispatched == false);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(ObjectDispatcherTest);

bool ObjectDispatcherTest::hasCalledStaticHandlerPacketA = false;
bool ObjectDispatcherTest::hasCalledStaticHandlerPacketB = false;
bool ObjectDispatcherTest::hasCalledStaticCatchAllHandler = false;
const PacketA ObjectDispatcherTest::packetA;
const PacketB ObjectDispatcherTest::packetB;

} // namespace Testing
} // namespace Utils

Copyright © 2006 Peter Dimov.
Powered by Doxygen.