Esempio n. 1
0
        public void Setup()
        {
            // Three pieces of length 32kb.
            SmallTorrent = new TestTorrentData {
                Files       = new[] { new TorrentFile("foo", length: Piece.BlockSize * 2 * 3, startIndex: 0, endIndex: 2) },
                PieceLength = Piece.BlockSize * 2,
                Size        = Piece.BlockSize * 2 * 3,

                Bitfield = new BitField(3),
                Seeder   = PeerId.CreateNull(3, seeder: true, isChoking: false, amInterested: true)
            };

            // Three hundred pieces of length 4MB.
            LargeTorrent = new TestTorrentData {
                Files       = new[] { new TorrentFile("foo", length: Piece.BlockSize * 2 * 300, startIndex: 0, endIndex: 299) },
                PieceLength = Piece.BlockSize * 256,
                Size        = Piece.BlockSize * 256 * 300,

                Bitfield = new BitField(300),
                Seeder   = PeerId.CreateNull(300, seeder: true, isChoking: false, amInterested: true)
            };

            Standard = new StandardPicker();
            Endgame  = new EndGamePicker();
            Switcher = new EndGameSwitcher(Standard, Endgame, null);
        }
 public void Setup()
 {
     checker = new PiecePickerFilterChecker(new StandardPicker());
     picker  = new RandomisedPicker(checker);
     seeder  = PeerId.CreateNull(40, true, false, true);
     picker.Initialise(new TestTorrentData());
 }
Esempio n. 3
0
        public void Setup()
        {
            int pieceCount  = 40;
            int pieceLength = 256 * 1024;
            var torrentData = new TestTorrentData {
                Files       = TorrentFileInfo.Create(pieceLength, ("File", pieceLength * pieceCount, "full/path/File")),
                PieceLength = pieceLength,
                Size        = pieceLength * pieceCount
            };

            peers = new List <PeerId> ();

            torrentManager = TestRig.CreateSingleFileManager(torrentData.Size, torrentData.PieceLength);
            torrentManager.LoadFastResume(new FastResume(torrentManager.InfoHash, new BitField(pieceCount).SetAll(true), new BitField(pieceCount).SetAll(false)));

            manager = new PieceManager(torrentManager);
            manager.Initialise();

            peer = PeerId.CreateNull(pieceCount);
            for (int i = 0; i < 20; i++)
            {
                PeerId p = PeerId.CreateNull(pieceCount);
                p.SupportsFastPeer = true;
                peers.Add(p);
            }
        }
Esempio n. 4
0
        public void Setup()
        {
            int pieceLength = 16 * Piece.BlockSize;
            int pieces      = 40;
            int size        = pieces * pieceLength;

            bitfield    = new BitField(pieces);
            torrentData = new TestTorrentData {
                Files       = new [] { new TorrentFile("Test", size) },
                PieceLength = pieceLength,
                Size        = size
            };

            checker = new TestPicker();
            picker  = new RarestFirstPicker(checker);
            picker.Initialise(bitfield, torrentData, new List <Piece>());

            peer = PeerId.CreateNull(pieces);
            peer.BitField.SetAll(true);

            peers = new List <PeerId>();
            for (int i = 0; i < 5; i++)
            {
                peers.Add(PeerId.CreateNull(pieces));
            }
        }
        public void Setup()
        {
            var pieceCount  = 40;
            var pieceLength = 256 * 1024;

            torrentData = new TestTorrentData {
                Files       = new[] { new TorrentFileInfo(new TorrentFile("One File", pieceLength * pieceCount, 0, pieceCount)) },
                PieceLength = pieceLength,
                Size        = pieceLength * pieceCount
            };

            bitfield = new BitField(torrentData.PieceCount)
                       .SetAll(true)
                       .Set(4, false)
                       .Set(6, false)
                       .Set(24, false)
                       .Set(36, false);

            picker = new EndGamePicker();
            pieces = new List <Piece> (new[] {
                new Piece(4, torrentData.PieceLength, torrentData.Size),
                new Piece(6, torrentData.PieceLength, torrentData.Size),
                new Piece(24, torrentData.PieceLength, torrentData.Size),
                new Piece(36, torrentData.PieceLength, torrentData.Size)
            });

            id           = PeerId.CreateNull(torrentData.PieceCount);
            id.IsChoking = false;

            other           = PeerId.CreateNull(torrentData.PieceCount);
            other.IsChoking = false;
        }
        public void Setup()
        {
            int pieceCount  = 40;
            int pieceLength = 256 * 1024;

            bitfield    = new BitField(pieceCount);
            torrentData = new TestTorrentData {
                Files       = new [] { new TorrentFile("File", pieceLength * pieceCount) },
                PieceLength = pieceLength,
                Size        = pieceLength * pieceCount
            };
            peers = new List <PeerId>();

            magnetLink     = new MagnetLink(new InfoHash(new byte[20]));
            torrentManager = new TorrentManager(magnetLink, "", new TorrentSettings(), "");
            manager        = new PieceManager(torrentManager);
            manager.ChangePicker(new StandardPicker(), bitfield, torrentData);

            peer = PeerId.CreateNull(pieceCount);
            for (int i = 0; i < 20; i++)
            {
                PeerId p = PeerId.CreateNull(pieceCount);
                p.SupportsFastPeer = true;
                peers.Add(p);
            }
        }
        public void Setup()
        {
            int pieceLength = 16 * Piece.BlockSize;
            int pieces      = 40;
            int size        = pieces * pieceLength;

            bitfield    = new MutableBitField(pieces);
            torrentData = new TestTorrentData {
                Files       = TorrentFileInfo.Create(pieceLength, ("Test", size, "Full/Path/Test")),
                PieceLength = pieceLength,
                Size        = size
            };

            checker = new PiecePickerFilterChecker();
            picker  = new RarestFirstPicker(checker);
            picker.Initialise(torrentData);

            peer = PeerId.CreateNull(pieces);
            peer.MutableBitField.SetAll(true);

            peers = new List <PeerId> ();
            for (int i = 0; i < 5; i++)
            {
                peers.Add(PeerId.CreateNull(pieces));
            }
        }
        public void DupeRequests_PickSameBlockTwiceWhenAllRequested()
        {
            var seeder1     = PeerId.CreateNull(bitfield.Length, true, false, true);
            var seeder2     = PeerId.CreateNull(bitfield.Length, true, false, true);
            var singlePiece = peers[0].BitField.SetAll(false).Set(3, true);

            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder1, 0, bitfield.Length));

            BlockInfo?req;
            var       requests1 = new List <BlockInfo> ();

            while ((req = picker.PickPiece(seeder1, singlePiece)) != null)
            {
                requests1.Add(req.Value);
            }

            // There are no pieces owned by this peer, so there's nothing to continue.
            Assert.IsNull(picker.ContinueExistingRequest(seeder2, 0, bitfield.Length));

            // Every block has been requested once and no duplicates are allowed.
            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder2, 0, bitfield.Length));

            // Every block has been requested once and no duplicates are allowed.
            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder2, 0, bitfield.Length, 1));

            var requests2 = new List <BlockInfo> ();

            while ((req = picker.ContinueAnyExistingRequest(seeder2, 0, bitfield.Length, 2)) != null)
            {
                requests2.Add(req.Value);
            }

            CollectionAssert.AreEquivalent(requests1, requests2);
        }
Esempio n. 9
0
        public void Setup()
        {
            int pieceCount  = 40;
            int pieceLength = 256 * 1024;

            bitfield    = new BitField(pieceCount);
            torrentData = new TestTorrentData {
                Files       = new[] { new TorrentFileInfo(new TorrentFile("File", pieceLength * pieceCount)) },
                PieceLength = pieceLength,
                Size        = pieceLength * pieceCount
            };
            peers = new List <PeerId> ();

            torrentManager = TestRig.CreateSingleFileManager(torrentData.Size, torrentData.PieceLength);
            torrentManager.LoadFastResume(new FastResume(torrentManager.InfoHash, new BitField(pieceCount).SetAll(true), new BitField(pieceCount).SetAll(false)));
            manager = new PieceManager(torrentManager);
            manager.ChangePicker(new StandardPicker(), bitfield);
            manager.Picker.Initialise(bitfield, torrentData, Enumerable.Empty <Piece> ());

            peer = PeerId.CreateNull(pieceCount);
            for (int i = 0; i < 20; i++)
            {
                PeerId p = PeerId.CreateNull(pieceCount);
                p.SupportsFastPeer = true;
                peers.Add(p);
            }
        }
Esempio n. 10
0
        public async Task AddPeers_PeerExchangeMessage_Private()
        {
            var peer = new byte[] { 192, 168, 0, 1, 100, 0 };
            var dotF = new byte[] { 1 << 0 | 1 << 2 }; // 0x1 means supports encryption, 0x2 means is a seeder
            var id   = PeerId.CreateNull(40);

            id.SupportsFastPeer   = true;
            id.SupportsLTMessages = true;

            var manager = TestRig.CreatePrivate();

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peersTask = new TaskCompletionSource <PeerExchangePeersAdded> ();

            manager.PeersFound += (o, e) => {
                if (e is PeerExchangePeersAdded args)
                {
                    peersTask.TrySetResult(args);
                }
            };

            var exchangeMessage = new PeerExchangeMessage(13, peer, dotF, null);

            manager.Mode.HandleMessage(id, exchangeMessage);

            var addedArgs = await peersTask.Task.WithTimeout();

            Assert.AreEqual(0, addedArgs.NewPeers, "#1");
        }
Esempio n. 11
0
        public void SmallTorrent_RequestAll_TriggerEndgame()
        {
            Switcher.Initialise(SmallTorrent.Bitfield, SmallTorrent, Enumerable.Empty <Piece> ());
            // Pretend we have all the pieces except one.
            SmallTorrent.Bitfield.SetAll(true).Set(0, false);
            // When picking we should indicate there's 1 piece that we desire - the one we're missing.
            var onePieceLeft = SmallTorrent.Bitfield.Clone().Not();

            // Only 2 blocks should be left to be requested, so add 1 request per person.
            var seeders = new[] {
                PeerId.CreateNull(SmallTorrent.Bitfield.Length, seeder: true, isChoking: false, amInterested: true),
                PeerId.CreateNull(SmallTorrent.Bitfield.Length, seeder: true, isChoking: false, amInterested: true),
            };

            foreach (var peer in seeders)
            {
                Assert.IsNotNull(Switcher.PickPiece(peer, onePieceLeft, Array.Empty <IPieceRequester> ()), "#1");
                Assert.AreEqual(1, peer.AmRequestingPiecesCount, "#2");
                Assert.AreSame(Standard, Switcher.ActivePicker, "#3");
            }

            // The next request *should* trigger endgame mode and give a valid request.
            Assert.IsNotNull(Switcher.PickPiece(SmallTorrent.Seeder, onePieceLeft, Array.Empty <IPieceRequester> ()), "#4");
            Assert.AreSame(Endgame, Switcher.ActivePicker, "#5");
        }
Esempio n. 12
0
        public void LargeTorrent_RequestAll_TriggerEndgame()
        {
            Switcher.Initialise(LargeTorrent.Bitfield, LargeTorrent, Enumerable.Empty <Piece> ());
            // Pretend we have all the pieces except one.
            LargeTorrent.Bitfield.SetAll(true).Set(0, false);
            // When picking we should indicate there's 1 piece that we desire - the one we're missing.
            var onePieceLeft = LargeTorrent.Bitfield.Clone().Not();

            // Only 2 blocks should be left to be requested, so add 1 request per person.
            var seeders = new List <PeerId> ();

            for (int i = 0; i < LargeTorrent.PieceLength / Piece.BlockSize; i++)
            {
                seeders.Add(PeerId.CreateNull(LargeTorrent.Bitfield.Length, seeder: true, isChoking: false, amInterested: true));
            }

            // 256 blocks per piece, request 1 block per peer.
            foreach (var peer in seeders)
            {
                Assert.IsNotNull(Switcher.PickPiece(peer, onePieceLeft, Array.Empty <IPieceRequester> ()) ?? Switcher.ContinueAnyExisting(peer, 0, LargeTorrent.Bitfield.Length - 1), "#1");
                Assert.AreEqual(1, peer.AmRequestingPiecesCount, "#2");
                Assert.AreSame(Standard, Switcher.ActivePicker, "#3");
            }

            // Trigger endgame mode, but don't pick a piece.
            Assert.IsInstanceOf <StandardPicker> (Switcher.ActivePicker);
            Assert.IsNull(Switcher.ContinueAnyExisting(LargeTorrent.Seeder, 0, LargeTorrent.Bitfield.Length - 1));
            Assert.IsInstanceOf <EndGamePicker> (Switcher.ActivePicker);

            // The next request *should* get a valid request.
            Assert.IsNotNull(Switcher.PickPiece(LargeTorrent.Seeder, onePieceLeft, Array.Empty <IPieceRequester> ()), "#4");
            Assert.AreSame(Endgame, Switcher.ActivePicker, "#5");
        }
Esempio n. 13
0
        public void MismatchedInfoHash()
        {
            Manager.Mode = new DownloadMode(Manager, DiskManager, ConnectionManager, Settings);
            var peer      = PeerId.CreateNull(Manager.Bitfield.Length);
            var handshake = new HandshakeMessage(new InfoHash(Enumerable.Repeat((byte)15, 20).ToArray()), "peerid", VersionInfo.ProtocolStringV100);

            Assert.Throws <TorrentException> (() => Manager.Mode.HandleMessage(peer, handshake));
        }
Esempio n. 14
0
        public void MismatchedProtocolString()
        {
            Manager.Mode = new DownloadMode(Manager, DiskManager, ConnectionManager, Settings);
            var peerId    = PeerId.CreateNull(Manager.Bitfield.Length);
            var handshake = new HandshakeMessage(Manager.InfoHash, "peerid", "bleurgh");

            Assert.Throws <ProtocolException> (() => Manager.Mode.HandleMessage(peerId, handshake));
        }
Esempio n. 15
0
        public void Setup()
        {
            checker = new TestPicker();
            picker  = new RandomisedPicker(checker);

            pieceCount = 40;
            peer       = PeerId.CreateNull(pieceCount);
            peer.BitField.SetAll(true);
        }
Esempio n. 16
0
        public async Task UnknownMetadataLength()
        {
            await Setup(true);

            ExtendedHandshakeMessage exHand = new ExtendedHandshakeMessage(false, null, 5555);

            exHand.Supports.Add(LTMetadata.Support);
            Assert.DoesNotThrow(() => rig.Manager.Mode.HandleMessage(PeerId.CreateNull(1), exHand));
        }
Esempio n. 17
0
        public void MismatchedPeerId_PublicTorrent()
        {
            Manager.Mode = new DownloadMode(Manager, DiskManager, ConnectionManager, Settings);
            var peer      = PeerId.CreateNull(Manager.Bitfield.Length);
            var handshake = new HandshakeMessage(Manager.InfoHash, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), VersionInfo.ProtocolStringV100, false);

            Assert.DoesNotThrow(() => Manager.Mode.HandleMessage(peer, handshake));
            Assert.AreEqual(peer.PeerID, handshake.PeerId);
        }
Esempio n. 18
0
        public void MismatchedPeerId_PrivateTorrent()
        {
            var manager = TestRig.CreatePrivate();

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peer      = PeerId.CreateNull(manager.Bitfield.Length);
            var handshake = new HandshakeMessage(manager.InfoHash, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), VersionInfo.ProtocolStringV100, false);

            Assert.Throws <TorrentException> (() => manager.Mode.HandleMessage(peer, handshake));
        }
Esempio n. 19
0
        public void ReceivedPiecesAreNotRequested()
        {
            for (int i = 2; i < pieces[0].BlockCount; i++)
            {
                pieces[0].Blocks[i].CreateRequest(PeerId.CreateNull(torrentData.PieceCount));
                pieces[0].Blocks[i].Received = true;
            }

            picker.Initialise(bitfield, torrentData, pieces);
            Assert.IsTrue(picker.Requests.All(t => !t.Block.Received), "#1");
        }
Esempio n. 20
0
        public void EmptyPeerId_PublicTorrent()
        {
            Manager.Mode = new DownloadMode(Manager, DiskManager, ConnectionManager, Settings);
            var peer = PeerId.CreateNull(Manager.Bitfield.Length);

            peer.Peer.PeerId = null;
            var handshake = new HandshakeMessage(Manager.InfoHashes.V1OrV2, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), Constants.ProtocolStringV100, false);

            Manager.Mode.HandleMessage(peer, handshake, default);
            Assert.AreEqual(handshake.PeerId, peer.PeerID);
        }
Esempio n. 21
0
        public void EmptyPeerId_PrivateTorrent()
        {
            var manager = TestRig.CreatePrivate();

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peer = PeerId.CreateNull(manager.Bitfield.Length);

            peer.Peer.PeerId = null;
            var handshake = new HandshakeMessage(manager.InfoHash, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), VersionInfo.ProtocolStringV100, false);

            manager.Mode.HandleMessage(peer, handshake);
            Assert.AreEqual(handshake.PeerId, peer.PeerID);
        }
        public async Task MismatchedPeerId_PrivateTorrent()
        {
            var torrent = TestRig.CreatePrivate();

            using var engine = new ClientEngine(EngineSettingsBuilder.CreateForTests());
            var manager = await engine.AddAsync(torrent, "");

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peer      = PeerId.CreateNull(manager.Bitfield.Length);
            var handshake = new HandshakeMessage(manager.InfoHash, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), VersionInfo.ProtocolStringV100, false);

            Assert.Throws <TorrentException> (() => manager.Mode.HandleMessage(peer, handshake));
        }
        public void Setup()
        {
            singleFile     = CreateSingleFile();
            singleBitfield = new BitField(singleFile.Files.Single().EndPieceIndex + 1).SetAll(true);
            singlePeer     = PeerId.CreateNull(singleBitfield.Length);

            multiFile     = CreateMultiFile();
            multiBitfield = new BitField(multiFile.Files.Last().EndPieceIndex + 1).SetAll(true);
            multiPeer     = PeerId.CreateNull(multiBitfield.Length);

            tester = new TestPicker();
            picker = new PriorityPicker(tester);
            peers  = new List <PeerId>();
        }
Esempio n. 24
0
        public void Setup()
        {
            singleFile     = CreateSingleFile();
            singleBitfield = new MutableBitField(singleFile.PieceCount()).SetAll(true);
            singlePeer     = PeerId.CreateNull(singleBitfield.Length);

            multiFile     = CreateMultiFile();
            multiBitfield = new MutableBitField(multiFile.PieceCount()).SetAll(true);
            multiPeer     = PeerId.CreateNull(multiBitfield.Length);

            checker = new PiecePickerFilterChecker();
            picker  = new PriorityPicker(checker);
            peers   = new List <PeerId> ();
        }
        public void Setup()
        {
            blocksPerPiece = 4;
            pieceCount     = 40;

            bitfield = new BitField(pieceCount);
            data     = new TorrentData {
                PieceLength = Piece.BlockSize * blocksPerPiece,
                Files       = new[] { new TorrentFile("Test", Piece.BlockSize * blocksPerPiece * pieceCount, 0, pieceCount - 1) },
                Size        = Piece.BlockSize * blocksPerPiece * pieceCount - 10
            };

            peer = PeerId.CreateNull(pieceCount, seeder: true, isChoking: false, amInterested: true);
        }
Esempio n. 26
0
        public async Task EmptyPeerId_PrivateTorrent()
        {
            var torrent = TestRig.CreatePrivate();

            using var engine = new ClientEngine(EngineSettingsBuilder.CreateForTests());
            var manager = await engine.AddAsync(torrent, "");

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peer = PeerId.CreateNull(manager.Bitfield.Length);

            peer.Peer.PeerId = null;
            var handshake = new HandshakeMessage(manager.InfoHashes.V1OrV2, new BEncodedString(Enumerable.Repeat('c', 20).ToArray()), Constants.ProtocolStringV100, false);

            manager.Mode.HandleMessage(peer, handshake, default);
            Assert.AreEqual(handshake.PeerId, peer.PeerID);
        }
        public void DupeRequests_CanRequestInTriplicate()
        {
            var seeders = new IPeer[] {
                PeerId.CreateNull(bitfield.Length, true, false, true),
                PeerId.CreateNull(bitfield.Length, true, false, true),
                PeerId.CreateNull(bitfield.Length, true, false, true),
            };

            var queue       = new Queue <IPeer> (seeders);
            var requests    = seeders.ToDictionary(t => t, t => new List <BlockInfo> ());
            var singlePiece = seeders[0].BitField.Clone().SetAll(false).Set(3, true);

            // Request an entire piece using 1 peer first to ensure we have collisions when
            // issuing duplicates. In the end all peers should have the same set though.
            while (true)
            {
                var req = picker.PickPiece(seeders[0], singlePiece)
                          ?? picker.ContinueAnyExistingRequest(seeders[0], 0, bitfield.Length - 1, 3);
                if (req.HasValue)
                {
                    requests[seeders[0]].Add(req.Value);
                }
                else
                {
                    break;
                }
            }
            Assert.AreEqual(torrentData.BlocksPerPiece, requests[seeders[0]].Count);

            while (queue.Count > 0)
            {
                var seeder = queue.Dequeue();
                var req    = picker.PickPiece(seeder, singlePiece)
                             ?? picker.ContinueAnyExistingRequest(seeder, 0, bitfield.Length - 1, 3);

                if (req.HasValue)
                {
                    queue.Enqueue(seeder);
                    requests[seeder].Add(req.Value);
                }
            }

            CollectionAssert.AreEquivalent(requests[seeders[0]], requests[seeders[1]]);
            CollectionAssert.AreEquivalent(requests[seeders[1]], requests[seeders[2]]);
            Assert.AreEqual(torrentData.BlocksPerPiece, requests.Values.First().Count);
        }
        public void DupeRequests_PeerCannotDuplicateOwnRequest()
        {
            var seeder      = PeerId.CreateNull(bitfield.Length, true, false, true);
            var singlePiece = seeder.BitField.Clone().SetAll(false).Set(3, true);

            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder, 0, bitfield.Length - 1));

            BlockInfo?req;
            var       requests = new List <BlockInfo> ();

            while ((req = picker.PickPiece(seeder, singlePiece)) != null)
            {
                requests.Add(req.Value);
            }

            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder, 0, bitfield.Length - 1));
            Assert.IsNull(picker.ContinueAnyExistingRequest(seeder, 0, bitfield.Length - 1, 2));
        }
Esempio n. 29
0
        public void MultiPick()
        {
            id.BitField.Set(pieces[0].Index, true);
            other.BitField.Set(pieces[0].Index, true);

            for (int i = 2; i < pieces[0].BlockCount; i++)
            {
                pieces[0].Blocks[i].CreateRequest(PeerId.CreateNull(torrentData.PieceCount));
                pieces[0].Blocks[i].Received = true;
            }

            picker.Initialise(bitfield, torrentData, pieces);

            // Pick blocks 1 and 2 for both peers
            while (picker.PickPiece(id, id.BitField, new List <PeerId>()) != null)
            {
            }
            while (picker.PickPiece(other, id.BitField, new List <PeerId>()) != null)
            {
            }

            Assert.AreEqual(2, id.AmRequestingPiecesCount, "#1");
            Assert.AreEqual(2, other.AmRequestingPiecesCount, "#1");

            Piece piece;

            if (!picker.ValidatePiece(id, pieces[0].Index, pieces[0][0].StartOffset, pieces[0][0].RequestLength, out piece))
            {
                Assert.Fail("I should've validated!");
            }

            if (picker.ValidatePiece(other, pieces[0].Index, pieces[0][0].StartOffset, pieces[0][0].RequestLength, out piece))
            {
                Assert.Fail("I should not have validated!");
            }

            Assert.AreEqual(1, id.AmRequestingPiecesCount, "#1");
            Assert.AreEqual(1, other.AmRequestingPiecesCount, "#1");
            Assert.IsTrue(pieces[0][0].Received, "#5");
            Assert.AreEqual(16, pieces[0].TotalRequested, "#6");
            Assert.AreEqual(15, pieces[0].TotalReceived, "#7");
        }
        public void PickHighestPriority()
        {
            var data             = new TorrentData();
            var ignoringBitfield = new MutableBitField(data.PieceCount())
                                   .SetAll(false);

            var requester = new StreamingPieceRequester();

            requester.Initialise(data, new[] { ignoringBitfield });
            requester.SeekToPosition(data.Files[0], data.PieceLength * 3);

            var peer = PeerId.CreateNull(ignoringBitfield.Length, true, false, true);

            requester.AddRequests(peer, Array.Empty <IPeerWithMessaging> ());
            Assert.AreEqual(4, peer.AmRequestingPiecesCount);

            var requests = GetRequests(peer);

            Assert.AreEqual(4, requests.Count);
            Assert.IsTrue(requests.All(r => r.PieceIndex == 3));
        }