public async Task ReadZeroFromDisk()
{
PieceWriter.FilesThatExist.AddRange(new[] {
Manager.Files [0],
Manager.Files [2],
});
PieceWriter.DoNotReadFrom.AddRange(new[] {
Manager.Files[0],
Manager.Files[3],
});
var bf = new MutableBitField(Manager.PieceCount()).SetAll(true);
Manager.LoadFastResume(new FastResume(Manager.InfoHash, bf, Manager.UnhashedPieces.SetAll(false)));
Assert.IsTrue(Manager.Bitfield.AllTrue, "#1");
foreach (var file in Manager.Files)
{
Assert.IsTrue(file.BitField.AllTrue, "#2." + file.Path);
}
var mode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = mode;
await mode.WaitForHashingToComplete();
Assert.IsTrue(Manager.Bitfield.AllFalse, "#3");
foreach (var file in Manager.Files)
{
Assert.IsTrue(file.BitField.AllFalse, "#4." + file.Path);
}
}
public async Task DoNotDownload_OneFile()
{
Manager.MutableBitField.SetAll(true);
foreach (var f in Manager.Files.Skip(1))
{
PieceWriter.FilesThatExist.Add(f);
await Manager.SetFilePriorityAsync(f, Priority.DoNotDownload);
}
var hashingMode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = hashingMode;
await hashingMode.WaitForHashingToComplete();
// No piece should be marked as available
Assert.IsTrue(Manager.Bitfield.AllFalse, "#1");
// Only one piece should actually have been hash checked.
Assert.AreEqual(1, Manager.UnhashedPieces.Length - Manager.UnhashedPieces.TrueCount, "#2");
Assert.IsFalse(Manager.UnhashedPieces[0], "#3");
Manager.PieceManager.AddPieceRequests(Peer);
Assert.AreNotEqual(0, Peer.AmRequestingPiecesCount, "#4");
}
public async Task DoNotDownload_All()
{
Manager.MutableBitField.SetAll(true);
foreach (var f in Manager.Files)
{
PieceWriter.FilesThatExist.Add(f);
await Manager.SetFilePriorityAsync(f, Priority.DoNotDownload);
((MutableBitField)f.BitField).SetAll(true);
}
var hashingMode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = hashingMode;
await hashingMode.WaitForHashingToComplete().WithTimeout();
Manager.PieceManager.AddPieceRequests(Peer);
Assert.AreEqual(0, Peer.AmRequestingPiecesCount, "#1");
// No piece should be marked as available, and no pieces should actually be hashchecked.
Assert.IsTrue(Manager.Bitfield.AllFalse, "#2");
Assert.AreEqual(Manager.UnhashedPieces.TrueCount, Manager.UnhashedPieces.Length, "#3");
foreach (var f in Manager.Files)
{
Assert.IsTrue(f.BitField.AllFalse, "#4." + f.Path);
}
}
public async Task PauseResumeHashingMode()
{
var pieceHashed = new TaskCompletionSource <object> ();
Manager.PieceHashed += (o, e) => pieceHashed.TrySetResult(null);
var mode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = mode;
var pausedEvent = Manager.WaitForState(TorrentState.HashingPaused);
mode.Pause();
await pausedEvent.WithTimeout("#pause");
Assert.AreEqual(TorrentState.HashingPaused, mode.State, "#a");
var hashingTask = mode.WaitForHashingToComplete();
await Task.Delay(50);
Assert.IsFalse(pieceHashed.Task.IsCompleted, "#1");
var resumeEvent = Manager.WaitForState(TorrentState.Hashing);
mode.Resume();
await resumeEvent.WithTimeout("#resume");
Assert.AreEqual(pieceHashed.Task, await Task.WhenAny(pieceHashed.Task, Task.Delay(1000)), "#2");
Assert.AreEqual(TorrentState.Hashing, mode.State, "#b");
}
public async Task DoNotDownload_ThenDownload()
{
DiskManager.GetHashAsyncOverride = (manager, index, dest) => {
if (index >= 0 && index <= 4)
{
Manager.Torrent.Pieces.ReadHash(index, dest.Span);
}
else
{
Enumerable.Repeat((byte)255, 20).ToArray().CopyTo(dest);
}
return(Task.FromResult(true));
};
Manager.MutableBitField.SetAll(true);
foreach (var f in Manager.Files)
{
PieceWriter.FilesThatExist.Add(f);
await Manager.SetFilePriorityAsync(f, Priority.DoNotDownload);
}
var hashingMode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = hashingMode;
await hashingMode.WaitForHashingToComplete();
Assert.IsTrue(Manager.UnhashedPieces.AllTrue, "#1");
// Nothing should be available to download.
Manager.PieceManager.AddPieceRequests(Peer);
Assert.AreEqual(0, Peer.AmRequestingPiecesCount, "#1b");
Manager.Mode = new DownloadMode(Manager, DiskManager, ConnectionManager, Settings);
foreach (var file in Manager.Files)
{
await Manager.SetFilePriorityAsync(file, Priority.Normal);
await Manager.Mode.TryHashPendingFilesAsync();
for (int i = file.StartPieceIndex; i <= file.EndPieceIndex; i++)
{
Assert.IsFalse(Manager.UnhashedPieces[i], "#2." + i);
}
}
// No piece should be marked as available, and no pieces should actually be hashchecked.
Assert.IsTrue(Manager.UnhashedPieces.AllFalse, "#3");
// These pieces should now be available for download
Manager.PieceManager.AddPieceRequests(Peer);
Assert.AreNotEqual(0, Peer.AmRequestingPiecesCount, "#4");
Assert.AreEqual(5, Manager.finishedPieces.Count, "#5");
}
public async Task StopWhileHashing()
{
var mode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = mode;
mode.Pause();
var hashingTask = mode.WaitForHashingToComplete();
await Manager.StopAsync();
Assert.ThrowsAsync <TaskCanceledException> (() => hashingTask, "#1");
Assert.AreEqual(Manager.State, TorrentState.Stopped, "#2");
}
public void CancelHashing()
{
var mode = new HashingMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = mode;
mode.Pause();
var hashingTask = mode.WaitForHashingToComplete();
var stoppedMode = new StoppedMode(Manager, DiskManager, ConnectionManager, Settings);
Manager.Mode = stoppedMode;
// Ensure the hashing mode ends and does not throw exceptions.
Assert.ThrowsAsync <TaskCanceledException> (() => hashingTask, "#1");
Assert.AreSame(stoppedMode, Manager.Mode, "#2");
}
