PacketFactoryTest.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 "../PacketFactory.h"
#include "../BadPacket.h"
#include "PacketStub.h"
#include "cppunit/extensions/HelperMacros.h"

namespace Protocols {
namespace Generics {
namespace Testing {

class PacketFactoryStub: public PacketFactory
{
public:
    void setDoExtractPacketReturns (bool returnValue, int headerLength,
                                    int payloadLength, int trailerLength)
    {
        doExtractReturnValue    = returnValue;
        doExtractHeaderLength   = headerLength;
        doExtractPayloadLength  = payloadLength;
        doExtractTrailerLength  = trailerLength;
    }

    bool doExtractPacket (const QByteArray &,
                          int &headerLength,
                          int &payloadLength,
                          int &trailerLength)
    {
        if (doExtractReturnValue) {
            headerLength = doExtractHeaderLength;
            payloadLength = doExtractPayloadLength;
            trailerLength = doExtractTrailerLength;
        }
        return doExtractReturnValue;
    }

    void setDoCreatePacketReturns (Packet packet)
    {
        doCreatePacketPacket = packet;
    }

    Packet doCreatePacket (const QByteArray &,
                           const QByteArray &,
                           const QByteArray &)
    {
        return doCreatePacketPacket;
    }

private:
    bool                    doExtractReturnValue;
    int                     doExtractHeaderLength;
    int                     doExtractPayloadLength;
    int                     doExtractTrailerLength;
    Packet                  doCreatePacketPacket;
};

class PacketFactoryTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (PacketFactoryTest);
    CPPUNIT_TEST (testExtractPacket);
    CPPUNIT_TEST (testCreatePacketOK);
    CPPUNIT_TEST (testCreatePacketBad);
    CPPUNIT_TEST_SUITE_END();

public:
    void setUp()
    {
    }

    void tearDown()
    {
    }

    void testExtractPacket()
    {
        {
            PacketFactoryStub factory;
            factory.setDoExtractPacketReturns (true, 2, 0, 0);
            QByteArray rawBytes (2, 0);
            int headerLength = 0, payloadLength = 0, trailerLength = 0;
            bool extracted = factory.extractPacket (rawBytes, headerLength,
                                                payloadLength, trailerLength);
            CPPUNIT_ASSERT (true == extracted);
        }
        {
            PacketFactoryStub factory;
            factory.setDoExtractPacketReturns (false, 0, 0, 0);
            QByteArray rawBytes (0, '\0');
            int headerLength = 0, payloadLength = 0, trailerLength = 0;
            bool extracted = factory.extractPacket (rawBytes, headerLength,
                                                payloadLength, trailerLength);
            CPPUNIT_ASSERT (false == extracted);
        }
    }

    void testCreatePacketOK()
    {
        PacketFactoryStub factory;
        QByteArray rawHeader (2, 1);
        QByteArray rawPayload;
        QByteArray rawTrailer;
        Packet packet = PacketStub();
        factory.setDoCreatePacketReturns (packet); // i.e. return the stub
        packet = factory.createPacket (rawHeader, rawPayload, rawTrailer);
        CPPUNIT_ASSERT (typeid (*packet) == typeid (PacketStub));
    }

    void testCreatePacketBad()
    {
        {
            PacketFactoryStub factory;
            QByteArray rawHeader (2, 1);
            QByteArray rawPayload (1, 0);
            QByteArray rawTrailer;
            // Create a packet for which parse() will return false
            // (rawPayload will NOT match the value expected by the stub):
            Packet packet;
            packet = PacketStub (rawHeader, rawTrailer, true);
            factory.setDoCreatePacketReturns (packet); // i.e. return the stub
            packet = factory.createPacket (rawHeader, rawPayload, rawTrailer);
            CPPUNIT_ASSERT (typeid (*packet) == typeid (BadPacket));
        }
        {
            PacketFactoryStub factory;
            QByteArray rawHeader (2, 0);
            QByteArray rawPayload;
            QByteArray rawTrailer;
            Packet packet;
            factory.setDoCreatePacketReturns (packet); // Packet() is BadPacket.
            packet = factory.createPacket (rawHeader, rawPayload, rawTrailer);
            CPPUNIT_ASSERT (typeid (*packet) == typeid (BadPacket));
        }
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (PacketFactoryTest);

} // namespace Testing
} // namespace Generics
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.