Skip to content

Commit 161e817

Browse files
KrusenKrusen
committed
Merge branch 'v5'
2 parents 33a31cb + 90773e2 commit 161e817

17 files changed

+193
-207
lines changed

‎BencodeNET.Tests/BencodeNET.Tests.csproj‎

Lines changed: 19 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
<Project Sdk="Microsoft.NET.Sdk">
22

33
<PropertyGroup>
4-
<TargetFrameworks>net472;netcoreapp2.1;netcoreapp3.1;net5.0</TargetFrameworks>
5-
<LangVersion>9</LangVersion>
4+
<TargetFrameworks>net6.0</TargetFrameworks>
5+
<LangVersion>11</LangVersion>
66
</PropertyGroup>
77

88
<ItemGroup>
@@ -15,16 +15,23 @@
1515
</ItemGroup>
1616

1717
<ItemGroup>
18-
<PackageReference Include="AutoFixture" Version="4.15.0" />
19-
<PackageReference Include="AutoFixture.AutoNSubstitute" Version="4.15.0" />
20-
<PackageReference Include="AutoFixture.Xunit2" Version="4.15.0" />
21-
<PackageReference Include="FluentAssertions" Version="5.10.3" />
22-
<PackageReference Include="FluentAssertions.Analyzers" Version="0.11.4" />
23-
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
24-
<PackageReference Include="NSubstitute" Version="4.2.2" />
25-
<PackageReference Include="NSubstitute.Analyzers.CSharp" Version="1.0.14" />
26-
<PackageReference Include="xunit" Version="2.4.1" />
27-
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
18+
<PackageReference Include="AutoFixture" Version="4.18.0" />
19+
<PackageReference Include="AutoFixture.AutoNSubstitute" Version="4.18.0" />
20+
<PackageReference Include="AutoFixture.Xunit2" Version="4.18.0" />
21+
<PackageReference Include="FluentAssertions" Version="6.10.0" />
22+
<PackageReference Include="FluentAssertions.Analyzers" Version="0.17.2">
23+
<PrivateAssets>all</PrivateAssets>
24+
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
25+
</PackageReference>
26+
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
27+
<PackageReference Include="NSubstitute" Version="5.0.0" />
28+
<PackageReference Include="NSubstitute.Analyzers.CSharp" Version="1.0.16">
29+
<PrivateAssets>all</PrivateAssets>
30+
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
31+
</PackageReference>
32+
<PackageReference Include="xunit" Version="2.4.2" />
33+
<PackageReference Include="xunit.analyzers" Version="1.1.0" />
34+
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
2835
<PrivateAssets>all</PrivateAssets>
2936
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
3037
</PackageReference>

‎BencodeNET.Tests/Objects/BListTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,7 @@ public void AsType_ConvertsToListOfType()
153153
var blist = new BList {1, 2, 3};
154154
var bnumbers = blist.AsType<BNumber>();
155155

156-
bnumbers.Should()
156+
bnumbers.Should<object>()
157157
.HaveCount(3)
158158
.And.ContainItemsAssignableTo<BNumber>()
159159
.And.ContainInOrder(blist);

‎BencodeNET.Tests/Parsing/BDictionaryParserTests.Async.cs‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -51,32 +51,32 @@ public async Task CanParseEmptyDictionaryAsync(string bencode, IBencodeParser bp
5151
[Theory]
5252
[AutoMockedData("")]
5353
[AutoMockedData("d")]
54-
public void BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
54+
public async Task BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
5555
{
5656
var parser = new BDictionaryParser(bparser);
57-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
57+
var action = async () => await parser.ParseStringAsync(bencode);
5858

59-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*reached end of stream*");
59+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*reached end of stream*");
6060
}
6161

6262
[Theory]
6363
[AutoMockedData("ade")]
6464
[AutoMockedData(":de")]
6565
[AutoMockedData("-de")]
6666
[AutoMockedData("1de")]
67-
public void InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
67+
public async Task InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
6868
{
6969
var parser = new BDictionaryParser(bparser);
70-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
70+
var action = async () => await parser.ParseStringAsync(bencode);
7171

72-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*Unexpected character*");
72+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*Unexpected character*");
7373
}
7474

7575
[Theory]
7676
[AutoMockedData("da")]
7777
[AutoMockedData("d4:spam3:egg")]
7878
[AutoMockedData("d ")]
79-
public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser, BString someKey, IBObject someValue)
79+
public async Task MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser, BString someKey, IBObject someValue)
8080
{
8181
// Arrange
8282
bparser.ParseAsync<BString>(Arg.Any<PipeBencodeReader>())
@@ -88,51 +88,51 @@ public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IB
8888

8989
// Act
9090
var parser = new BDictionaryParser(bparser);
91-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
91+
var action = async () => await parser.ParseStringAsync(bencode);
9292

9393
// Assert
94-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*Missing end character of object*");
94+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*Missing end character of object*");
9595
}
9696

9797
[Theory]
9898
[AutoMockedData]
99-
public void InvalidKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser)
99+
public async Task InvalidKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser)
100100
{
101101
bparser.ParseAsync<BString>(Arg.Any<PipeBencodeReader>()).Throws<BencodeException>();
102102

103103
var parser = new BDictionaryParser(bparser);
104104

105-
Func<Task> action = async () => await parser.ParseStringAsync("di42ee");
105+
var action = async () => await parser.ParseStringAsync("di42ee");
106106

107-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*Could not parse dictionary key*");
107+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*Could not parse dictionary key*");
108108
}
109109

110110
[Theory]
111111
[AutoMockedData]
112-
public void InvalidValue_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey)
112+
public async Task InvalidValue_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey)
113113
{
114114
bparser.ParseAsync<BString>(Arg.Any<PipeBencodeReader>()).Returns(someKey);
115115
bparser.ParseAsync(Arg.Any<PipeBencodeReader>()).Throws<BencodeException>();
116116

117117
var parser = new BDictionaryParser(bparser);
118118

119-
Func<Task> action = async () => await parser.ParseStringAsync("di42ee");
119+
var action = async () => await parser.ParseStringAsync("di42ee");
120120

121-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*Could not parse dictionary value*");
121+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*Could not parse dictionary value*");
122122
}
123123

124124
[Theory]
125125
[AutoMockedData]
126-
public void DuplicateKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey, BString someValue)
126+
public async Task DuplicateKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey, BString someValue)
127127
{
128128
bparser.ParseAsync<BString>(Arg.Any<PipeBencodeReader>()).Returns(someKey, someKey);
129129
bparser.ParseAsync(Arg.Any<PipeBencodeReader>()).Returns(someValue);
130130

131131
var parser = new BDictionaryParser(bparser);
132132

133-
Func<Task> action = async () => await parser.ParseStringAsync("di42ee");
133+
var action = async () => await parser.ParseStringAsync("di42ee");
134134

135-
action.Should().Throw<InvalidBencodeException<BDictionary>>().WithMessage("*The dictionary already contains the key*");
135+
await action.Should().ThrowAsync<InvalidBencodeException<BDictionary>>().WithMessage("*The dictionary already contains the key*");
136136
}
137137
}
138138
}

‎BencodeNET.Tests/Parsing/BListParserTests.Async.cs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -49,12 +49,12 @@ public async Task CanParseEmptyListAsync(string bencode, IBencodeParser bparser)
4949
[Theory]
5050
[AutoMockedData("")]
5151
[AutoMockedData("l")]
52-
public void BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
52+
public async Task BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
5353
{
5454
var parser = new BListParser(bparser);
55-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
55+
var action = async () => await parser.ParseStringAsync(bencode);
5656

57-
action.Should().Throw<InvalidBencodeException<BList>>().WithMessage("*reached end of stream*");
57+
await action.Should().ThrowAsync<InvalidBencodeException<BList>>().WithMessage("*reached end of stream*");
5858
}
5959

6060
[Theory]
@@ -64,19 +64,19 @@ public void BelowMinimumLength2_ThrowsInvalidBencodeExceptionAsync(string bencod
6464
[AutoMockedData("-e")]
6565
[AutoMockedData(".e")]
6666
[AutoMockedData("ee")]
67-
public void InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
67+
public async Task InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser)
6868
{
6969
var parser = new BListParser(bparser);
70-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
70+
var action = async () => await parser.ParseStringAsync(bencode);
7171

72-
action.Should().Throw<InvalidBencodeException<BList>>().WithMessage("*Unexpected character*");
72+
await action.Should().ThrowAsync<InvalidBencodeException<BList>>().WithMessage("*Unexpected character*");
7373
}
7474

7575
[Theory]
7676
[AutoMockedData("l4:spam")]
7777
[AutoMockedData("l ")]
7878
[AutoMockedData("l:")]
79-
public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser, IBObject something)
79+
public async Task MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser, IBObject something)
8080
{
8181
// Arrange
8282
bparser.ParseAsync(Arg.Any<PipeBencodeReader>())
@@ -85,10 +85,10 @@ public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IB
8585

8686
// Act
8787
var parser = new BListParser(bparser);
88-
Func<Task> action = async () => await parser.ParseStringAsync(bencode);
88+
var action = async () => await parser.ParseStringAsync(bencode);
8989

9090
// Assert
91-
action.Should().Throw<InvalidBencodeException<BList>>().WithMessage("*Missing end character of object*");
91+
await action.Should().ThrowAsync<InvalidBencodeException<BList>>().WithMessage("*Missing end character of object*");
9292
}
9393
}
9494
}

‎BencodeNET.Tests/Parsing/BNumberParserTests.Async.cs‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -57,30 +57,30 @@ public async Task CanParseInt64Async(string bencode, long value)
5757
[InlineData("i012e")]
5858
[InlineData("i01234567890e")]
5959
[InlineData("i00001e")]
60-
public void LeadingZeros_ThrowsInvalidBencodeExceptionAsync(string bencode)
60+
public async Task LeadingZeros_ThrowsInvalidBencodeExceptionAsync(string bencode)
6161
{
62-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
63-
action.Should().Throw<InvalidBencodeException<BNumber>>()
62+
var action = async () => await Parser.ParseStringAsync(bencode);
63+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
6464
.WithMessage("*Leading '0's are not valid.*")
6565
.Which.StreamPosition.Should().Be(0);
6666
}
6767

6868
[Fact]
69-
public void MinusZero_ThrowsInvalidBencodeExceptionAsync()
69+
public async Task MinusZero_ThrowsInvalidBencodeExceptionAsync()
7070
{
71-
Func<Task> action = async () => await Parser.ParseStringAsync("i-0e");
72-
action.Should().Throw<InvalidBencodeException<BNumber>>()
71+
var action = async () => await Parser.ParseStringAsync("i-0e");
72+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
7373
.WithMessage("*'-0' is not a valid number.*")
7474
.Which.StreamPosition.Should().Be(0);
7575
}
7676

7777
[Theory]
7878
[InlineData("i12")]
7979
[InlineData("i123")]
80-
public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode)
80+
public async Task MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode)
8181
{
82-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
83-
action.Should().Throw<InvalidBencodeException<BNumber>>()
82+
var action = async () => await Parser.ParseStringAsync(bencode);
83+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
8484
.WithMessage("*Missing end character of object.*")
8585
.Which.StreamPosition.Should().Be(0);
8686
}
@@ -92,19 +92,19 @@ public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode)
9292
[InlineData("l42e")]
9393
[InlineData("100e")]
9494
[InlineData("1234567890e")]
95-
public void InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode)
95+
public async Task InvalidFirstChar_ThrowsInvalidBencodeExceptionAsync(string bencode)
9696
{
97-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
98-
action.Should().Throw<InvalidBencodeException<BNumber>>()
97+
var action = async () => await Parser.ParseStringAsync(bencode);
98+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
9999
.WithMessage("*Unexpected character. Expected 'i'*")
100100
.Which.StreamPosition.Should().Be(0);
101101
}
102102

103103
[Fact]
104-
public void JustNegativeSign_ThrowsInvalidBencodeExceptionAsync()
104+
public async Task JustNegativeSign_ThrowsInvalidBencodeExceptionAsync()
105105
{
106-
Func<Task> action = async () => await Parser.ParseStringAsync("i-e");
107-
action.Should().Throw<InvalidBencodeException<BNumber>>()
106+
var action = async () => await Parser.ParseStringAsync("i-e");
107+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
108108
.WithMessage("*It contains no digits.*")
109109
.Which.StreamPosition.Should().Be(0);
110110
}
@@ -114,10 +114,10 @@ public void JustNegativeSign_ThrowsInvalidBencodeExceptionAsync()
114114
[InlineData("i--42e")]
115115
[InlineData("i---100e")]
116116
[InlineData("i----1234567890e")]
117-
public void MoreThanOneNegativeSign_ThrowsInvalidBencodeExceptionAsync(string bencode)
117+
public async Task MoreThanOneNegativeSign_ThrowsInvalidBencodeExceptionAsync(string bencode)
118118
{
119-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
120-
action.Should().Throw<InvalidBencodeException<BNumber>>()
119+
var action = async () => await Parser.ParseStringAsync(bencode);
120+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
121121
.WithMessage("*The value '*' is not a valid number.*")
122122
.Which.StreamPosition.Should().Be(0);
123123
}
@@ -128,10 +128,10 @@ public void MoreThanOneNegativeSign_ThrowsInvalidBencodeExceptionAsync(string be
128128
[InlineData("i.e")]
129129
[InlineData("i42.e")]
130130
[InlineData("i42ae")]
131-
public void NonDigit_ThrowsInvalidBencodeExceptionAsync(string bencode)
131+
public async Task NonDigit_ThrowsInvalidBencodeExceptionAsync(string bencode)
132132
{
133-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
134-
action.Should().Throw<InvalidBencodeException<BNumber>>()
133+
var action = async () => await Parser.ParseStringAsync(bencode);
134+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
135135
.WithMessage("*The value '*' is not a valid number.*")
136136
.Which.StreamPosition.Should().Be(0);
137137
}
@@ -141,21 +141,21 @@ public void NonDigit_ThrowsInvalidBencodeExceptionAsync(string bencode)
141141
[InlineData("", "reached end of stream")]
142142
[InlineData("i", "contains no digits")]
143143
[InlineData("ie", "contains no digits")]
144-
public void BelowMinimumLength_ThrowsInvalidBencodeExceptionAsync(string bencode, string exceptionMessage)
144+
public async Task BelowMinimumLength_ThrowsInvalidBencodeExceptionAsync(string bencode, string exceptionMessage)
145145
{
146-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
147-
action.Should().Throw<InvalidBencodeException<BNumber>>()
146+
var action = async () => await Parser.ParseStringAsync(bencode);
147+
(await action.Should().ThrowAsync<InvalidBencodeException<BNumber>>())
148148
.WithMessage($"*{exceptionMessage}*")
149149
.Which.StreamPosition.Should().Be(0);
150150
}
151151

152152
[Theory]
153153
[InlineData("i9223372036854775808e")]
154154
[InlineData("i-9223372036854775809e")]
155-
public void LargerThanInt64_ThrowsUnsupportedExceptionAsync(string bencode)
155+
public async Task LargerThanInt64_ThrowsUnsupportedExceptionAsync(string bencode)
156156
{
157-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
158-
action.Should().Throw<UnsupportedBencodeException<BNumber>>()
157+
var action = async () => await Parser.ParseStringAsync(bencode);
158+
(await action.Should().ThrowAsync<UnsupportedBencodeException<BNumber>>())
159159
.WithMessage("*The value '*' is not a valid long (Int64)*")
160160
.Which.StreamPosition.Should().Be(0);
161161
}
@@ -164,10 +164,10 @@ public void LargerThanInt64_ThrowsUnsupportedExceptionAsync(string bencode)
164164
[InlineData("i12345678901234567890e")]
165165
[InlineData("i123456789012345678901e")]
166166
[InlineData("i123456789012345678901234567890e")]
167-
public void LongerThanMaxDigits19_ThrowsUnsupportedExceptionAsync(string bencode)
167+
public async Task LongerThanMaxDigits19_ThrowsUnsupportedExceptionAsync(string bencode)
168168
{
169-
Func<Task> action = async () => await Parser.ParseStringAsync(bencode);
170-
action.Should().Throw<UnsupportedBencodeException<BNumber>>()
169+
var action = async () => await Parser.ParseStringAsync(bencode);
170+
(await action.Should().ThrowAsync<UnsupportedBencodeException<BNumber>>())
171171
.WithMessage("*The number '*' has more than 19 digits and cannot be stored as a long*")
172172
.Which.StreamPosition.Should().Be(0);
173173
}

0 commit comments

Comments
 (0)