public void WriteFail()
{
writer.write = true;
Hookup();
diskManager.WriteAsync(rig.Manager, 0, data, data.Length).Wait();
CheckFail();
}
public async Task WriteFail()
{
writer.write = true;
await diskManager.WriteAsync(rig.Manager, 0, data, data.Length);
Assert.AreEqual(TorrentState.Error, rig.Manager.State);
}
public async Task ExceedWriteRate()
{
// Ensure the read rate is smaller than a block
await diskManager.UpdateSettingsAsync(new EngineSettingsBuilder { MaximumDiskWriteRate = 1, DiskCacheBytes = 0 }.ToSettings());
await diskManager.Tick(1000);
// Queue up 6 reads, none should process.
var buffer = new byte[Piece.BlockSize];
int count = 6;
var tasks = new List <Task> ();
for (int i = 0; i < count; i++)
{
tasks.Add(diskManager.WriteAsync(fileData, new BlockInfo(i / 3, Piece.BlockSize * (i % 3), Piece.BlockSize), buffer).AsTask());
}
Assert.AreEqual(buffer.Length * count, diskManager.PendingWriteBytes, "#1");
// We should still process none.
await diskManager.Tick(1000);
Assert.AreEqual(buffer.Length * count, diskManager.PendingWriteBytes, "#2");
// Give a proper max read rate.
await diskManager.UpdateSettingsAsync(new EngineSettingsBuilder { MaximumDiskWriteRate = Piece.BlockSize * 2, DiskCacheBytes = 0 }.ToSettings());
for (int i = 0; i < 2; i++)
{
await diskManager.Tick(1000);
for (int t = 0; t < 2; t++)
{
var completed = await Task.WhenAny(tasks).WithTimeout();
await completed;
tasks.Remove(completed);
}
Assert.IsFalse(tasks.Any(t => t.IsCompleted));
count -= 2;
Assert.AreEqual(buffer.Length * count, diskManager.PendingWriteBytes, "#3." + i);
}
// If we add more writes after we used up our allowance they still won't process.
for (int i = 0; i < 2; i++)
{
count++;
tasks.Add(diskManager.WriteAsync(fileData, new BlockInfo(0, Piece.BlockSize * i, Piece.BlockSize), buffer).AsTask());
}
Assert.AreEqual(buffer.Length * count, diskManager.PendingWriteBytes, "#4");
while (diskManager.PendingWriteBytes > 0)
{
await diskManager.Tick(1000);
for (int t = 0; t < 2; t++)
{
var completed = await Task.WhenAny(tasks).WithTimeout();
await completed;
tasks.Remove(completed);
}
Assert.IsFalse(tasks.Any(t => t.IsCompleted));
count -= 2;
Assert.AreEqual(buffer.Length * count, diskManager.PendingWriteBytes, "#5." + diskManager.PendingWriteBytes);
}
}
public void WriteFail()
{
writer.write = true;
Assert.ThrowsAsync <Exception> (() => diskManager.WriteAsync(data, 0, buffer, buffer.Length).AsTask());
}
public void WriteFail()
{
writer.write = true;
Assert.ThrowsAsync <Exception> (() => diskManager.WriteAsync(data, new BlockInfo(0, 0, Constants.BlockSize), buffer).AsTask());
}
public async Task ExceedWriteRate()
{
// Ensure the read rate is smaller than a block
settings.MaximumDiskWriteRate = 1;
await diskManager.Tick(1000);
// Queue up 6 reads, none should process.
var buffer = new byte[Piece.BlockSize];
int count = 6;
var tasks = new List <ReusableTask> ();
for (int i = 0; i < count; i++)
{
tasks.Add(diskManager.WriteAsync(fileData, 0, buffer, buffer.Length));
}
Assert.AreEqual(buffer.Length * count, diskManager.PendingWrites, "#1");
// We should still process none.
await diskManager.Tick(1000);
Assert.AreEqual(buffer.Length * count, diskManager.PendingWrites, "#2");
// Give a proper max read rate.
settings.MaximumDiskWriteRate = Piece.BlockSize * 2;
for (int i = 0; i < 2; i++)
{
await diskManager.Tick(1000);
count -= 2;
Assert.AreEqual(buffer.Length * count, diskManager.PendingWrites, "#3." + i);
}
// If we add more writes after we used up our allowance they still won't process.
for (int i = 0; i < 2; i++)
{
count++;
tasks.Add(diskManager.WriteAsync(fileData, 0, buffer, buffer.Length));
}
Assert.AreEqual(buffer.Length * count, diskManager.PendingWrites, "#4");
while (diskManager.PendingWrites > 0)
{
await diskManager.Tick(1000);
count -= 2;
Assert.AreEqual(buffer.Length * count, diskManager.PendingWrites, "#5." + diskManager.PendingWrites);
}
foreach (var v in tasks)
{
Assert.DoesNotThrowAsync(async() => await v.WithTimeout(1000), "#6");
}
}
public async Task ExceedWriteRate()
{
// Ensure the read rate is smaller than a block
settings.MaximumDiskWriteRate = 1;
await diskManager.Tick(1000);
// Queue up 6 reads, none should process.
var buffer = new byte[Piece.BlockSize];
var tasks = new List <Task> ();
for (int i = 0; i < 6; i++)
{
tasks.Add(diskManager.WriteAsync(fileData, 0, buffer, buffer.Length));
}
// We should still process none.
await diskManager.Tick(1000);
Assert.IsTrue(tasks.All(t => t.IsCompleted == false), "#1");
// Give a proper max read rate.
settings.MaximumDiskWriteRate = Piece.BlockSize * 2;
for (int i = 0; i < 2; i++)
{
await diskManager.Tick(1000);
Assert.AreEqual(2, tasks.Count(t => t.IsCompleted), "#1");
tasks.RemoveAll(t => t.IsCompleted);
}
// If we add more writes after we used up our allowance they still won't process.
for (int i = 0; i < 2; i++)
{
tasks.Add(diskManager.WriteAsync(fileData, 0, buffer, buffer.Length));
}
while (tasks.Count > 0)
{
await diskManager.Tick(1000);
Assert.AreEqual(2, tasks.Count(t => t.IsCompleted), "#1");
tasks.RemoveAll(t => t.IsCompleted);
}
}
