TrackerResponseParserTest.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 "../TrackerResponse.h"
#include "../TrackerResponseParser.h"
#include "Imports.cpp"
#include <sstream>
#include <limits>

namespace Protocols {
namespace BitTorrent {
namespace Trackers {
namespace Testing {


class TrackerResponseParserTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TrackerResponseParserTest);
    CPPUNIT_TEST (testLoadInvalidResponseEmptyData);
    CPPUNIT_TEST (testLoadInvalidResponseRandomData);
    CPPUNIT_TEST (testLoadInvalidResponseListInsteadOfDictionary);
    CPPUNIT_TEST (testLoadInvalidResponseEmptyDictionary);
    CPPUNIT_TEST (testLoadInvalidResponseWouldNotChangeInputResponseObject);
    CPPUNIT_TEST (testLoadFieldFailureReasonPresentAndOtherDataAsWell);
    CPPUNIT_TEST (testLoadFieldFailureReasonPresentAndNoOtherData);
    CPPUNIT_TEST (testLoadFieldWarningMessageValid);
    CPPUNIT_TEST (testLoadFieldIntervalNegative);
    CPPUNIT_TEST (testLoadFieldIntervalZero);
    CPPUNIT_TEST (testLoadFieldIntervalTooBig);
    CPPUNIT_TEST (testLoadFieldIntervalValid);
    CPPUNIT_TEST (testLoadFieldIntervalMissing);
    CPPUNIT_TEST (testLoadFieldMinIntervalNegative);
    CPPUNIT_TEST (testLoadFieldMinIntervalZero);
    CPPUNIT_TEST (testLoadFieldMinIntervalTooBig);
    CPPUNIT_TEST (testLoadFieldMinIntervalValid);
    CPPUNIT_TEST (testLoadFieldTrackerIdValid);
    CPPUNIT_TEST (testLoadFieldCompleteNegative);
    CPPUNIT_TEST (testLoadFieldCompleteZero);
    CPPUNIT_TEST (testLoadFieldCompleteTooBig);
    CPPUNIT_TEST (testLoadFieldCompleteValid);
    CPPUNIT_TEST (testLoadFieldIncompleteNegative);
    CPPUNIT_TEST (testLoadFieldIncompleteZero);
    CPPUNIT_TEST (testLoadFieldIncompleteTooBig);
    CPPUNIT_TEST (testLoadFieldIncompleteValid);
    CPPUNIT_TEST (testLoadFieldPeersMissing);
    CPPUNIT_TEST (testLoadFieldPeersIntInsteadOfDictionary);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelEmptyList);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPeerIdMissing);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPeerIdInvalid);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoIpMissing);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPortMissing);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPortNegative);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPortZero);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPortTooBig);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelOnePeerInfoPortValid);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelTwoPeerInfoEverythingValid);
    CPPUNIT_TEST (testLoadFieldPeersDictionaryModelTwoPeerInfoSecondInvalid);
    CPPUNIT_TEST (testLoadFieldPeersBinaryModelOnePeerInfoStringTooShort);
    CPPUNIT_TEST (testLoadFieldPeersBinaryModelOnePeerInfoStringTooLong);
    CPPUNIT_TEST (testLoadFieldPeersBinaryModelOnePeerInfoEverythingValid);
    CPPUNIT_TEST (testLoadFieldPeersBinaryModelTwoPeerInfoEverythingValid);
    CPPUNIT_TEST (testLoadValidResponseMinimal);
    CPPUNIT_TEST (testLoadValidResponseComplex);
    CPPUNIT_TEST_SUITE_END();

    template <class T>
    static QByteArray stringifyNum (T num)
    {
        std::ostringstream out;
        out << num;
        return QByteArray (out.str().c_str());
    }


    static QByteArray createPeersBinaryModel (const QByteArray &ipAddress,
                                              quint16 port)
    {
        BinaryWriter writer (BinaryWriter::BigEndian);
        // Write IP address
        foreach (QByteArray byte, ipAddress.split ('.')) {
            writer.writeByte (byte.toUShort());
        }
        // Write port
        writer.writeUInt16 (port);

        return writer.buffer();
    }

public:
    void testLoadInvalidResponseEmptyData()
    {
        const QByteArray rawResponseData ("");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadInvalidResponseRandomData()
    {
        const QByteArray rawResponseData ("!@#$%^&*()_+");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadInvalidResponseListInsteadOfDictionary()
    {
        const QByteArray rawResponseData ("le");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadInvalidResponseEmptyDictionary()
    {
        const QByteArray rawResponseData ("de");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadInvalidResponseWouldNotChangeInputResponseObject()
    {
        const QByteArray rawResponseDataValid (
            "d"
                "14:failure reason6:Failed"
            "e");
        TrackerResponse response;
        bool loadedOk1 = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseDataValid, response);
        CPPUNIT_ASSERT (loadedOk1);

        const QByteArray rawResponseDataInvalid ("463gd972nedlsdf023e");
        TrackerResponse responseBackup (response);
        bool loadedOk2 = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseDataInvalid, response);
        CPPUNIT_ASSERT (!loadedOk2);
        CPPUNIT_ASSERT (responseBackup == response);
    }

    void testLoadFieldFailureReasonPresentAndOtherDataAsWell()
    {
        const QByteArray rawResponseData (
            "d"
                "14:failure reason6:Failed"
                "8:intervali300e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldFailureReasonPresentAndNoOtherData()
    {
        const QByteArray rawResponseData (
            "d"
                "14:failure reason6:Failed"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.failureReason() == QString ("Failed"));
        // Other data are left unchanged
        CPPUNIT_ASSERT (response.warningMessage() == QString());
        CPPUNIT_ASSERT (response.interval() == 0);
        CPPUNIT_ASSERT (response.minInterval() == 0);
        CPPUNIT_ASSERT (response.trackerId() == QByteArray());
        CPPUNIT_ASSERT (response.complete() == 0);
        CPPUNIT_ASSERT (response.incomplete() == 0);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadFieldWarningMessageValid()
    {
        const QByteArray rawResponseData (
            "d"
                "15:warning message7:Warning"
                "8:intervali300e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.warningMessage() == QString ("Warning"));
    }

    void testLoadFieldIntervalMissing()
    {
        const QByteArray rawResponseData (
            "d"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldIntervalNegative()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali-126e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldIntervalZero()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali0e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.interval() == 0);
    }

    void testLoadFieldIntervalTooBig()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali" + stringifyNum(std::numeric_limits<qint64>::max()) + "e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldIntervalValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.interval() == 300);
    }

    void testLoadFieldMinIntervalNegative()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali400e"
                "12:min intervali-477e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.minInterval() == 0);
    }

    void testLoadFieldMinIntervalZero()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali400e"
                "12:min intervali0e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.minInterval() == 0);
    }

    void testLoadFieldMinIntervalTooBig()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali400e"
                "12:min intervali" + stringifyNum(std::numeric_limits<qint64>::max()) + "e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.minInterval() == 0);
    }

    void testLoadFieldMinIntervalValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali400e"
                "12:min intervali600e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.minInterval() == 600);
    }

    void testLoadFieldTrackerIdValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "10:tracker id20:dg47sk3ld06jvnzmaq23"
                "8:completei10e"
                "10:incompletei20e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.trackerId() == QString ("dg47sk3ld06jvnzmaq23"));
    }

    void testLoadFieldCompleteNegative()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "8:completei-1000e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.complete() == 0);
    }

    void testLoadFieldCompleteZero()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "8:completei0e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.complete() == 0);
    }

    void testLoadFieldCompleteTooBig()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "8:completei" + stringifyNum(std::numeric_limits<qint64>::max()) + "e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.complete() == 0);
    }

    void testLoadFieldCompleteValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "8:completei123e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.complete() == 123);
    }

    void testLoadFieldIncompleteNegative()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "10:incompletei-16432e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.incomplete() == 0);
    }

    void testLoadFieldIncompleteZero()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "8:completei123e"
                "10:incompletei0e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.incomplete() == 0);
    }

    void testLoadFieldIncompleteTooBig()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "10:incompletei" + stringifyNum(std::numeric_limits<qint64>::max()) + "e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.incomplete() == 0);
    }

    void testLoadFieldIncompleteValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "10:incompletei1999e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.incomplete() == 1999);
    }

    void testLoadFieldPeersMissing()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldPeersIntInsteadOfDictionary()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peersli456ee"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldPeersDictionaryModelEmptyList()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPeerIdMissing()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "2:ip9:127.0.0.1"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPeerIdInvalid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id5:abcde"
                            "2:ip9:127.0.0.1"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 6881,
            PeerInfo::PeerId()));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoIpMissing()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPortMissing()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPortNegative()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                            "4:porti-1001e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;

        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 0,
            PeerInfo::PeerId ("agd538x9fo4bf85jg076")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPortZero()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                            "4:porti0e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 0,
            PeerInfo::PeerId ("agd538x9fo4bf85jg076")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPortTooBig()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                            "4:porti-1001e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
                CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 0,
            PeerInfo::PeerId ("agd538x9fo4bf85jg076")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelOnePeerInfoPortValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 6881,
            PeerInfo::PeerId ("agd538x9fo4bf85jg076")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelTwoPeerInfoEverythingValid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:ah453vx05lf85j362fx1"
                            "2:ip9:127.0.0.0"
                            "4:porti6880e"
                        "e"
                        "d"
                            "7:peer id20:f54hx439s0gnv8787714"
                            "2:ip9:127.0.0.1"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.0", 6880,
            PeerInfo::PeerId ("ah453vx05lf85j362fx1")));
        referencePeers.push_back (PeerInfo ("127.0.0.1", 6881,
            PeerInfo::PeerId ("f54hx439s0gnv8787714")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersDictionaryModelTwoPeerInfoSecondInvalid()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:ah453vx05lf85j362fx1"
                            "2:ip9:127.0.0.0"
                            "4:porti6880e"
                        "e"
                        "d"
                            "4:porti6881e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.0", 6880,
            PeerInfo::PeerId ("ah453vx05lf85j362fx1")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersBinaryModelOnePeerInfoStringTooShort()
    {
        const QByteArray rawPeersData (createPeersBinaryModel (
            QByteArray (""), 6881));
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers" + QByteArray::number (rawPeersData.size()) + ":" +
                    rawPeersData +
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldPeersBinaryModelOnePeerInfoStringTooLong()
    {
        const QByteArray rawPeersData (createPeersBinaryModel (
            QByteArray ("1.2.3.4.5"), 6881));
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers" + QByteArray::number (rawPeersData.size()) + ":" +
                    rawPeersData +
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (!loadedOk);
    }

    void testLoadFieldPeersBinaryModelOnePeerInfoEverythingValid()
    {
        const QByteArray rawPeersData (createPeersBinaryModel (
            QByteArray ("127.0.0.1"), 6881));
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers" + QByteArray::number (rawPeersData.size()) + ":" +
                    rawPeersData +
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 6881,
            PeerInfo::PeerId()));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadFieldPeersBinaryModelTwoPeerInfoEverythingValid()
    {
        const QByteArray rawPeersData1 (createPeersBinaryModel (
            QByteArray ("167.234.8.123"), 101));
        const QByteArray rawPeersData2 (createPeersBinaryModel (
            QByteArray ("4.6.7.8"), 63456));
        const QByteArray rawResponseData (
            "d"
                "8:intervali300e"
                "5:peers" + QByteArray::number (rawPeersData1.size() +
                        rawPeersData2.size()) +
                    ":" +
                    rawPeersData1 + rawPeersData2 +
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("167.234.8.123", 101,
            PeerInfo::PeerId()));
        referencePeers.push_back (PeerInfo ("4.6.7.8", 63456,
            PeerInfo::PeerId()));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }

    void testLoadValidResponseMinimal()
    {
        const QByteArray rawResponseData (
            "d"
                "8:intervali360e"
                "5:peersle"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.failureReason() == QString());
        CPPUNIT_ASSERT (response.warningMessage() == QString());
        CPPUNIT_ASSERT (response.interval() == 360);
        CPPUNIT_ASSERT (response.minInterval() == 0);
        CPPUNIT_ASSERT (response.trackerId() == QByteArray());
        CPPUNIT_ASSERT (response.complete() == 0);
        CPPUNIT_ASSERT (response.incomplete() == 0);
        CPPUNIT_ASSERT (response.peers() == TrackerResponse::PeerInfoList());
    }

    void testLoadValidResponseComplex()
    {
        const QByteArray rawResponseData (
            "d"
                "15:warning message7:Warning"
                "8:intervali300e"
                "12:min intervali600e"
                "10:tracker id20:dg47sk3ld06jvnzmaq23"
                "8:completei10e"
                "10:incompletei20e"
                "5:peers"
                    "l"
                        "d"
                            "7:peer id20:agd538x9fo4bf85jg076"
                            "2:ip9:127.0.0.1"
                            "4:porti6881e"
                        "e"
                        "d"
                            "7:peer id20:hf648dnck60dktuydnsf"
                            "2:ip9:127.0.0.2"
                            "4:porti6882e"
                        "e"
                        "d"
                            "7:peer id20:lop0r64gcvxg35dhsb2l"
                            "2:ip9:127.0.0.3"
                            "4:porti6883e"
                        "e"
                    "e"
            "e");
        TrackerResponse response;
        bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
            rawResponseData, response);
        CPPUNIT_ASSERT (loadedOk);
        CPPUNIT_ASSERT (response.failureReason() == QString());
        CPPUNIT_ASSERT (response.warningMessage() == QString("Warning"));
        CPPUNIT_ASSERT (response.interval() == 300);
        CPPUNIT_ASSERT (response.minInterval() == 600);
        CPPUNIT_ASSERT (response.trackerId() == QByteArray("dg47sk3ld06jvnzmaq23"));
        CPPUNIT_ASSERT (response.complete() == 10);
        CPPUNIT_ASSERT (response.incomplete() == 20);
        TrackerResponse::PeerInfoList referencePeers;
        referencePeers.push_back (PeerInfo ("127.0.0.1", 6881,
            PeerInfo::PeerId ("agd538x9fo4bf85jg076")));
        referencePeers.push_back (PeerInfo ("127.0.0.2", 6882,
            PeerInfo::PeerId ("hf648dnck60dktuydnsf")));
        referencePeers.push_back (PeerInfo ("127.0.0.3", 6883,
            PeerInfo::PeerId ("lop0r64gcvxg35dhsb2l")));
        CPPUNIT_ASSERT (response.peers() == referencePeers);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(TrackerResponseParserTest);

} // namespace Testing
} // namespace Trackers
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.