TrackerRequestUrlCreatorTest.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 "../TrackerRequestUrlCreator.h"
#include "Imports.cpp"
#include <sstream>
#include <limits>

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


class TrackerRequestUrlCreatorTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TrackerRequestUrlCreatorTest);
    CPPUNIT_TEST (testCreateRequestUrlMinimalRequest);
    CPPUNIT_TEST (testCreateRequestUrlCompleteRequest);
    CPPUNIT_TEST (testCreateRequestUrlMinNumbers);
    CPPUNIT_TEST (testCreateRequestUrlMaxNumbers);
    CPPUNIT_TEST_SUITE_END();


    void scenarioCreateRequestUrl (const TrackerRequest &request,
                                   const QByteArray &referenceUrl)
    {
        const Uri requestUrl = TrackerRequestUrlCreator::createRequestUrl (
            request);
        CPPUNIT_ASSERT (requestUrl.encoded() == referenceUrl);
    }

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

    const QByteArray        ReferenceAnnounceUrl;
    const QByteArray        ReferenceMinimalRequestUrlQueryPart;
    const QByteArray        ReferenceMinimalRequestUrl;
    const QByteArray        ReferenceCompleteRequestUrlQueryPart;
    const QByteArray        ReferenceCompleteRequestUrl;

    const TrackerRequest    MinimalRequest;
    const TrackerRequest    CompleteRequest;

public:
    TrackerRequestUrlCreatorTest();

    void testCreateRequestUrlMinimalRequest()
    {
        scenarioCreateRequestUrl (MinimalRequest, ReferenceMinimalRequestUrl);
    }

    void testCreateRequestUrlCompleteRequest()
    {
        scenarioCreateRequestUrl (CompleteRequest, ReferenceCompleteRequestUrl);
    }

    void testCreateRequestUrlMinNumbers()
    {
        TrackerRequest request (Uri::fromUnencoded (ReferenceAnnounceUrl),
                                PeerInfo ("10.0.0.0",
                                          std::numeric_limits<quint16>::min(),
                                          PeerInfo::PeerId ("h584hfp70x52ns05jc75")),
                                Torrent::InfoHash ("klotp50374hx75g36123"),
                                std::numeric_limits<quint64>::min(),
                                std::numeric_limits<quint64>::min(),
                                std::numeric_limits<quint64>::min(),
                                false,
                                TrackerRequest::Stopped,
                                std::numeric_limits<uint>::min(),
                                "xz42vdlgo60svx64hryz",
                                "dht73f2caldor058cp08");

        QByteArray referenceUrl = ReferenceAnnounceUrl +
            "?info_hash=klotp50374hx75g36123"
            "&peer_id=h584hfp70x52ns05jc75"
            "&port=" + stringifyNum (std::numeric_limits<quint16>::min()) +
            "&uploaded=" + stringifyNum (std::numeric_limits<quint64>::min()) +
            "&downloaded=" + stringifyNum (std::numeric_limits<quint64>::min()) +
            "&left=" + stringifyNum (std::numeric_limits<quint64>::min()) +
            "&compact=0"
            "&event=stopped"
            "&ip=10.0.0.0"
            "&numwant=" + stringifyNum (std::numeric_limits<uint>::min()) +
            "&key=xz42vdlgo60svx64hryz"
            "&trackerid=dht73f2caldor058cp08";

        scenarioCreateRequestUrl (request, referenceUrl);
    }

    void testCreateRequestUrlMaxNumbers()
    {
        TrackerRequest request (Uri::fromUnencoded (ReferenceAnnounceUrl),
                                PeerInfo ("255.255.255.255",
                                          std::numeric_limits<quint16>::max(),
                                          PeerInfo::PeerId ("h584hfp70x52ns05jc75")),
                                Torrent::InfoHash ("klotp50374hx75g36123"),
                                std::numeric_limits<quint64>::max(),
                                std::numeric_limits<quint64>::max(),
                                std::numeric_limits<quint64>::max(),
                                true,
                                TrackerRequest::Stopped,
                                std::numeric_limits<uint>::max(),
                                "xz42vdlgo60svx64hryz",
                                "dht73f2caldor058cp08");

        QByteArray referenceUrl = ReferenceAnnounceUrl +
            "?info_hash=klotp50374hx75g36123"
            "&peer_id=h584hfp70x52ns05jc75"
            "&port=" + stringifyNum (std::numeric_limits<quint16>::max()) +
            "&uploaded=" + stringifyNum (std::numeric_limits<quint64>::max()) +
            "&downloaded=" + stringifyNum (std::numeric_limits<quint64>::max()) +
            "&left=" + stringifyNum (std::numeric_limits<quint64>::max()) +
            "&compact=1"
            "&event=stopped"
            "&ip=255.255.255.255"
            "&numwant=" + stringifyNum (std::numeric_limits<uint>::max()) +
            "&key=xz42vdlgo60svx64hryz"
            "&trackerid=dht73f2caldor058cp08";

        scenarioCreateRequestUrl (request, referenceUrl);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(TrackerRequestUrlCreatorTest);


TrackerRequestUrlCreatorTest::TrackerRequestUrlCreatorTest()
    : ReferenceAnnounceUrl ("http://tracker.com/announce.php"),
    ReferenceMinimalRequestUrlQueryPart (
        "?info_hash=z53bf64bd05hfn2daqml"
        "&peer_id=-CA0610-574938205849"
        "&port=6881"
        "&uploaded=4096"
        "&downloaded=2048"
        "&left=63488"
        "&compact=0"
        "&event=empty"
        "&numwant=0"),
    ReferenceMinimalRequestUrl (
        ReferenceAnnounceUrl + ReferenceMinimalRequestUrlQueryPart),
    ReferenceCompleteRequestUrlQueryPart (
        "?info_hash=fh37dosi5jv0c91g3654"
        "&peer_id=-CA0610-574938205849"
        "&port=6882"
        "&uploaded=12345"
        "&downloaded=120"
        "&left=63488"
        "&compact=1"
        "&event=started"
        "&ip=127.0.0.1"
        "&numwant=30"
        "&key=364h3kd9472mfd03odj3"
        "&trackerid=z84d74h39doz7dh47du5"),
    ReferenceCompleteRequestUrl (
        ReferenceAnnounceUrl + ReferenceCompleteRequestUrlQueryPart),
    MinimalRequest (
        Uri::fromUnencoded (ReferenceAnnounceUrl),
        PeerInfo ("0.0.0.0", 6881, PeerInfo::PeerId ("-CA0610-574938205849")),
        Torrent::InfoHash ("z53bf64bd05hfn2daqml"),
        4096,
        2048,
        63488,
        false),
    CompleteRequest (
        Uri::fromUnencoded (ReferenceAnnounceUrl),
        PeerInfo ("127.0.0.1", 6882, PeerInfo::PeerId ("-CA0610-574938205849")),
        Torrent::InfoHash ("fh37dosi5jv0c91g3654"),
        12345,
        120,
        63488,
        true,
        TrackerRequest::Started,
        30,
        QByteArray ("364h3kd9472mfd03odj3"),
        QByteArray ("z84d74h39doz7dh47du5"))
{
}

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.