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 OnetimeSetup()
{
var random = new Random();
var filePieces = new long[] {
Piece.BlockSize / 2,
Piece.BlockSize,
Piece.BlockSize + Piece.BlockSize / 2,
Piece.BlockSize * 10 + Piece.BlockSize / 2,
};
int pieceLength = Piece.BlockSize * 3;
var files = TorrentFileInfo.Create(pieceLength, filePieces);
long total = files.Sum(f => f.Length);
var fileBytes = files
.Select(f => { var b = new byte[f.Length]; random.NextBytes(b); return(b); })
.ToArray();
// Turn all the files into one byte array. Group the byte array into bittorrent pieces. Hash that piece.
var hashes = fileBytes
.SelectMany(t => t)
.Partition(pieceLength)
.Select(t => SHA1.Create().ComputeHash(t))
.ToArray();
fileData = new TestTorrentData {
Data = fileBytes,
Files = files.ToArray(),
Hashes = hashes,
Size = files.Sum(f => f.Length),
PieceLength = pieceLength
};
}
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);
}
}
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()
{
int pieceLength = 16 * Constants.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.BitField.SetAll(true);
peers = new List <PeerId> ();
for (int i = 0; i < 5; i++)
{
peers.Add(PeerId.CreateNull(pieces));
}
}
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()
{
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()
{
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>();
}
public async Task WriteDataFromTwoTorrentsConcurrently()
{
// Data from the primary torrent
var allData = fileData.Data.SelectMany(t => t).ToArray();
// Data from a different torrent which hits the same pieces.
var emptyBytes = new byte[Constants.BlockSize];
var otherData = new TestTorrentData {
Data = fileData.Data,
Files = fileData.Files,
Hashes = fileData.Hashes,
PieceLength = fileData.PieceLength,
Size = fileData.Size
};
int offset = 0;
foreach (var block in allData.Partition(Constants.BlockSize))
{
var buffer = new byte[Constants.BlockSize];
Buffer.BlockCopy(block, 0, buffer, 0, block.Length);
var request = new BlockInfo(offset / fileData.PieceLength, offset % fileData.PieceLength, block.Length);
await Task.WhenAll(
diskManager.WriteAsync (fileData, request, buffer).AsTask(),
// Attempt to 'overwrite' the data from the primary torrent by writing the same block
// or the subsequent block
diskManager.WriteAsync (otherData, request, buffer).AsTask()
);
offset += block.Length;
}
using var _ = MemoryPool.Default.Rent(20, out Memory <byte> memory);
for (int i = 0; i < fileData.Hashes.Length; i++)
{
// Check twice because the first check should give us the result from the incremental hash.
memory.Span.Fill(0);
Assert.IsTrue(await diskManager.GetHashAsync(fileData, i, memory));
Assert.IsTrue(fileData.Hashes[i].AsSpan().SequenceEqual(memory.Span), "#2." + i);
memory.Span.Fill(0);
Assert.IsTrue(await diskManager.GetHashAsync(fileData, i, memory));
Assert.IsTrue(fileData.Hashes[i].AsSpan().SequenceEqual(memory.Span), "#3." + i);
}
Assert.AreEqual(fileData.Size + otherData.Size, diskManager.TotalBytesWritten, "#4");
}
public void Setup()
{
var files = new [] {
new TorrentFileInfo(new TorrentFile("First", Piece.BlockSize / 2)),
new TorrentFileInfo(new TorrentFile("Second", Piece.BlockSize)),
new TorrentFileInfo(new TorrentFile("Third", Piece.BlockSize + Piece.BlockSize / 2)),
new TorrentFileInfo(new TorrentFile("Fourth", Piece.BlockSize * 2 + Piece.BlockSize / 2)),
};
buffer = new byte[Piece.BlockSize];
data = new TestTorrentData {
Files = files,
Size = files.Sum(f => f.Length),
PieceLength = Piece.BlockSize * 2
};
writer = new ExceptionWriter();
diskManager = new DiskManager(new EngineSettings(), writer);
}
public void Setup()
{
var pieceLength = Constants.BlockSize * 2;
var files = TorrentFileInfo.Create(pieceLength,
Constants.BlockSize / 2,
Constants.BlockSize,
Constants.BlockSize + Constants.BlockSize / 2,
Constants.BlockSize * 2 + Constants.BlockSize / 2
);
buffer = new byte[Constants.BlockSize];
data = new TestTorrentData {
Files = files,
Size = files.Sum(f => f.Length),
PieceLength = pieceLength
};
writer = new ExceptionWriter();
diskManager = new DiskManager(new EngineSettings(), Factories.Default, writer);
}
public void Setup()
{
var pieceLength = Piece.BlockSize * 2;
var files = TorrentFileInfo.Create(pieceLength,
Piece.BlockSize / 2,
Piece.BlockSize,
Piece.BlockSize + Piece.BlockSize / 2,
Piece.BlockSize * 2 + Piece.BlockSize / 2
);
buffer = new byte[Piece.BlockSize];
data = new TestTorrentData {
Files = files,
Size = files.Sum(f => f.Length),
PieceLength = pieceLength
};
writer = new ExceptionWriter();
diskManager = new DiskManager(new EngineSettings(), writer);
}
public void Setup()
{
var random = new Random();
var files = new [] {
new TorrentFile("First", Piece.BlockSize / 2),
new TorrentFile("Second", Piece.BlockSize),
new TorrentFile("Third", Piece.BlockSize + Piece.BlockSize / 2),
new TorrentFile("Fourth", Piece.BlockSize * 6 + Piece.BlockSize / 2),
};
var fileBytes = files
.Select(f => { var b = new byte [f.Length]; random.NextBytes(b); return(b); })
.ToArray();
int pieceLength = Piece.BlockSize * 3;
// Turn all the files into one byte array. Group the byte array into bittorrent pieces. Hash that piece.
var hashes = fileBytes
.SelectMany(t => t)
.Partition(pieceLength)
.Select(t => SHA1.Create().ComputeHash(t))
.ToArray();
fileData = new TestTorrentData {
Data = fileBytes,
Files = files,
Hashes = hashes,
Size = files.Sum(f => f.Length),
PieceLength = pieceLength
};
writer = new PieceWriter();
for (int i = 0; i < files.Length; i++)
{
writer.Data.Add(files[i], fileBytes[i]);
}
settings = new EngineSettings();
diskManager = new DiskManager(settings, writer);
}
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> ();
picker = new StandardPicker();
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);
}
}
public void Setup()
{
int pieceCount = 40;
int pieceLength = 256 * 1024;
bitfield = new BitField(pieceCount);
torrentData = new TestTorrentData {
Files = TorrentFileInfo.Create(pieceLength, ("File", pieceLength * pieceCount, "Full/Path/File")),
PieceLength = pieceLength,
Size = pieceLength * pieceCount
};
peers = new List <PeerId> ();
picker = new StandardPicker();
picker.Initialise(torrentData);
peer = PeerId.CreateNull(pieceCount);
for (int i = 0; i < 20; i++)
{
PeerId p = PeerId.CreateNull(pieceCount);
p.SupportsFastPeer = true;
peers.Add(p);
}
}
