[core] Move some more code to the helper methods

alanmcgovern · Feb 18, 2021 · 59d0208 · 59d0208
1 parent 42f4b8a
commit 59d0208
Show file tree

Hide file tree

Showing 6 changed files with 46 additions and 26 deletions.
diff --git a/src/MonoTorrent.Tests/Client/TorrentDataExtensionsTests.cs b/src/MonoTorrent.Tests/Client/TorrentDataExtensionsTests.cs
@@ -27,18 +27,7 @@
 //
 
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-using MonoTorrent.BEncoding;
-using MonoTorrent.Client.Connections;
-using MonoTorrent.Client.Messages;
-using MonoTorrent.Client.Messages.Standard;
 
 using NUnit.Framework;
 
@@ -61,6 +50,23 @@ public void BlocksPerPiece ()
             Assert.AreEqual (2, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.BlocksPerPiece (1));
             Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4 + 1, PieceLength = Piece.BlockSize * 2 }.BlocksPerPiece (2));
             Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 5 - 1, PieceLength = Piece.BlockSize * 2 }.BlocksPerPiece (2));
+
+            Assert.AreEqual (2, new Data { Size = (long) (int.MaxValue) * 4, PieceLength = Piece.BlockSize * 2 }.BlocksPerPiece (0));
+        }
+
+        [Test]
+        public void ByteOffsetToPieceIndex ()
+        {
+            Assert.AreEqual (0, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (0));
+            Assert.AreEqual (0, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (1));
+            Assert.AreEqual (0, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 2 - 1));
+            Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 2));
+            Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 2 + 1));
+            Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 3 - 1));
+            Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 3));
+            Assert.AreEqual (2, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 4));
+
+            Assert.AreEqual (2, new Data { Size = (long) (int.MaxValue) * 4, PieceLength = Piece.BlockSize * 2 }.ByteOffsetToPieceIndex (Piece.BlockSize * 4));
         }
 
         [Test]
@@ -71,6 +77,8 @@ public void BytesPerPiece ()
 
             Assert.AreEqual (1, new Data { Size = Piece.BlockSize * 4 + 1, PieceLength = Piece.BlockSize * 2 }.BytesPerPiece (2));
             Assert.AreEqual (Piece.BlockSize - 1, new Data { Size = Piece.BlockSize * 5 - 1, PieceLength = Piece.BlockSize * 2 }.BytesPerPiece (2));
+
+            Assert.AreEqual (Piece.BlockSize * 2, new Data { Size = (long) (int.MaxValue) * 4, PieceLength = Piece.BlockSize * 2 }.BytesPerPiece (2));
         }
 
         [Test]
@@ -80,6 +88,8 @@ public void PieceCount ()
             Assert.AreEqual (2, new Data { Size = Piece.BlockSize * 4 - 1, PieceLength = Piece.BlockSize * 2 }.PieceCount ());
             Assert.AreEqual (2, new Data { Size = Piece.BlockSize * 4, PieceLength = Piece.BlockSize * 2 }.PieceCount ());
             Assert.AreEqual (3, new Data { Size = Piece.BlockSize * 4 + 1, PieceLength = Piece.BlockSize * 2 }.PieceCount ());
+
+            Assert.AreEqual (262144, new Data { Size = (long) (int.MaxValue) * 4, PieceLength = Piece.BlockSize * 2 }.PieceCount ());
         }
     }
 }
diff --git a/src/MonoTorrent.Tests/Streaming/StreamProviderTests.cs b/src/MonoTorrent.Tests/Streaming/StreamProviderTests.cs
@@ -161,10 +161,10 @@ public async Task ReadLastByte ()
             provider.Manager.Bitfield.SetAll (true); // the public API shouldn't allow this.
 
             using var stream = await provider.CreateStreamAsync (provider.Files[0], prebuffer: false, CancellationToken.None).WithTimeout ();
-            stream.Seek (1, SeekOrigin.End);
+            stream.Seek (-1, SeekOrigin.End);
             Assert.AreEqual (1, await stream.ReadAsync (new byte[1], 0, 1).WithTimeout ());
 
-            stream.Seek (1, SeekOrigin.End);
+            stream.Seek (-1, SeekOrigin.End);
             Assert.AreEqual (1, await stream.ReadAsync (new byte[5], 0, 5).WithTimeout ());
         }
 
@@ -178,6 +178,20 @@ public async Task SeekBeforeStart ()
             Assert.AreEqual (0, stream.Position);
         }
 
+        [Test]
+        public async Task SeekToMiddle ()
+        {
+            var provider = new StreamProvider (Engine, "testDir", Torrent);
+
+            await provider.StartAsync ();
+            await provider.Manager.WaitForState (TorrentState.Downloading);
+            provider.Manager.Bitfield.SetAll (true); // should not be allowed by public API.
+
+            using var stream = await provider.CreateStreamAsync (provider.Files[0], prebuffer: false, CancellationToken.None);
+            stream.Seek (12345, SeekOrigin.Begin);
+            Assert.AreEqual (provider.Manager.ByteOffsetToPieceIndex (12345), provider.Requester.HighPriorityPieceIndex);
+        }
+
         [Test]
         public async Task SeekPastEnd ()
         {

diff --git a/src/MonoTorrent/MonoTorrent.Client.PiecePicking/StreamingPieceRequester.cs b/src/MonoTorrent/MonoTorrent.Client.PiecePicking/StreamingPieceRequester.cs
@@ -262,8 +262,7 @@ internal void SeekToPosition (ITorrentFileInfo file, long position)
         /// <param name="position"></param>
         internal void ReadToPosition (ITorrentFileInfo file, long position)
         {
-            var pieceIndex = TorrentData.ByteOffsetToPieceIndex (position + file.OffsetInTorrent);
-            HighPriorityPieceIndex = Math.Min (file.EndPieceIndex, pieceIndex);
+            HighPriorityPieceIndex = Math.Min (file.EndPieceIndex, TorrentData.ByteOffsetToPieceIndex (position + file.OffsetInTorrent));
         }
     }
 }
diff --git a/src/MonoTorrent/MonoTorrent.Streaming/LocalStream.cs b/src/MonoTorrent/MonoTorrent.Streaming/LocalStream.cs
@@ -105,11 +105,8 @@ public override async Task<int> ReadAsync (byte[] buffer, int offset, int count,
                 return 0;
 
             // Take our current position into account when calculating the start/end pieces of the data we're reading.
-            var startPiece = (int) ((torrentFileStartOffset + Position) / Manager.Torrent.PieceLength);
-            var endPiece = (int) ((torrentFileStartOffset + Position + count) / Manager.Torrent.PieceLength);
-            if (Length % Manager.Torrent.PieceLength == 0 && endPiece == Manager.Torrent.Pieces.Count)
-                endPiece--;
-
+            var startPiece = Manager.ByteOffsetToPieceIndex (torrentFileStartOffset + Position);
+            var endPiece = Math.Min (File.EndPieceIndex, Manager.ByteOffsetToPieceIndex (torrentFileStartOffset + Position + count));
             while (Manager.State != TorrentState.Stopped && Manager.State != TorrentState.Error) {
                 bool allAvailable = true;
                 for (int i = startPiece; i <= endPiece && allAvailable; i++)
@@ -148,7 +145,7 @@ public override long Seek (long offset, SeekOrigin origin)
                     newPosition = position + offset;
                     break;
                 case SeekOrigin.End:
-                    newPosition = Length - offset;
+                    newPosition = Length + offset;
                     break;
                 default:
                     throw new NotSupportedException ();

diff --git a/src/MonoTorrent/MonoTorrent.Streaming/StreamProvider.cs b/src/MonoTorrent/MonoTorrent.Streaming/StreamProvider.cs
@@ -44,7 +44,7 @@ public class StreamProvider
     {
         LocalStream ActiveStream { get; set; }
         ClientEngine Engine { get; }
-        StreamingPieceRequester Requester { get; }
+        internal StreamingPieceRequester Requester { get; }
 
         /// <summary>
         /// Returns true when the <see cref="StreamProvider"/> has been started.

diff --git a/src/MonoTorrent/MonoTorrent/ITorrentData.cs b/src/MonoTorrent/MonoTorrent/ITorrentData.cs
@@ -56,19 +56,19 @@ public static int BlocksPerPiece (this ITorrentData self, int pieceIndex)
             if (pieceIndex < self.PieceCount () - 1)
                 return self.PieceLength / Piece.BlockSize;
 
-            var remainder = (int) self.Size - self.PieceLength * pieceIndex;
-            return (remainder + Piece.BlockSize - 1) / Piece.BlockSize;
+            var remainder = self.Size - self.PieceIndexToByteOffset (pieceIndex);
+            return (int) ((remainder + Piece.BlockSize - 1) / Piece.BlockSize);
         }
 
         public static int BytesPerPiece (this ITorrentData self, int pieceIndex)
         {
             if (pieceIndex < self.PieceCount () - 1)
                 return self.PieceLength;
-            return (int) (self.Size - (long) self.PieceLength * pieceIndex);
+            return (int) (self.Size - self.PieceIndexToByteOffset (pieceIndex));
         }
 
         public static int ByteOffsetToPieceIndex (this ITorrentData self, long offset)
-            => (int) ((offset / self.PieceLength) + (offset % self.PieceLength != 0 ? 1 : 0));
+            => (int) (offset / self.PieceLength);
 
         /// <summary>
         /// The number of pieces in the torrent