public void Setup()
{
file = new TorrentFileInfo(new TorrentFile("Relative/Path.txt", Piece.BlockSize * 5));
level2 = new MemoryWriter(new NullWriter(), Piece.BlockSize * 3);
level1 = new MemoryWriter(level2, Piece.BlockSize * 3);
}
public async Task FlushMultipleBlocks()
{
byte[] buffer;
var blocking = new BlockingWriter();
var memory = new MemoryWriter(blocking, Piece.BlockSize * 3);
// Write 3 blocks
for (int i = 0; i < 3; i++)
{
buffer = Enumerable.Repeat((byte)(i + 1), Piece.BlockSize).ToArray();
await memory.WriteAsync(file, Piece.BlockSize *i, buffer, 0, buffer.Length).WithTimeout();
}
// Flush them all
var flushTask = memory.FlushAsync(file);
// Process the first flush
blocking.Writes.TakeWithTimeout().tcs.SetResult(null);
// write a new block
buffer = Enumerable.Repeat((byte)1, Piece.BlockSize).ToArray();
await memory.WriteAsync(file, Piece.BlockSize, buffer, 0, buffer.Length).WithTimeout();
// Process the remaining two flushes
blocking.Writes.TakeWithTimeout().tcs.SetResult(null);
blocking.Writes.TakeWithTimeout().tcs.SetResult(null);
await flushTask.WithTimeout();
}
public EngineTestRig(string savePath, int piecelength, PieceWriter writer)
{
if (writer == null)
writer = new MemoryWriter(new NullWriter());
Listener = new CustomListener();
Engine = new ClientEngine(new EngineSettings(), Listener, writer);
TorrentDict = CreateTorrent(piecelength);
Torrent = Torrent.Load(TorrentDict);
Manager = new TorrentManager(Torrent, savePath, new TorrentSettings());
Engine.Register(Manager);
//manager.Start();
}
public MemoryWriterTests()
{
pieceLength = Piece.BlockSize*2;
singleFile = new TorrentFile("path", Piece.BlockSize*5);
multiFile = new[]
{
new TorrentFile("first", Piece.BlockSize - 550),
new TorrentFile("second", 100),
new TorrentFile("third", Piece.BlockSize)
};
buffer = new byte[Piece.BlockSize];
torrentSize = Toolbox.Accumulate(multiFile, delegate(TorrentFile f) { return f.Length; });
Initialise(buffer, 1);
level2 = new MemoryWriter(new NullWriter(), Piece.BlockSize*3);
level1 = new MemoryWriter(level2, Piece.BlockSize*3);
}
public async Task WriteBlockWhileFlushing()
{
var blocking = new BlockingWriter();
var memory = new MemoryWriter(blocking, Piece.BlockSize * 3);
await memory.WriteAsync(file, Piece.BlockSize, new byte[Piece.BlockSize], 0, Piece.BlockSize).WithTimeout();
// Begin flushing the piece, but write another block to the cache while the flush is in-progress
var flushTask = memory.FlushAsync(file);
await memory.WriteAsync(file, Piece.BlockSize, new byte[Piece.BlockSize], 0, Piece.BlockSize).WithTimeout();
blocking.Writes.TakeWithTimeout().tcs.SetResult(null);
await flushTask.WithTimeout();
// At the end we should have one block still in the cache.
Assert.AreEqual(Piece.BlockSize, memory.CacheUsed);
}
public void Setup()
{
blocks = new List<BufferedIO>();
level2 = new MemoryWriter(new NullWriter(this), (int)(PieceSize * 1.7));
level1 = new MemoryWriter(level2, (int)(PieceSize * 0.7));
for (int piece = 0; piece < PieceCount; piece++)
for (int block = 0; block < BlockCount; block++)
blocks.Add(CreateBlock(piece, block));
}
public void Setup()
{
Initialise(buffer, 1);
level2 = new MemoryWriter(new NullWriter(), Piece.BlockSize * 3);
level1 = new MemoryWriter(level2, Piece.BlockSize * 3);
}
public void Setup()
{
Initialise(buffer, 1);
level2 = new MemoryWriter(new NullWriter(), Piece.BlockSize * 3);
level1 = new MemoryWriter(level2, Piece.BlockSize * 3);
}
