public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow<InvalidBencodeException<BDictionary>>();
}
public void CanParseEmptyDictionary(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(0);
}
public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow <InvalidBencodeException <BDictionary> >();
}
public void CanParseEmptyDictionary(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(0);
}
public void InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync(bencode);
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Unexpected character*");
}
public void BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync(bencode);
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*reached end of stream*");
}
public async Task CanParseEmptyDictionaryAsync(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = await parser.ParseStringAsync(bencode);
bdictionary.Count.Should().Be(0);
}
public void BelowMinimumLength2_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Invalid length*");
}
public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Unexpected character*");
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
SetupBencodeParser(bparser, bencode, new BString("key"), new BString("value"), hasEndChar: false);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow <InvalidBencodeException <BDictionary> >();
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
SetupBencodeParser(bparser, bencode, new BString("key"), new BString("value"), hasEndChar:false);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow<InvalidBencodeException<BDictionary>>();
}
public void BelowMinimumLength2_WhenStreamLengthNotSupported_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var stream = new LengthNotSupportedStream(bencode);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.Parse(stream);
action.Should().Throw <InvalidBencodeException <BDictionary> >();
}
public void InvalidKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser)
{
bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Throws <BencodeException>();
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary key*");
}
public void Deserialize(byte[] data)
{
var dictParser = new BDictionaryParser(new BencodeParser());
var dict = dictParser.Parse(data);
if (dict.TryGetValue("added", out IBObject added))
{
Added = ParseEndPoints((BString)added).ToList();
}
}
public void InvalidKey_ThrowsInvalidBencodeException(IBencodeParser bparser)
{
bparser.Parse <BString>(Arg.Any <BencodeReader>()).Throws <BencodeException>();
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary key*");
}
public void DuplicateKey_ThrowsInvalidBencodeException(IBencodeParser bparser, BString someKey, BString someValue)
{
bparser.Parse <BString>(Arg.Any <BencodeReader>()).Returns(someKey, someKey);
bparser.Parse(Arg.Any <BencodeReader>()).Returns(someValue);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*");
}
public void DuplicateKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey, BString someValue)
{
bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Returns(someKey, someKey);
bparser.ParseAsync(Arg.Any <PipeBencodeReader>()).Returns(someValue);
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*");
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
var key = new BString("key");
var value = new BString("value");
SetupBencodeParser(bparser, bencode, key, value, hasEndChar:true);
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
var key = new BString("key");
var value = new BString("value");
SetupBencodeParser(bparser, bencode, key, value, hasEndChar: true);
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
public void Deserialize(IReadOnlyList <byte> data)
{
var dictParser = new BDictionaryParser(new BencodeParser());
var dict = dictParser.Parse(data.ToArray());
if (dict.TryGetValue("m", out IBObject msgTypes))
{
MessageIds = ((BDictionary)msgTypes).ToDictionary(x => x.Key.ToString(), x => (byte)((BNumber)x.Value).Value);
}
if (dict.TryGetValue("v", out IBObject client))
{
Client = ((BString)client).ToString();
}
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser, BString someKey, IBObject someValue)
{
// Arrange
bparser.Parse <BString>(Arg.Any <BencodeReader>())
.Returns(someKey);
bparser.Parse(Arg.Any <BencodeReader>())
.Returns(someValue)
.AndSkipsAhead(bencode.Length - 1);
// Act
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
// Assert
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Missing end character of object*");
}
/// <summary>
/// Loads the specified Torrent file.
/// </summary>
/// <param name="input">Input stream to read.</param>
/// <returns>Metainfo data.</returns>
public static Metainfo ReadFromStream(Stream input)
{
var dictParser = new BDictionaryParser(new BencodeParser());
var dict = dictParser.Parse(input);
var parser = new BencodeParser();
var torrent = parser.Parse <Torrent>(dict.EncodeAsBytes());
var files = new List <ContainedFile>();
if (torrent.File != null)
{
// Single file
files.Add(new ContainedFile(torrent.File.FileName, torrent.File.FileSize));
}
else
{
// Multiple files
files.AddRange(torrent.Files.Select(x => new ContainedFile(x.FullPath, x.FileSize)));
}
// Construct pieces
var pieces = new List <Piece>();
byte[] pieceHashes = torrent.Pieces;
int pieceIndex = 0;
for (long offset = 0; offset + torrent.PieceSize <= torrent.TotalSize; offset += torrent.PieceSize)
{
int length = (int)Math.Min(torrent.PieceSize, torrent.TotalSize - offset);
byte[] hash = new byte[Sha1Hash.Length];
Array.Copy(pieceHashes, pieceIndex * Sha1Hash.Length, hash, 0, Sha1Hash.Length);
Piece piece = new Piece(pieceIndex, length, new Sha1Hash(hash));
pieces.Add(piece);
pieceIndex++;
}
return(new Metainfo(torrent.DisplayName,
new Sha1Hash(torrent.GetInfoHashBytes()),
files,
pieces,
torrent.Trackers.Select(x => x.Select(y => new Uri(y))),
new byte[0]));
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
// Arange
var key = new BString("key");
var value = new BString("value");
bparser.Parse <BString>(Arg.Any <BencodeReader>())
.Returns(key);
bparser.Parse(Arg.Any <BencodeReader>())
.Returns(value)
.AndSkipsAhead(bencode.Length - 2);
// Act
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
// Assert
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
public void Deserialize(byte[] data)
{
using (var ms = new MemoryStream(data))
{
var dictParser = new BDictionaryParser(new BencodeParser());
var dict = dictParser.Parse(ms);
var requestType = (Type)((BNumber)dict["msg_type"]).Value;
if (!Enum.IsDefined(typeof(Type), requestType))
{
return; // Unsupported message type
}
RequestType = requestType;
PieceIndex = (int)((BNumber)dict["piece"]).Value;
if (RequestType == Type.Data)
{
TotalSize = (int)((BNumber)dict["total_size"]).Value;
PieceData = new byte[ms.Length - ms.Position];
ms.Read(PieceData, 0, (int)(ms.Length - ms.Position));
}
}
}
