PacketSessionTest.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 "../PacketSession.h"
#include "generated/PacketSessionDriver.h"
#include "Imports.cpp"

namespace Protocols {
namespace BitTorrent {
namespace Transfers {
namespace Testing {


class PacketSessionTest : public CppUnit::TestFixture
{
    // \todo Maybe derive from a common base that is a REFERENCE_OBJECT?
    REFERENCE_OBJECT (PacketSessionTest)

    CPPUNIT_TEST_SUITE (PacketSessionTest);
    CPPUNIT_TEST (testReadNothing);
    CPPUNIT_TEST (testReadOnePacket);
    CPPUNIT_TEST (testReadTwoPackets);
    CPPUNIT_TEST (testReadOnePacketAndHalfPacketStillBuffered);
    CPPUNIT_TEST (testSendPacketWritesPacketDirectly);
    CPPUNIT_TEST (testSendTwoPacketsBuffersThem);
    CPPUNIT_TEST (testSendTwoPacketsBuffersThemThenWritesThem);
    CPPUNIT_TEST_SUITE_END();

    TransportStub                   *transport;
    auto_ptr <SessionStatusMock>    status;
    auto_ptr <PacketSession>        sessionReal;
    auto_ptr <PacketSessionDriver>  session;

    const Packet                    packet1;
    const Packet                    packet2;
    const QByteArray                halfPacketBytes;

public:
    PacketSessionTest()
    :   transport (0), status(), sessionReal(), session(),
        packet1 (Keepalive()), packet2 (Choke()), halfPacketBytes ("12")
    {
    }

    void setUp()
    {
        transport = new TransportStub();
        auto_ptr <Transport> temp (transport);
        status.reset (new SessionStatusMock);
        sessionReal.reset (new PacketSession (temp, *status));
        session.reset (new PacketSessionDriver (*sessionReal));
    }

    void tearDown()
    {
        session.reset();
        sessionReal.reset();
        status.reset();
        transport = 0; // No need for delete, session owns the object.
    }

    void stateOpenedSession()
    {
        call (session->open())
        .returns();
    }

    void testReadNothing()
    {
        stateOpenedSession();

        call (session->transportReadyRead (transport))
        .returns();
    }

    void testReadOnePacket()
    {
        stateOpenedSession();

        Packet packet = Keepalive();
        transport->readBuffer = packet->rawPacket();

        call (session->transportReadyRead (transport))
            .willCall (status->sessionReceivedData (*session, packet))
            .returns()
        .returns();

        willBeEqual (transport->readBuffer, QByteArray());
    }

    void testReadTwoPackets()
    {
        stateOpenedSession();

        transport->readBuffer = packet1->rawPacket() + packet2->rawPacket();

        call (session->transportReadyRead (transport))
            .willCall (status->sessionReceivedData (*session, packet1))
            .returns()
            .willCall (status->sessionReceivedData (*session, packet2))
            .returns()
        .returns();

        willBeEqual (transport->readBuffer, QByteArray());
    }

    void testReadOnePacketAndHalfPacketStillBuffered()
    {
        stateOpenedSession();

        transport->readBuffer = packet1->rawPacket() + halfPacketBytes;

        call (session->transportReadyRead (transport))
            .willCall (status->sessionReceivedData (*session, packet1))
            .returns()
        .returns();

        willBeEqual (transport->readBuffer, halfPacketBytes);
    }

    void testSendPacketWritesPacketDirectly()
    {
        stateOpenedSession();

        transport->writeBuffer.reserve (packet1->rawPacket().size());

        call (session->send (packet1))
            .willCall (status->sessionSendingData (*session, packet1))
            .returns()
        .returns();

        willBeEqual (transport->writeBuffer, packet1->rawPacket());
    }

    void testSendTwoPacketsBuffersThem()
    {
        stateOpenedSession();

        transport->writeBuffer.reserve (0); // Disables writing to Transport.

        call (session->send (packet1))
            .willCall (status->sessionSendingData (*session, packet1))
            .returns()
        .returns();
        call (session->send (packet2))
            .willCall (status->sessionSendingData (*session, packet2))
            .returns()
        .returns();

        willBeEqual (transport->writeBuffer, QByteArray());
    }

    void testSendTwoPacketsBuffersThemThenWritesThem()
    {
        testSendTwoPacketsBuffersThem();

        // Enable writing to Transport:
        transport->writeBuffer.reserve (packet1->rawPacket().size()
                                        + packet2->rawPacket().size());

        call (session->transportReadyWrite (transport))
        .returns();

        willBeEqual (transport->writeBuffer,
                     packet1->rawPacket() + packet2->rawPacket());
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(PacketSessionTest);

} // namespace Testing
} // namespace Transfers
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.