ChokerTest.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 "../Choker.h"
#include "generated/ChokerDriver.h"
#include "generated/ChokerMock.h" // \todo because of Timer and RandomNumberGenerator.
#include "generated/TransferSessionMock.h"
#include "Imports.cpp"

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


class ChokerTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (ChokerTest);
    CPPUNIT_TEST (testStartingChokerStartsTheTimer);
    CPPUNIT_TEST (testStoppingChokerStopsTheTimer);
    CPPUNIT_TEST (testAddOneSessionItGetsUnchokedNextChokingTime);
    CPPUNIT_TEST (testAddFourSessionsAllGetUnchokedNextChokingTime);
    CPPUNIT_TEST (testAddFiveSessionsFiveNotInterestedGetUnchokedNextChokingTime);
    CPPUNIT_TEST (testAddFiveSessionsFourInterestedGetUnchokedNextChokingTime);
    CPPUNIT_TEST (testFifthSessionUnchokedDuringFirstOptimisticUnchoking);
    CPPUNIT_TEST (testForthSessionUnchokedDuringSecondUnchoking);
    CPPUNIT_TEST (testOptimisticUnchokeDoesNotChangeFor2ChokingTimes);
    CPPUNIT_TEST (testUnchokePeersWeDownloadFastestFrom);
    CPPUNIT_TEST (testAntiSnubbingOneSnubbedSessionTwoOptimisticChokes);
    CPPUNIT_TEST (testAntiSnubbingHasNoEffectWhenNoConnectionsAreChoked);
    CPPUNIT_TEST (testClosedSessionsAreNeitherChokedNorUnchokedAnymore);
    CPPUNIT_TEST (testSeedersAreAlwaysKeptChoked);
    CPPUNIT_TEST (testSeedersAreNeverOptimisticlyUnchoked);
    CPPUNIT_TEST (testOptimisticUnchokingPicksRandomlyFromMultipleCandidates);
    CPPUNIT_TEST (testUnchokeSessionsWithHighestUploadRateWhenInSeedingMode);
    CPPUNIT_TEST (testWeIngnoreBeingSnubbedWhenWeAreInSeedingMode);
    CPPUNIT_TEST_SUITE_END();

    struct SessionState
    {
        bool    isPeerChoked;
        bool    isPeerInterested;
        bool    isPeerSeeder;
        bool    areWeSnubbed;
        qint64  downloadSpeed;
        qint64  uploadSpeed;

        SessionState() : isPeerChoked (true), isPeerInterested (false),
                         isPeerSeeder (false), areWeSnubbed (false),
                         downloadSpeed (0), uploadSpeed (0) {}
    };

    typedef QList <TransferSessionMock *>               Sessions;
    typedef QMap <TransferSessionMock *, SessionState>  SessionsStateMap;

    auto_ptr <TimerMock>                    timer;
    auto_ptr <RandomNumberGeneratorMock>    randomNumberGenerator;
    auto_ptr <TransferManagerStateMock>     transferManagerState;
    auto_ptr <Choker>                       chokerReal;
    auto_ptr <ChokerDriver>                 choker;
    Sessions                                sessions;
    SessionsStateMap                        sessionsState;
    Sessions                                openedSessions;

    const Choke                             choke;
    const Unchoke                           unchoke;
    QList <int>                             randomIntsZero;
    QList <int>                             randomIntsZeroZero;
    bool                                    isTestingSeedingMode;
    static const int                        SessionsCount = 10;

public:
    ChokerTest() : timer (), randomNumberGenerator(), transferManagerState(),
                   chokerReal(), choker(), sessions(), sessionsState(),
                   openedSessions(), choke(), unchoke(), randomIntsZero(),
                   randomIntsZeroZero(), isTestingSeedingMode (false)
    {
        // let first choked session be unchoked:
        randomIntsZero += 0;
        // let the first two choked sessions be unchoked:
        randomIntsZeroZero += 0;
        randomIntsZeroZero += 0;
    }

    void setUp()
    {
        timer.reset (new TimerMock());
        randomNumberGenerator.reset (new RandomNumberGeneratorMock());
        transferManagerState.reset (new TransferManagerStateMock());
        chokerReal.reset (new Choker (*timer,
                                      *randomNumberGenerator,
                                      *transferManagerState));
        choker.reset (new ChokerDriver (*chokerReal));

        for (int i = 0; i < SessionsCount; ++i) {
            sessions += new TransferSessionMock();
            sessionsState.insert (sessions.last(), SessionState());
        }
    }

    void tearDown()
    {
        choker.reset();
        chokerReal.reset();
        randomNumberGenerator.reset();
        transferManagerState.reset();
        timer.reset();

        for (int i = 0; i < 10; ++i)
            delete sessions [i];
        sessions.clear();
        sessionsState.clear();
        openedSessions.clear();
    }

    void sessionsStateSetPeerIsChoked (const Sessions &sessions, bool choked)
    {
        foreach (TransferSessionMock *session, sessions)
            sessionsState [session].isPeerChoked = choked;
    }

    void sessionsStateSetPeerIsInterested (const Sessions &sessions,
                                           bool interested)
    {
        foreach (TransferSessionMock *session, sessions)
            sessionsState [session].isPeerInterested = interested;
    }

    void sessionsStateSetPeerIsSeeder (const Sessions &sessions, bool seeder)
    {
        foreach (TransferSessionMock *session, sessions)
            sessionsState [session].isPeerSeeder = seeder;
    }

    void sessionsStateSetWeAreSnubbed (const Sessions &sessions, bool snubbed)
    {
        foreach (TransferSessionMock *session, sessions)
            sessionsState [session].areWeSnubbed = snubbed;
    }

    void refOpenSessions (const Sessions &sessions)
    {
        foreach (TransferSessionMock *session, sessions) {
            call (choker->openedSession (*session))
            .returns();
        }
        openedSessions += sessions;
    }

    void refCloseSessions (const Sessions &sessions)
    {
        foreach (TransferSessionMock *session, sessions) {
            call (choker->closedSession (*session))
            .returns();

            openedSessions.removeAll (session);
        }
    }


    void refChokingTimeUnchokeChokeSessions (const Sessions &unchokedSessions,
                                             const Sessions &chokedSessions,
                                             const QList <int> &randomInts
                                                    = QList <int>())
    {
        CallDriver <BoundFunction <Choker, void()> > foo =
        timer->calls (choker->chokingTime());
            foo.willCall (transferManagerState->isDownloading())
                .numberOfTimes (1, -1)
            .willReturn (!isTestingSeedingMode);

            foreach (TransferSessionMock *session, openedSessions)
                foo.willCall (session->isPeerChoked())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].isPeerChoked)
                    .willCall (session->isPeerInterested())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].isPeerInterested)
                    .willCall (session->areWeSnubbed())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].areWeSnubbed)
                    .willCall (session->isPeerSeeder())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].isPeerSeeder)
                    .willCall (session->currentDownloadSpeed())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].downloadSpeed)
                    .willCall (session->currentUploadSpeed())
                        .numberOfTimes (0, -1)
                    .willReturn (sessionsState [session].uploadSpeed);

            foreach (TransferSessionMock *session, unchokedSessions)
                foo.willCall (session->sendPacket (unchoke))
                    .returns();

            foreach (TransferSessionMock *session, chokedSessions)
                foo.willCall (session->sendPacket (choke))
                    .returns();

            // This sets the sequence of random numbers returned when selecting
            // the optimistic unchokes.
            foreach (int randomInt, randomInts)
                foo.willCall (randomNumberGenerator->random())
                    .willReturn (randomInt);
        foo.returns();

        sessionsStateSetPeerIsChoked (chokedSessions, true);
        sessionsStateSetPeerIsChoked (unchokedSessions, false);
    }


    void testStartingChokerStartsTheTimer()
    {
        Callable <void()> chokingTimeCallable (choker->operator Choker&(),
                                               &Choker::chokingTime);

        call (choker->start())
            .willCall (timer->start (chokingTimeCallable, 10000))
            .returns()
        .returns();
    }

    void testStoppingChokerStopsTheTimer()
    {
        call (choker->stop())
            .willCall (timer->stop())
            .returns()
        .returns();
    }

    void testAddOneSessionItGetsUnchokedNextChokingTime()
    {
        refOpenSessions (sessions.mid (0, 1));
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 1),
                                            sessions.mid (0, 0));
    }

    void testAddFourSessionsAllGetUnchokedNextChokingTime()
    {
        refOpenSessions (sessions.mid (0, 4));
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 4),
                                            sessions.mid (0, 0));
    }

    void testAddFiveSessionsFiveNotInterestedGetUnchokedNextChokingTime()
    {
        refOpenSessions (sessions.mid (0, 5));
        sessionsStateSetPeerIsInterested (sessions.mid (0, 5), false);
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 5),
                                            sessions.mid (0, 0));
    }

    void testAddFiveSessionsFourInterestedGetUnchokedNextChokingTime()
    {
        refOpenSessions (sessions.mid (0, 5));
        sessionsStateSetPeerIsInterested (sessions.mid (0, 5), true);
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 4),
                                            sessions.mid (0, 0));
    }


    void testFifthSessionUnchokedDuringFirstOptimisticUnchoking()
    {
        refOpenSessions (sessions.mid (0, 5));
        sessionsStateSetPeerIsInterested (sessions.mid (0, 5), true);
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 4),
                                            sessions.mid (0, 0));
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 0),
                                            sessions.mid (0, 0));
        refChokingTimeUnchokeChokeSessions (sessions.mid (4, 1),
                                            sessions.mid (3, 1),
                                            randomIntsZero);
    }


    void testForthSessionUnchokedDuringSecondUnchoking()
    {
        testFifthSessionUnchokedDuringFirstOptimisticUnchoking();

        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (sessions.mid (3, 1),
                                            sessions.mid (4, 1),
                                            randomIntsZero);
    }


    void testOptimisticUnchokeDoesNotChangeFor2ChokingTimes()
    {
        testFifthSessionUnchokedDuringFirstOptimisticUnchoking();
        sessionsState [sessions [0]].downloadSpeed = 15;
        sessionsState [sessions [1]].downloadSpeed = 10;
        sessionsState [sessions [2]].downloadSpeed = 5;
        sessionsState [sessions [3]].downloadSpeed = 5;
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (sessions.mid (3, 1),
                                            sessions.mid (4, 1),
                                            randomIntsZero);
    }


    void testUnchokePeersWeDownloadFastestFrom()
    {
        refOpenSessions (sessions.mid (0, SessionsCount));

        Sessions unchokedSessions, chokedSessions;
        // Low download rate, not interested => choked
        sessionsState [sessions [0]].isPeerInterested = false;
        sessionsState [sessions [0]].downloadSpeed = 1;
        chokedSessions += sessions [0];
        // Low download rate, interested => choked
        sessionsState [sessions [1]].isPeerInterested = true;
        sessionsState [sessions [1]].downloadSpeed = 0;
        chokedSessions += sessions [1];
        // Good download rate, not interested => unchoked (good download)
        sessionsState [sessions [2]].isPeerInterested = false;
        sessionsState [sessions [2]].downloadSpeed = 12;
        unchokedSessions += sessions [2];
        // Low download rate, not interested => choked
        sessionsState [sessions [3]].isPeerInterested = false;
        sessionsState [sessions [3]].downloadSpeed = 0;
        chokedSessions += sessions [3];
        // Good download rate, interested => unchcoked (interested)
        sessionsState [sessions [4]].isPeerInterested = true;
        sessionsState [sessions [4]].downloadSpeed = 12;
        unchokedSessions += sessions [4];
        // Good download rate, interested => unchoked (interested)
        sessionsState [sessions [5]].isPeerInterested = true;
        sessionsState [sessions [5]].downloadSpeed = 48;
        unchokedSessions += sessions [5];
        // Low download rate, interested => choked
        sessionsState [sessions [6]].isPeerInterested = true;
        sessionsState [sessions [6]].downloadSpeed = 0;
        chokedSessions += sessions [6];
        // Low download rate, interested => unchoked (interested)
        // Note: wins over 0 because the other is not interested
        sessionsState [sessions [7]].isPeerInterested = true;
        sessionsState [sessions [7]].downloadSpeed = 1;
        unchokedSessions += sessions [7];
        // Good download rate, interested => unchoked (interested)
        sessionsState [sessions [8]].isPeerInterested = true;
        sessionsState [sessions [8]].downloadSpeed = 12000000;
        unchokedSessions += sessions [8];
        // Low download rate, not interested => choked
        sessionsState [sessions [9]].isPeerInterested = false;
        sessionsState [sessions [9]].downloadSpeed = 0;
        chokedSessions += sessions [9];

        refChokingTimeUnchokeChokeSessions (unchokedSessions, Sessions());
    }


    void testAntiSnubbingOneSnubbedSessionTwoOptimisticChokes()
    {
        refOpenSessions (sessions.mid (0, 6));

        sessionsStateSetPeerIsChoked (sessions.mid (0, 4), false);
        sessionsStateSetPeerIsInterested (sessions.mid (0, 6), true);
        sessionsStateSetWeAreSnubbed (sessions.mid (2, 1), true);

        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (sessions.mid (4, 2),
                                            sessions.mid (2, 2),
                                            randomIntsZeroZero);
    }

    void testAntiSnubbingHasNoEffectWhenNoConnectionsAreChoked()
    {
        refOpenSessions (sessions.mid (0, 4));

        sessionsStateSetPeerIsChoked (sessions.mid (0, 4), false);
        sessionsStateSetWeAreSnubbed (sessions.mid (0, 4), true);

        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
    }


    void testClosedSessionsAreNeitherChokedNorUnchokedAnymore()
    {
        refOpenSessions (sessions.mid (0, 1));
        refCloseSessions (sessions.mid (0, 1));
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
    }


    void testSeedersAreAlwaysKeptChoked()
    {
        refOpenSessions (sessions.mid (0, 4));
        // 1. session 0 is seeder and must not be unchoked
        // 2. session 1 is seeder and is unchoked, so should be choked
        sessionsStateSetPeerIsSeeder (sessions.mid (0, 2), true);
        sessionsStateSetPeerIsChoked (sessions.mid (1, 1), false);
        refChokingTimeUnchokeChokeSessions (sessions.mid (2, 2),
                                            sessions.mid (1, 1));
    }

    void testSeedersAreNeverOptimisticlyUnchoked()
    {
        // For the first choking time there will be new seeder sessions.
        testSeedersAreAlwaysKeptChoked();
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        // For the second choking time there will be no new seeder sessions.
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
    }


    void testOptimisticUnchokingPicksRandomlyFromMultipleCandidates()
    {
        refOpenSessions (sessions);
        sessionsStateSetPeerIsInterested (sessions, true);
        // Unchoke the first four interested sessions:
        refChokingTimeUnchokeChokeSessions (sessions.mid (0, 4), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        // Optimisticly unchoking sessions [7]:
        QList <int> randomIntsTwentyEight;
        randomIntsTwentyEight += 28;
        refChokingTimeUnchokeChokeSessions (sessions.mid (7, 1),
                                            sessions.mid (3, 1),
                                            randomIntsTwentyEight);
    }

    void testUnchokeSessionsWithHighestUploadRateWhenInSeedingMode()
    {
        isTestingSeedingMode = true;
        refOpenSessions (sessions.mid (0, SessionsCount));

        Sessions unchokedSessions, chokedSessions;
        // Low download rate, not interested => choked
        sessionsState [sessions [0]].isPeerInterested = false;
        sessionsState [sessions [0]].uploadSpeed = 1;
        chokedSessions += sessions [0];
        // Low download rate, interested => choked
        sessionsState [sessions [1]].isPeerInterested = true;
        sessionsState [sessions [1]].uploadSpeed = 0;
        chokedSessions += sessions [1];
        // Good download rate, not interested => unchoked (good download)
        sessionsState [sessions [2]].isPeerInterested = false;
        sessionsState [sessions [2]].uploadSpeed = 12;
        unchokedSessions += sessions [2];
        // Low download rate, not interested => choked
        sessionsState [sessions [3]].isPeerInterested = false;
        sessionsState [sessions [3]].uploadSpeed = 0;
        chokedSessions += sessions [3];
        // Good download rate, interested => unchcoked (interested)
        sessionsState [sessions [4]].isPeerInterested = true;
        sessionsState [sessions [4]].uploadSpeed = 12;
        unchokedSessions += sessions [4];
        // Good download rate, interested => unchoked (interested)
        sessionsState [sessions [5]].isPeerInterested = true;
        sessionsState [sessions [5]].uploadSpeed = 48;
        unchokedSessions += sessions [5];
        // Low download rate, interested => choked
        sessionsState [sessions [6]].isPeerInterested = true;
        sessionsState [sessions [6]].uploadSpeed = 0;
        chokedSessions += sessions [6];
        // Low download rate, interested => unchoked (interested)
        // Note: wins over 0 because the other is not interested
        sessionsState [sessions [7]].isPeerInterested = true;
        sessionsState [sessions [7]].uploadSpeed = 1;
        unchokedSessions += sessions [7];
        // Good download rate, interested => unchoked (interested)
        sessionsState [sessions [8]].isPeerInterested = true;
        sessionsState [sessions [8]].uploadSpeed = 12000000;
        unchokedSessions += sessions [8];
        // Low download rate, not interested => choked
        sessionsState [sessions [9]].isPeerInterested = false;
        sessionsState [sessions [9]].uploadSpeed = 0;
        chokedSessions += sessions [9];

        refChokingTimeUnchokeChokeSessions (unchokedSessions, Sessions());
    }

    void testWeIngnoreBeingSnubbedWhenWeAreInSeedingMode()
    {
        isTestingSeedingMode = true;
        refOpenSessions (sessions.mid (0, 6));

        sessionsStateSetPeerIsChoked (sessions.mid (0, 4), false);
        sessionsStateSetPeerIsInterested (sessions.mid (0, 6), true);
        sessionsStateSetWeAreSnubbed (sessions.mid (2, 1), true);

        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (Sessions(), Sessions());
        refChokingTimeUnchokeChokeSessions (sessions.mid (4, 1),
                                            sessions.mid (3, 1),
                                            randomIntsZero);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(ChokerTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.