PacketProtocolTest.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 "../PacketProtocol.h"
#include "../BadPacket.h"
#include "../BitField.h"
#include "../Cancel.h"
#include "../Choke.h"
#include "../Have.h"
#include "../Interested.h"
#include "../Keepalive.h"
#include "../NotInterested.h"
#include "../Piece.h"
#include "../Request.h"
#include "../Unchoke.h"
#include "Imports.cpp"

namespace Protocols {
namespace BitTorrent {
namespace Packets {
namespace Testing {

// \todo test HaveAll, HaveNone, AllowedFast, SuggestPiece, RejectRequest
// \todo rename to PacketProtocolTest !!!
class PacketFactoryTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (PacketFactoryTest);
    CPPUNIT_TEST (testHeaderLengthReturns4);
    CPPUNIT_TEST (testPayloadLengthIs0);
    CPPUNIT_TEST (testPayloadLengthIs1);
    CPPUNIT_TEST (testPayloadLengthIs12345);
    CPPUNIT_TEST (testCreatePacketKeepalive);
    CPPUNIT_TEST (testCreatePacketChoke);
    CPPUNIT_TEST (testCreatePacketUnchoke);
    CPPUNIT_TEST (testCreatePacketInterested);
    CPPUNIT_TEST (testCreatePacketNotInterested);
    CPPUNIT_TEST (testCreatePacketHave);
    CPPUNIT_TEST (testCreatePacketBitField);
    CPPUNIT_TEST (testCreatePacketRequest);
    CPPUNIT_TEST (testCreatePacketPiece);
    CPPUNIT_TEST (testCreatePacketCancel);
    CPPUNIT_TEST (testCreateBadPacketUnknownType);
    CPPUNIT_TEST (testCreateBadPacketChoke);
    CPPUNIT_TEST (testCreateBadPacketUnchoke);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <PacketProtocol>   protocol;

public:
    PacketFactoryTest() : protocol()
    {
    }

    void setUp()
    {
        protocol.reset (new PacketProtocol());
    }

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

    void testHeaderLengthReturns4()
    {
        willBeEqual (protocol->headerLength(), 4);
    }

    void testPayloadLengthIs0()
    {
        QByteArray header ("\0\0\0\0", 4);
        willBeEqual (protocol->payloadLength (header), 0);
    }

    void testPayloadLengthIs1()
    {
        QByteArray header ("\0\0\0\x1", 4);
        willBeEqual (protocol->payloadLength (header), 1);
    }

    void testPayloadLengthIs12345()
    {
        QByteArray header ("\0\0\x30\x39", 4);
        willBeEqual (protocol->payloadLength (header), 12345);
    }

    void scenarioCreatePacket (const QByteArray &header,
                               const QByteArray &payload,
                               const PacketBase &packet)
    {
        willBeEqual (protocol->createPacket (header, payload),
                     GenericsPacket (packet));
    }

    void testCreatePacketKeepalive()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\0", 4),
                              QByteArray (""),
                              Keepalive());
    }

    void testCreatePacketChoke()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x1", 4),
                              QByteArray ("\x0", 1),
                              Choke());
    }

    void testCreatePacketUnchoke()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x1", 4),
                              QByteArray ("\x1", 1),
                              Unchoke());
    }

    void testCreatePacketInterested()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x1", 4),
                              QByteArray ("\x2", 1),
                              Interested());
    }

    void testCreatePacketNotInterested()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x1", 4),
                              QByteArray ("\x3", 1),
                              NotInterested());
    }

    void testCreatePacketHave()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x5", 4),
                              QByteArray ("\x4\x1\x2\x3\x4", 5),
                              Have (16909060));
    }

    void testCreatePacketBitField()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\x5", 4),
                              QByteArray ("\x5\x1\x2\x3\x4", 5),
                              BitField (QByteArray ("\x1\x2\x3\x4", 4)));
    }

    void testCreatePacketRequest()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\xd", 4),
                              QByteArray ("\x6\0\0\0\x1\0\0\0\x2\0\0\0\x3", 13),
                              Request (1,2, 3));
    }

    void testCreatePacketPiece()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\xf", 4),
                              QByteArray ("\x7\0\0\0\x1\0\0\0\x2\0\0\0\x3\0\0", 15),
                              Piece (1,2, QByteArray ("\0\0\0\x3\0\0", 6)));
    }

    void testCreatePacketCancel()
    {
        scenarioCreatePacket (QByteArray ("\0\0\0\xd", 4),
                              QByteArray ("\x8\0\0\0\x1\0\0\0\x2\0\0\0\x3", 13),
                              Cancel (1,2, 3));
    }

    void scenarioCreateBadPacket (const QByteArray &header,
                                  const QByteArray &payload)
    {
        PacketType type = static_cast <PacketType> (payload.at(0));
        scenarioCreatePacket (header, payload,
                              BadPacket (type, header, payload));
    }

    void testCreateBadPacketUnknownType()
    {
        scenarioCreateBadPacket (QByteArray ("\0\0\0\xa", 4),
                                 QByteArray ("\xef\0\0\0\x1\0\0\0\x2\0", 10));
    }

    void testCreateBadPacketChoke()
    {
        scenarioCreateBadPacket (QByteArray ("\0\0\0\xa", 4),
                                 QByteArray ("\x0\0\0\0\x1\0\0\0\x2\0", 10));
    }

    void testCreateBadPacketUnchoke()
    {
        scenarioCreateBadPacket (QByteArray ("\0\0\0\xa", 4),
                                 QByteArray ("\x1\0\0\0\x1\0\0\0\x2\0", 10));
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (PacketFactoryTest);

} // namespace Testing
} // namespace Packets
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.