PacketSerializerTest.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 "../BadPacket.h"
#include "generated/PacketSerializerDriver.h"
#include "generated/PacketProtocolMock.h"
#include "generated/TransportMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {


class PacketSerializerTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(PacketSerializerTest);
    CPPUNIT_TEST (testReadPacketSucceeds);
    CPPUNIT_TEST (testReadPacketFailsCannotPeekHeader);
    CPPUNIT_TEST (testReadPacketFailsPeeksHeaderButCannotReadCompletePacket);
    CPPUNIT_TEST (testWritePacketSucceeds);
    CPPUNIT_TEST (testWritePacketFailsCannotWriteCompletePacket);
    CPPUNIT_TEST_SUITE_END();

    static const QByteArray                 header;
    static const QByteArray                 payload;
    static const Packet                     packet;

    auto_ptr <TransportMock>                transport;
    auto_ptr <PacketProtocolMock>           packetProtocol;
    auto_ptr <PacketSerializer>             serializerReal;
    auto_ptr <PacketSerializerDriver>       serializer;

public:
    PacketSerializerTest()
     :  transport(), packetProtocol(), serializerReal(), serializer()
    {
    }

    void setUp()
    {
        transport.reset (new TransportMock);
        packetProtocol.reset (new PacketProtocolMock);
        serializerReal.reset (new PacketSerializer (*packetProtocol));
        serializer.reset (new PacketSerializerDriver (*serializerReal.get()));
    }

    void tearDown()
    {
        serializer.reset();
        serializerReal.reset();
        packetProtocol.reset();
        transport.reset();
    }

    void testReadPacketSucceeds()
    {
        Data outPacket;
        call (serializer->read (outPacket, *transport))
            .willCall (packetProtocol->headerLength())
            .willReturn (header.length())
            .willCall (transport->peek (header.length()))
            .willReturn (header)
            .willCall (packetProtocol->payloadLength (header))
            .willReturn (payload.length())
            .willCall (transport->canRead (header.length() + payload.length()))
            .willReturn (true)
            .willCall (transport->read (header.length()))
            .willReturn (header)
            .willCall (transport->read (payload.length()))
            .willReturn (payload)
            .willCall (packetProtocol->createPacket (header, payload))
            .willReturn (packet)
        .willReturn (true);
        // The out parameter outPacket must have been correctly set:
        willBeEqual (Data (packet), outPacket);
    }

    void testReadPacketFailsCannotPeekHeader()
    {
        Data outPacket;
        call (serializer->read (outPacket, *transport))
            .willCall (packetProtocol->headerLength())
            .willReturn (header.length())
            .willCall (transport->peek (header.length()))
            .willReturn (QByteArray())
        .willReturn (false);
        // The out parameter outPacket must have been correctly set:
        willBeEqual (Data(), outPacket);
    }

    void testReadPacketFailsPeeksHeaderButCannotReadCompletePacket()
    {
        Data outPacket;
        call (serializer->read (outPacket, *transport))
            .willCall (packetProtocol->headerLength())
            .willReturn (header.length())
            .willCall (transport->peek (header.length()))
            .willReturn (header)
            .willCall (packetProtocol->payloadLength (header))
            .willReturn (payload.length())
            .willCall (transport->canRead (header.length() + payload.length()))
            .willReturn (false)
        .willReturn (false);
        // The out parameter outPacket must have been correctly set:
        willBeEqual (Data(), outPacket);
    }

    void testWritePacketSucceeds()
    {
        call (serializer->write (packet, *transport))
            .willCall (transport->canWrite (header.length() + payload.length()))
            .willReturn (true)
            .willCall (transport->write (header, false))
            .willReturn (true)
            .willCall (transport->write (payload, true))
            .willReturn (true)
        .willReturn (true);
    }

    void testWritePacketFailsCannotWriteCompletePacket()
    {
        call (serializer->write (packet, *transport))
            .willCall (transport->canWrite (header.length() + payload.length()))
            .willReturn (false)
        .willReturn (false);
    }
};

const QByteArray PacketSerializerTest::header = QByteArray ("header");
const QByteArray PacketSerializerTest::payload = QByteArray ("payload");
const Packet PacketSerializerTest::packet = BadPacket (header, payload);

CPPUNIT_TEST_SUITE_REGISTRATION(PacketSerializerTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.