TransferSessionImplTest.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 "../TransferSessionImpl.h"
#include "generated/TransferSessionImplDriver.h"
#include "generated/TransferSessionImplMock.h" // because of clock \todo
#include "generated/TransferSessionStatusMock.h"
#include "Imports.cpp"

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


class TransferSessionImplTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TransferSessionImplTest);
    CPPUNIT_TEST (testCorrectInitialState);
    CPPUNIT_TEST (testWeGetChoked);
    CPPUNIT_TEST (testWeGetUnchoked);
    CPPUNIT_TEST (testWeGetUnchokedAndThenChokedAgain);
    CPPUNIT_TEST (testChokePeer);
    CPPUNIT_TEST (testUnchokePeer);
    CPPUNIT_TEST (testUnchokePeerAndThenChokeItAgain);
    CPPUNIT_TEST (testWeGetInterested);
    CPPUNIT_TEST (testWeGetNotInterested);
    CPPUNIT_TEST (testWeGetInterestedAndThenNotInterestedAgain);
    CPPUNIT_TEST (testPeerGetsInterested);
    CPPUNIT_TEST (testPeerGetsNotInterested);
    CPPUNIT_TEST (testPeerGetsInterestedAndThenNotInterestedAgain);
    CPPUNIT_TEST (testOnlyReceivingPieceIncreasesTotalDownload);
    CPPUNIT_TEST (testOnlySendingPieceIncreasesTotalUpload);
    CPPUNIT_TEST (testClosingTransferSessionClosesGenericSession);
    CPPUNIT_TEST (testForwardsClosingAndClosedNotificationFromGenericSession);
    CPPUNIT_TEST (testCurrentDownloadSpeedIsMovingAverageMoveTimeout);
    CPPUNIT_TEST (testCurrentDownloadSpeedIsMovingAverageMoveEachSecond);
    CPPUNIT_TEST (testCurrentUploadSpeedIsMovingAverageMoveTimeout);
    CPPUNIT_TEST (testCurrentUploadSpeedIsMovingAverageMoveEachSecond);
    CPPUNIT_TEST (testWeAreSnubbedIfPeerIsUnchokedButDoesNotReciprocate);
    CPPUNIT_TEST (testPeerIsSnubbedIfWeAreUnchokedButDoNotReciprocate);
    CPPUNIT_TEST (testReceivingABadPacketClosesSession);
    CPPUNIT_TEST (testReceivingBitFieldSetsPeerPiecesAvailable);
    CPPUNIT_TEST (testReceivingASecondBitFieldClosesSession);
    CPPUNIT_TEST (testSendingBitFieldSetsWePiecesAvailable);
    CPPUNIT_TEST (testReceivingHaveAllSetsAllPeerPiecesAvailable);
    CPPUNIT_TEST (testReceivingASecondHaveAllClosesSession);
    CPPUNIT_TEST (testSendingHaveAllSetsAllWePiecesAvailable);
    CPPUNIT_TEST (testReceivingHaveNoneResetsAllPeerPiecesAvailable);
    CPPUNIT_TEST (testReceivingASecondHaveNoneClosesSession);
    CPPUNIT_TEST (testSendingHaveNoneResetsAllWePiecesAvailable);
    CPPUNIT_TEST (testReceivingHavePacketSetsAPiecesAvailableBit);
    CPPUNIT_TEST (testSendingHavePacketSetsAPiecesAvailableBit);
    CPPUNIT_TEST (testPeerIsSeederIfItHasAllPieces);
    CPPUNIT_TEST (testWeAreSeederIfItHaveAllPieces);
    CPPUNIT_TEST (testPeerIsSeederAfterReportingItHasAllPieces);
    CPPUNIT_TEST (testWeAreSeederAfterReportingWeHaveAllPieces);
    CPPUNIT_TEST_SUITE_END();

    static const int                        AverageLength = 20;
    static const int                        SnubbedTimeout = 60;

    auto_ptr <SessionMock>                  genericSession;
    auto_ptr <IntegerResetStopwatchMock>    downloadStopwatch;
    auto_ptr <IntegerResetStopwatchMock>    uploadStopwatch;
    auto_ptr <TransferSessionStatusMock>    sessionStatus;
    auto_ptr <TransferSessionImpl>          sessionReal;
    auto_ptr <TransferSessionImplDriver>    session;

    const Handshake                         handshake;
    const BadPacket                         badPacket;
    const Choke                             choke;
    const Unchoke                           unchoke;
    const Interested                        interested;
    const NotInterested                     notInterested;
    const Piece                             piece1;
    const Piece                             piece2;
    const Piece                             piece3;
    const BitField                          bitField;
    const HaveAll                           haveAll;
    const HaveNone                          haveNone;
    const Have                              have5;
    const Have                              have11;
    const QBitArray                         allPiecesAvailable;
    QBitArray                               piecesAvailable;
    const QBitArray                         noPiecesAvailable;

public:
    TransferSessionImplTest()
     :  genericSession(), downloadStopwatch(), uploadStopwatch(),
        sessionStatus(), sessionReal(), session(),
        handshake(Handshake::ProtocolVersion1, true, QByteArray(), 12),
        badPacket(), choke(), unchoke(), interested(), notInterested(),
        piece1 (0, 0, "1234567890"),
        piece2 (1, 0, "12345"),
        piece3 (2, 0, QByteArray (20000, '\0')),
        bitField ("\xf1\x80"),
        haveAll(), haveNone(), have5 (5), have11 (11),
        allPiecesAvailable (12, true),
        piecesAvailable (12),
        noPiecesAvailable (12, false)
    {
        piecesAvailable.fill (true, 0, 4); // xf_
        piecesAvailable.fill (true, 7, 8); // x_1
        piecesAvailable.fill (true, 8, 9); // x8_
    }

    void setUp()
    {
        genericSession.reset (new SessionMock());
        downloadStopwatch.reset (new IntegerResetStopwatchMock());
        uploadStopwatch.reset (new IntegerResetStopwatchMock());
        sessionStatus.reset (new TransferSessionStatusMock());
        sessionReal.reset (new TransferSessionImpl (*genericSession,
                                                    handshake,
                                                    *downloadStopwatch,
                                                    *uploadStopwatch,
                                                    *sessionStatus));
        session.reset (new TransferSessionImplDriver (*sessionReal));
    }

    void tearDown()
    {
        session.reset();
        sessionReal.reset();
        sessionStatus.reset();
        uploadStopwatch.reset();
        downloadStopwatch.reset();
        genericSession.reset();
    }

    void refWeAreChoked (bool value)
    {
        call (session->areWeChoked())
        .willReturn (value);
    }

    void refWeAreInterested (bool value)
    {
        call (session->areWeInterested())
        .willReturn (value);
    }

    void refWeAreSnubbed (bool value, int secondsSinceLastReceived = 0)
    {
        call (session->areWeSnubbed())
            .willCall (downloadStopwatch->elapsedSeconds())
            .willReturn (secondsSinceLastReceived)
        .willReturn (value);
    }

    void refWeAreSeeder (bool isSeeder)
    {
        call (session->areWeSeeder())
        .willReturn (isSeeder);
    }

    void refPeerIsChoked (bool value)
    {
        call (session->isPeerChoked())
        .willReturn (value);
    }

    void refPeerIsInterested (bool value)
    {
        call (session->isPeerInterested())
        .willReturn (value);
    }

    void refPeerIsSnubbed (bool value, int secondsSinceLastSent = 0)
    {
        call (session->isPeerSnubbed())
            .willCall (uploadStopwatch->elapsedSeconds())
            .willReturn (secondsSinceLastSent)
        .willReturn (value);
    }

    void refPeerIsSeeder (bool isSeeder)
    {
        call (session->isPeerSeeder())
        .willReturn (isSeeder);
    }

    void refTotalDownloadedIs (qint64 count)
    {
        call (session->totalDownloaded())
        .willReturn (count);
    }

    void refTotalUploadedIs (qint64 count)
    {
        call (session->totalUploaded())
        .willReturn (count);
    }

    void refCurrentDownloadSpeedIs (qint64 speed,
                                    int secondsSinceLastReceive = 0)
    {
        call (session->currentDownloadSpeed())
            .willCall (downloadStopwatch->elapsedSeconds())
            .willReturn (secondsSinceLastReceive)
            .willCall (downloadStopwatch->reset())
            .returns()
        .willReturn (speed);
    }

    void refCurrentUploadSpeedIs (qint64 speed, int secondsSinceLastSend = 0)
    {
        call (session->currentUploadSpeed())
            .willCall (uploadStopwatch->elapsedSeconds())
            .willReturn (secondsSinceLastSend)
            .willCall (uploadStopwatch->reset())
            .returns()
        .willReturn (speed);
    }

    void refWePiecesAvailable (const QBitArray &pieces)
    {
        call (session->wePiecesAvailable())
        .willReturn (pieces);
    }

    void refPeerPiecesAvailable (const QBitArray &pieces)
    {
        call (session->peerPiecesAvailable())
        .willReturn (pieces);
    }

    void refReceivedPacketFromPeer (Packet packet,
                                    int secondsSinceLastReceive = 0)
    {
        CallDriver <BoundFunction <TransferSessionImpl,
                                   void (Session*, const Data &)> > foo
        = genericSession->calls (session->sessionReceivedData (*genericSession,
                                                               packet));

        foo
            .willCall (sessionStatus->transferSessionReceivedPacket (*session,
                                                                     packet))
            .returns();
            if (typeid (*packet) == typeid (Piece)) {
                foo.willCall (downloadStopwatch->elapsedSeconds())
                .willReturn (secondsSinceLastReceive)
                .willCall (downloadStopwatch->reset())
                .returns();
            }
        foo.returns();
    }

    void refReceivedPacketFromPeerClosesSession (Packet packet)
    {
        genericSession->calls (session->sessionReceivedData (*genericSession,
                                                             packet))
            .willCall (genericSession->close())
            .returns()
        .returns();
    }



    void refSentPacketToPeer (Packet packet,
                              int secondsSinceLastSend = 0)
    {
        CallDriver <BoundFunction <TransferSessionImpl,
                                   void (const Packet &)> > foo
        = call (session->sendPacket (packet));

        foo
            .willCall (sessionStatus->transferSessionSendingPacket (*session,
                                                                    packet))
            .returns()
            .willCall (genericSession->send (packet))
            .returns();
            if (typeid (*packet) == typeid (Piece)) {
                foo.willCall (uploadStopwatch->elapsedSeconds())
                .willReturn (secondsSinceLastSend)
                .willCall (uploadStopwatch->reset())
                .returns();
            }
        foo.returns();
    }

    void testCorrectInitialState()
    {
        refWeAreChoked (true);
        refPeerIsChoked (true);
        refWeAreInterested (false);
        refPeerIsInterested (false);
        refWeAreSnubbed (false);
        refPeerIsSnubbed (false);
        refWeAreSeeder (false);
        refPeerIsSeeder (false);
        refTotalDownloadedIs (0);
        refTotalUploadedIs (0);
        refCurrentDownloadSpeedIs (0);
        refCurrentUploadSpeedIs (0);
        refWePiecesAvailable (QBitArray(handshake.numberPieces));
        refPeerPiecesAvailable (QBitArray(handshake.numberPieces));
    }

    void testWeGetChoked()
    {
        testWeGetUnchoked();
        refReceivedPacketFromPeer (choke);
        refWeAreChoked (true);
    }

    void testWeGetUnchoked()
    {
        refReceivedPacketFromPeer (unchoke);
        refWeAreChoked (false);
    }

    void testWeGetUnchokedAndThenChokedAgain()
    {
        testWeGetChoked();
        testWeGetUnchoked();
    }

    void testChokePeer()
    {
        testUnchokePeer();
        refSentPacketToPeer (choke);
        refPeerIsChoked (true);
    }

    void testUnchokePeer()
    {
        refSentPacketToPeer (unchoke);
        refPeerIsChoked (false);
    }

    void testUnchokePeerAndThenChokeItAgain()
    {
        testUnchokePeer();
        testChokePeer();
    }

    void testWeGetInterested()
    {
        refSentPacketToPeer (interested);
        refWeAreInterested (true);
    }

    void testWeGetNotInterested()
    {
        refSentPacketToPeer (notInterested);
        refWeAreInterested (false);
    }

    void testWeGetInterestedAndThenNotInterestedAgain()
    {
        testWeGetInterested();
        testWeGetNotInterested();
    }

    void testPeerGetsInterested()
    {
        refReceivedPacketFromPeer (interested);
        refPeerIsInterested (true);
    }

    void testPeerGetsNotInterested()
    {
        refReceivedPacketFromPeer (notInterested);
        refPeerIsInterested (false);
    }

    void testPeerGetsInterestedAndThenNotInterestedAgain()
    {
        testPeerGetsInterested();
        testPeerGetsNotInterested();
    }

    void testOnlyReceivingPieceIncreasesTotalDownload()
    {
        refTotalDownloadedIs (0);
        refReceivedPacketFromPeer (choke);
        refReceivedPacketFromPeer (unchoke);
        refReceivedPacketFromPeer (interested);
        refReceivedPacketFromPeer (notInterested);
        // \todo add the rest of the packets!
        refTotalDownloadedIs (0);
        refReceivedPacketFromPeer (piece1);
        refTotalDownloadedIs (piece1.pieceBytes().length());
        refReceivedPacketFromPeer (piece2);
        refTotalDownloadedIs (piece1.pieceBytes().length()
                              + piece2.pieceBytes().length());
    }

    void testOnlySendingPieceIncreasesTotalUpload()
    {
        refTotalUploadedIs (0);
        refSentPacketToPeer (choke);
        refSentPacketToPeer (unchoke);
        refSentPacketToPeer (interested);
        refSentPacketToPeer (notInterested);
        refTotalUploadedIs (0);
        refSentPacketToPeer (piece1);
        refTotalUploadedIs (piece1.pieceBytes().length());
        refSentPacketToPeer (piece2);
        refTotalUploadedIs (piece1.pieceBytes().length()
                            + piece2.pieceBytes().length());
    }

    void testClosingTransferSessionClosesGenericSession()
    {
        call (session->close())
            .willCall (genericSession->close())
            .returns()
        .returns();
    }

    void testForwardsClosingAndClosedNotificationFromGenericSession()
    {
        genericSession->calls (session->sessionClosing (*genericSession))
            .willCall (sessionStatus->transferSessionClosing (*session))
            .returns()
        .returns();

        genericSession->calls (session->sessionClosed (*genericSession))
            .willCall (sessionStatus->transferSessionClosed (*session))
            .returns()
        .returns();
    }

    void testCurrentDownloadSpeedIsMovingAverageMoveTimeout()
    {
        int piece3length = piece3.pieceBytes().length();
        // Burst some bytes to gain speed:
        for (int i = 1; i <= 3; ++i) {
            refReceivedPacketFromPeer (piece3);
            refCurrentDownloadSpeedIs (i * piece3length / AverageLength);
        }
        // Receive again after the timeout, speed goes down:
        refReceivedPacketFromPeer (piece3, AverageLength);
        refCurrentDownloadSpeedIs (piece3length / AverageLength);
        // The download speed is zero after the timeout:
        refCurrentDownloadSpeedIs (0, AverageLength);
    }

    void testCurrentDownloadSpeedIsMovingAverageMoveEachSecond()
    {
        int piece3length = piece3.pieceBytes().length();
        // Feed it constantly with data to see the speed grow:
        for (int i = 1; i <= AverageLength; ++i) {
            refReceivedPacketFromPeer (piece3, 1);
            refCurrentDownloadSpeedIs (i * piece3length / AverageLength);
        }
        // The speed must become constant now:
        refReceivedPacketFromPeer (piece3, 1);
        refCurrentDownloadSpeedIs (piece3length);
        // Stop feeding data and see how the speed goes down:
        for (int i = AverageLength - 1; i >= 0; --i) {
            refCurrentDownloadSpeedIs (i * piece3length / AverageLength, 1);
            // Speed must stay the same if we query it without delay:
            refCurrentDownloadSpeedIs (i * piece3length / AverageLength, 0);
        }
    }

    void testCurrentUploadSpeedIsMovingAverageMoveTimeout()
    {
        int piece3length = piece3.pieceBytes().length();
        // Burst some bytes to gain speed:
        for (int i = 1; i <= 3; ++i) {
            refSentPacketToPeer (piece3);
            refCurrentUploadSpeedIs (i * piece3length / AverageLength);
        }
        // Receive again after the timeout, speed goes down:
        refSentPacketToPeer (piece3, AverageLength);
        refCurrentUploadSpeedIs (piece3length / AverageLength);
        // The download speed is zero after the timeout:
        refCurrentUploadSpeedIs (0, AverageLength);
    }

    void testCurrentUploadSpeedIsMovingAverageMoveEachSecond()
    {
        int piece3length = piece3.pieceBytes().length();
        // Feed it constantly with data to see the speed grow:
        for (int i = 1; i <= AverageLength; ++i) {
            refSentPacketToPeer (piece3, 1);
            refCurrentUploadSpeedIs (i * piece3length / AverageLength);
        }
        // The speed must become constant now:
        refSentPacketToPeer (piece3, 1);
        refCurrentUploadSpeedIs (piece3length);
        // Stop feeding data and see how the speed goes down:
        for (int i = AverageLength - 1; i >= 0; --i) {
            refCurrentUploadSpeedIs (i * piece3length / AverageLength, 1);
            // Speed must stay the same if we query it without delay:
            refCurrentUploadSpeedIs (i * piece3length / AverageLength, 0);
        }
    }


    void testWeAreSnubbedIfPeerIsUnchokedButDoesNotReciprocate()
    {
        // We do not get snubbed even after the timeout because we are choked:
        refWeAreSnubbed (false);
        refWeAreSnubbed (false, SnubbedTimeout);
        // After we get unchoked we can get snubbed after a timeout:
        refSentPacketToPeer (unchoke);
        refWeAreSnubbed (false);
        refWeAreSnubbed (true, SnubbedTimeout);
    }

    void testPeerIsSnubbedIfWeAreUnchokedButDoNotReciprocate()
    {
        // Peer is choked so it cannot get snubbed even after the timeout:
        refPeerIsSnubbed (false);
        refPeerIsSnubbed (false, SnubbedTimeout);
        // After we unchoke the peer it can get snubbed after a timeout:
        refReceivedPacketFromPeer (unchoke);
        refPeerIsSnubbed (false);
        refPeerIsSnubbed (true, SnubbedTimeout);
    }

    void testReceivingABadPacketClosesSession()
    {
        refReceivedPacketFromPeerClosesSession (badPacket);
    }

    void testReceivingBitFieldSetsPeerPiecesAvailable()
    {
        refReceivedPacketFromPeer (bitField);
        refPeerPiecesAvailable (piecesAvailable);
    }

    void testReceivingASecondBitFieldClosesSession()
    {
        testReceivingBitFieldSetsPeerPiecesAvailable();
        refReceivedPacketFromPeerClosesSession (bitField);
    }

    void testSendingBitFieldSetsWePiecesAvailable()
    {
        refSentPacketToPeer (bitField);
        refWePiecesAvailable (piecesAvailable);
    }

    void testReceivingHaveAllSetsAllPeerPiecesAvailable()
    {
        refReceivedPacketFromPeer (haveAll);
        refPeerPiecesAvailable (allPiecesAvailable);
    }

    void testReceivingASecondHaveAllClosesSession()
    {
        testReceivingHaveAllSetsAllPeerPiecesAvailable();
        refReceivedPacketFromPeerClosesSession (haveAll);
    }

    void testSendingHaveAllSetsAllWePiecesAvailable()
    {
        refSentPacketToPeer (haveAll);
        refWePiecesAvailable (allPiecesAvailable);
    }

    void testReceivingHaveNoneResetsAllPeerPiecesAvailable()
    {
        refReceivedPacketFromPeer (haveNone);
        refPeerPiecesAvailable (noPiecesAvailable);
    }

    void testReceivingASecondHaveNoneClosesSession()
    {
        testReceivingHaveNoneResetsAllPeerPiecesAvailable();
        refReceivedPacketFromPeerClosesSession (haveNone);
    }

    void testSendingHaveNoneResetsAllWePiecesAvailable()
    {
        refSentPacketToPeer (haveNone);
        refWePiecesAvailable (noPiecesAvailable);
    }

    void testReceivingHavePacketSetsAPiecesAvailableBit()
    {
        // Initialize the bit array with a BitField packet:
        testReceivingBitFieldSetsPeerPiecesAvailable();
        // Now receive additional Have packets:
        refReceivedPacketFromPeer (have5);
        piecesAvailable.setBit (5, true);
        refPeerPiecesAvailable (piecesAvailable);
        refReceivedPacketFromPeer (have11);
        piecesAvailable.setBit (11, true);
        refPeerPiecesAvailable (piecesAvailable);
    }

    void testSendingHavePacketSetsAPiecesAvailableBit()
    {
        // Initialize the bit array with a BitField packet:
        testSendingBitFieldSetsWePiecesAvailable();
        // Now send additional Have packets:
        refSentPacketToPeer (have5);
        piecesAvailable.setBit (5, true);
        refWePiecesAvailable (piecesAvailable);
        refSentPacketToPeer (have11);
        piecesAvailable.setBit (11, true);
        refWePiecesAvailable (piecesAvailable);
    }

    void testPeerIsSeederIfItHasAllPieces()
    {
        refPeerIsSeeder (false);
        testReceivingHaveAllSetsAllPeerPiecesAvailable();
        refPeerIsSeeder (true);
    }

    void testWeAreSeederIfItHaveAllPieces()
    {
        refWeAreSeeder (false);
        testSendingHaveAllSetsAllWePiecesAvailable();
        refWeAreSeeder (true);
    }

    void testPeerIsSeederAfterReportingItHasAllPieces()
    {
        testReceivingBitFieldSetsPeerPiecesAvailable();
        refPeerIsSeeder (false);
        // Receiving a single Have packet is not enough:
        refReceivedPacketFromPeer (Have (4));
        refPeerIsSeeder (false);
        // Receive Have packets for ALL missing pieces:
        refReceivedPacketFromPeer (Have (5));
        refReceivedPacketFromPeer (Have (6));
        refReceivedPacketFromPeer (Have (9));
        refReceivedPacketFromPeer (Have (10));
        refReceivedPacketFromPeer (Have (11));
        refPeerIsSeeder (true);
    }

    void testWeAreSeederAfterReportingWeHaveAllPieces()
    {
        testSendingBitFieldSetsWePiecesAvailable();
        refWeAreSeeder (false);
        // Receiving a single Have packet is not enough:
        refSentPacketToPeer (Have (4));
        refWeAreSeeder (false);
        // Receive Have packets for ALL missing pieces:
        refSentPacketToPeer (Have (5));
        refSentPacketToPeer (Have (6));
        refSentPacketToPeer (Have (9));
        refSentPacketToPeer (Have (10));
        refSentPacketToPeer (Have (11));
        refWeAreSeeder (true);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(TransferSessionImplTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.