Skip to content

Commit 78096d3

Browse files
ssgssg
committed
adapt test syntax to newer NUnit versions
1 parent d8d6b74 commit 78096d3

13 files changed

+121
-57
lines changed

‎test/Base16/Base16Test.cs

+36-18
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ public void Decode_Stream(Base16 encoder, byte[] expectedOutput, string input)
5252
using var memoryStream = new MemoryStream();
5353
using var reader = new StringReader(input);
5454
encoder.Decode(reader, memoryStream);
55-
CollectionAssert.AreEqual(expectedOutput, memoryStream.ToArray());
55+
Assert.That(memoryStream.ToArray(), Is.EqualTo(expectedOutput));
5656
}
5757

5858
[Test]
@@ -72,7 +72,7 @@ public async Task DecodeAsync_Stream(Base16 encoder, byte[] expectedOutput, stri
7272
using var memoryStream = new MemoryStream();
7373
using var reader = new StringReader(input);
7474
await encoder.DecodeAsync(reader, memoryStream);
75-
CollectionAssert.AreEqual(expectedOutput, memoryStream.ToArray());
75+
Assert.That(memoryStream.ToArray(), Is.EqualTo(expectedOutput));
7676
}
7777

7878
[Test]
@@ -98,9 +98,12 @@ public void Encode(Base16 encoder, byte[] input, string expectedOutput)
9898
public void TryEncode_RegularInput_Succeeds(Base16 encoder, byte[] input, string expectedOutput)
9999
{
100100
var output = new char[input.Length * 2];
101-
Assert.That(encoder.TryEncode(input, output, out int numCharsWritten), Is.True);
102-
Assert.That(numCharsWritten, Is.EqualTo(output.Length));
103-
Assert.That(new string(output), Is.EqualTo(expectedOutput));
101+
Assert.Multiple(() =>
102+
{
103+
Assert.That(encoder.TryEncode(input, output, out int numCharsWritten), Is.True);
104+
Assert.That(numCharsWritten, Is.EqualTo(output.Length));
105+
Assert.That(new string(output), Is.EqualTo(expectedOutput));
106+
});
104107
}
105108

106109
[Test]
@@ -109,34 +112,43 @@ public void TryEncode_SmallerOutput_Fails(Base16 encoder)
109112
{
110113
var input = new byte[4];
111114
var output = Array.Empty<char>();
112-
Assert.That(encoder.TryEncode(input, output, out int numCharsWritten), Is.False);
113-
Assert.That(numCharsWritten, Is.EqualTo(0));
115+
Assert.Multiple(() =>
116+
{
117+
Assert.That(encoder.TryEncode(input, output, out int numCharsWritten), Is.False);
118+
Assert.That(numCharsWritten, Is.EqualTo(0));
119+
});
114120
}
115121

116122
[Test]
117123
[TestCaseSource(nameof(testData))]
118124
public void Decode(Base16 encoder, byte[] expectedOutput, string input)
119125
{
120126
var result = encoder.Decode(input);
121-
CollectionAssert.AreEqual(expectedOutput, result.ToArray());
127+
Assert.That(result.ToArray(), Is.EqualTo(expectedOutput));
122128
}
123129

124130
[Test]
125131
[TestCaseSource(nameof(testData))]
126132
public void TryDecode_RegularInput_Succeeds(Base16 encoder, byte[] expectedOutput, string input)
127133
{
128134
var output = new byte[expectedOutput.Length];
129-
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.True);
130-
Assert.That(numBytesWritten, Is.EqualTo(output.Length));
131-
CollectionAssert.AreEqual(expectedOutput, output);
135+
Assert.Multiple(() =>
136+
{
137+
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.True);
138+
Assert.That(numBytesWritten, Is.EqualTo(output.Length));
139+
Assert.That(output, Is.EqualTo(expectedOutput));
140+
});
132141
}
133142

134143
[Test]
135144
public void TryDecode_InvalidChar_ReturnsFalse()
136145
{
137146
var output = new byte[3];
138-
Assert.That(Base16.UpperCase.TryDecode("1234ZB", output, out int numWritten), Is.False);
139-
Assert.That(numWritten, Is.EqualTo(2));
147+
Assert.Multiple(() =>
148+
{
149+
Assert.That(Base16.UpperCase.TryDecode("1234ZB", output, out int numWritten), Is.False);
150+
Assert.That(numWritten, Is.EqualTo(2));
151+
});
140152
}
141153

142154
[Test]
@@ -145,8 +157,11 @@ public void TryDecode_SmallOutputBuffer_Fails(Base16 encoder)
145157
{
146158
var input = "1234";
147159
var output = new byte[1];
148-
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.False);
149-
Assert.That(numBytesWritten, Is.EqualTo(0));
160+
Assert.Multiple(() =>
161+
{
162+
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.False);
163+
Assert.That(numBytesWritten, Is.EqualTo(0));
164+
});
150165
}
151166

152167
[Test]
@@ -155,16 +170,19 @@ public void TryDecode_UnevenInputBuffer_Fails(Base16 encoder)
155170
{
156171
var input = "123";
157172
var output = new byte[1];
158-
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.False);
159-
Assert.That(numBytesWritten, Is.EqualTo(0));
173+
Assert.Multiple(() =>
174+
{
175+
Assert.That(encoder.TryDecode(input, output, out int numBytesWritten), Is.False);
176+
Assert.That(numBytesWritten, Is.EqualTo(0));
177+
});
160178
}
161179

162180
[Test]
163181
[TestCaseSource(nameof(testData))]
164182
public void Decode_OtherCase_StillPasses(Base16 encoder, byte[] expectedOutput, string input)
165183
{
166184
var result = encoder.Decode(input.ToUpperInvariant());
167-
CollectionAssert.AreEqual(expectedOutput, result.ToArray());
185+
Assert.That(result.ToArray(), Is.EqualTo(expectedOutput));
168186
}
169187

170188
[Test]

‎test/Base16/LegacyTest.cs

+5-2
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,10 @@ class LegacyTest
1212
public void Decode_DecodesBothLowerAndUpperCase()
1313
{
1414
var expectedResult = new byte[] { 0xAB, 0xCD, 0xEF, 0xF0 };
15-
Assert.That(Base16.Decode("ABCDEFF0").ToArray(), Is.EqualTo(expectedResult));
16-
Assert.That(Base16.Decode("abcdeff0").ToArray(), Is.EqualTo(expectedResult));
15+
Assert.Multiple(() =>
16+
{
17+
Assert.That(Base16.Decode("ABCDEFF0").ToArray(), Is.EqualTo(expectedResult));
18+
Assert.That(Base16.Decode("abcdeff0").ToArray(), Is.EqualTo(expectedResult));
19+
});
1720
}
1821
}

‎test/Base32/Base32AlphabetTest.cs

+10-4
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,20 @@ public void ctorWithPaddingChar_Works()
1111
{
1212
// alphabet characters are unimportant here
1313
var alpha = new Base32Alphabet("0123456789abcdef0123456789abcdef", '!', PaddingPosition.Start);
14-
Assert.That(alpha.PaddingChar, Is.EqualTo('!'));
15-
Assert.That(alpha.PaddingPosition, Is.EqualTo(PaddingPosition.Start));
14+
Assert.Multiple(() =>
15+
{
16+
Assert.That(alpha.PaddingChar, Is.EqualTo('!'));
17+
Assert.That(alpha.PaddingPosition, Is.EqualTo(PaddingPosition.Start));
18+
});
1619
}
1720

1821
[Test]
1922
public void GetSafeByteCountForDecoding_Works()
2023
{
21-
Assert.That(Base32.Crockford.GetSafeByteCountForDecoding("12345"), Is.EqualTo(3));
22-
Assert.That(Base32.Crockford.GetSafeByteCountForDecoding(""), Is.EqualTo(0));
24+
Assert.Multiple(() =>
25+
{
26+
Assert.That(Base32.Crockford.GetSafeByteCountForDecoding("12345"), Is.EqualTo(3));
27+
Assert.That(Base32.Crockford.GetSafeByteCountForDecoding(""), Is.EqualTo(0));
28+
});
2329
}
2430
}

‎test/Base32/CrockfordTest.cs

+11-5
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ public void Decode_SampleInterface_Compiles()
6161
// do not edit/refactor the code below
6262
string myText = "CSQPYRK1E8"; // any buffer will do
6363
Span<byte> result = Base32.Crockford.Decode(myText);
64-
Assert.That(result.Length > 0, Is.True);
64+
Assert.That(result.Length, Is.GreaterThan(0));
6565
}
6666

6767
[Test]
@@ -168,8 +168,11 @@ public void TryEncode_Simple_ReturnsExpectedValues(string input, string expected
168168
byte[] bytes = Encoding.ASCII.GetBytes(input);
169169
var output = new char[Base32.Crockford.GetSafeCharCountForEncoding(bytes)];
170170
bool success = Base32.Crockford.TryEncode(bytes, output, padded, out int numCharsWritten);
171-
Assert.That(success, Is.True);
172-
Assert.That(output[..numCharsWritten], Is.EqualTo(expectedOutput));
171+
Assert.Multiple(() =>
172+
{
173+
Assert.That(success, Is.True);
174+
Assert.That(output[..numCharsWritten], Is.EqualTo(expectedOutput));
175+
});
173176
}
174177

175178
[Test]
@@ -204,8 +207,11 @@ public void TryDecode_ReturnsExpectedValues(string expectedOutput, string input,
204207
public void TryDecode_ZeroBuffer_ReturnsFalse()
205208
{
206209
var success = Base32.Crockford.TryDecode("test", [], out int numBytesWritten);
207-
Assert.That(success, Is.False);
208-
Assert.That(numBytesWritten, Is.EqualTo(0));
210+
Assert.Multiple(() =>
211+
{
212+
Assert.That(success, Is.False);
213+
Assert.That(numBytesWritten, Is.EqualTo(0));
214+
});
209215
}
210216

211217
[Test]

‎test/Base58/Base58CheckTest.cs

+5-2
Original file line numberDiff line numberDiff line change
@@ -55,8 +55,11 @@ public void TryDecodeCheck_ValidInput_ReturnsExpectedResult(int expectedVersion,
5555
{
5656
Span<byte> outputBuffer = new byte[256];
5757
bool result = Base58.Bitcoin.TryDecodeCheck(input, outputBuffer, out byte actualVersion, out int numBytesWritten);
58-
Assert.IsTrue(result);
59-
Assert.That(actualVersion, Is.EqualTo(expectedVersion));
58+
Assert.Multiple(() =>
59+
{
60+
Assert.That(result, Is.True);
61+
Assert.That(actualVersion, Is.EqualTo(expectedVersion));
62+
});
6063
string output = Encoding.ASCII.GetString(outputBuffer[..numBytesWritten]);
6164
Assert.That(output, Is.EqualTo(expectedOutput));
6265
}

‎test/Base58/BitcoinTest.cs

+11-5
Original file line numberDiff line numberDiff line change
@@ -61,8 +61,11 @@ public void TryEncode_Bitcoin_ReturnsExpectedResults(string input, string expect
6161
{
6262
var inputBuffer = Base16.UpperCase.Decode(input);
6363
var outputBuffer = new char[Base58.Bitcoin.GetSafeCharCountForEncoding(inputBuffer)];
64-
Assert.That(Base58.Bitcoin.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
65-
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
64+
Assert.Multiple(() =>
65+
{
66+
Assert.That(Base58.Bitcoin.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
67+
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
68+
});
6669
}
6770

6871
[Test]
@@ -75,15 +78,18 @@ public void Encode_EmptyBuffer_ReturnsEmptyString()
7578
public void Decode_EmptyString_ReturnsEmptyBuffer()
7679
{
7780
var result = Base58.Bitcoin.Decode(String.Empty);
78-
Assert.That(result.Length, Is.EqualTo(0));
81+
Assert.That(result, Is.Empty);
7982
}
8083

8184
[Test]
8285
public void TryDecode_EmptyString_ReturnsEmptyBuffer()
8386
{
8487
var result = Base58.Bitcoin.TryDecode(String.Empty, new byte[1], out int numBytesWritten);
85-
Assert.That(result, Is.True);
86-
Assert.That(numBytesWritten, Is.EqualTo(0));
88+
Assert.Multiple(() =>
89+
{
90+
Assert.That(result, Is.True);
91+
Assert.That(numBytesWritten, Is.EqualTo(0));
92+
});
8793
}
8894

8995
[Test]

‎test/Base58/Cb58Test.cs

+7-4
Original file line numberDiff line numberDiff line change
@@ -60,10 +60,13 @@ public void EncodeCheck_ValidInput_ReturnsExpectedResult(byte[] bytes, string ex
6060
[TestCaseSource(nameof(testData))]
6161
public void TryDecodeCheck_ValidInput_ReturnsExpectedResult(byte[] expectedOutput, string input)
6262
{
63-
Span<byte> outputBuffer = new byte[256];
64-
bool result = Base58.Bitcoin.TryDecodeCb58(input, outputBuffer, out int numBytesWritten);
65-
Assert.IsTrue(result);
66-
Assert.That(outputBuffer[..numBytesWritten].ToArray(), Is.EqualTo(expectedOutput));
63+
byte[] outputBuffer = new byte[256];
64+
bool result = Base58.Bitcoin.TryDecodeCb58(input, outputBuffer.AsSpan(), out int numBytesWritten);
65+
Assert.Multiple(() =>
66+
{
67+
Assert.That(result, Is.True);
68+
Assert.That(outputBuffer[..numBytesWritten], Is.EqualTo(expectedOutput));
69+
});
6770
}
6871

6972
}

‎test/Base58/FlickrTest.cs

+6-3
Original file line numberDiff line numberDiff line change
@@ -58,8 +58,11 @@ public void TryEncode_Flickr_ReturnsExpectedResults(string input, string expecte
5858
{
5959
var inputBuffer = Base16.UpperCase.Decode(input);
6060
var outputBuffer = new char[Base58.Flickr.GetSafeCharCountForEncoding(inputBuffer)];
61-
Assert.That(Base58.Flickr.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
62-
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
61+
Assert.Multiple(() =>
62+
{
63+
Assert.That(Base58.Flickr.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
64+
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
65+
});
6366
}
6467

6568
[Test]
@@ -72,7 +75,7 @@ public void Encode_EmptyBuffer_ReturnsEmptyString()
7275
public void Decode_EmptyString_ReturnsEmptyBuffer()
7376
{
7477
var result = Base58.Flickr.Decode(String.Empty);
75-
Assert.That(result.Length, Is.EqualTo(0));
78+
Assert.That(result, Is.Empty);
7679
}
7780

7881
[Test]

‎test/Base58/RippleTest.cs

+6-3
Original file line numberDiff line numberDiff line change
@@ -58,8 +58,11 @@ public void TryEncode_Ripple_ReturnsExpectedResults(string input, string expecte
5858
{
5959
var inputBuffer = Base16.UpperCase.Decode(input);
6060
var outputBuffer = new char[Base58.Ripple.GetSafeCharCountForEncoding(inputBuffer)];
61-
Assert.That(Base58.Ripple.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
62-
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
61+
Assert.Multiple(() =>
62+
{
63+
Assert.That(Base58.Ripple.TryEncode(inputBuffer, outputBuffer, out int numWritten), Is.True);
64+
Assert.That(outputBuffer[..numWritten], Is.EqualTo(expectedOutput));
65+
});
6366
}
6467

6568
[Test]
@@ -72,7 +75,7 @@ public void Encode_EmptyBuffer_ReturnsEmptyString()
7275
public void Decode_EmptyString_ReturnsEmptyBuffer()
7376
{
7477
var result = Base58.Ripple.Decode(String.Empty);
75-
Assert.That(result.Length, Is.EqualTo(0));
78+
Assert.That(result, Is.Empty);
7679
}
7780

7881
[Test]

‎test/Base85/Ascii85Test.cs

+14-8
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ public void Decode_Whitespace_IsIgnored(byte[] expectedOutput, string input)
4444
}
4545
actualInput += " ";
4646
var result = Base85.Ascii85.Decode(actualInput);
47-
CollectionAssert.AreEqual(expectedOutput, result);
47+
Assert.That(result, Is.EqualTo(expectedOutput));
4848
}
4949

5050
[Test]
@@ -80,8 +80,11 @@ public void Encode_TestVectors_ShouldEncodeCorrectly(byte[] input, string expect
8080
public void TryEncode_TestVectors_ShouldEncodeCorrectly(byte[] input, string expectedOutput)
8181
{
8282
var output = new char[Base85.Ascii85.GetSafeCharCountForEncoding(input)];
83-
Assert.That(Base85.Ascii85.TryEncode(input, output, out int numCharsWritten), Is.True);
84-
Assert.That(new string(output[..numCharsWritten]), Is.EqualTo(expectedOutput));
83+
Assert.Multiple(() =>
84+
{
85+
Assert.That(Base85.Ascii85.TryEncode(input, output, out int numCharsWritten), Is.True);
86+
Assert.That(new string(output[..numCharsWritten]), Is.EqualTo(expectedOutput));
87+
});
8588
}
8689

8790
[Test]
@@ -109,7 +112,7 @@ public void Decode_TestVectorsWithStream_ShouldDecodeCorrectly(byte[] expectedOu
109112
using var inputStream = new StringReader(input);
110113
using var writer = new MemoryStream();
111114
Base85.Ascii85.Decode(inputStream, writer);
112-
CollectionAssert.AreEqual(expectedOutput, writer.ToArray());
115+
Assert.That(writer.ToArray(), Is.EqualTo(expectedOutput));
113116
}
114117

115118
[Test]
@@ -119,23 +122,26 @@ public async Task DecodeAsync_TestVectorsWithStream_ShouldDecodeCorrectly(byte[]
119122
using var inputStream = new StringReader(input);
120123
using var writer = new MemoryStream();
121124
await Base85.Ascii85.DecodeAsync(inputStream, writer);
122-
CollectionAssert.AreEqual(expectedOutput, writer.ToArray());
125+
Assert.That(writer.ToArray(), Is.EqualTo(expectedOutput));
123126
}
124127

125128
[Test]
126129
[TestCaseSource(nameof(testVectors))]
127130
public void Decode_TestVectors_ShouldDecodeCorrectly(byte[] expectedOutput, string input)
128131
{
129132
var result = Base85.Ascii85.Decode(input);
130-
CollectionAssert.AreEqual(expectedOutput, result);
133+
Assert.That(result, Is.EqualTo(expectedOutput));
131134
}
132135

133136
[Test]
134137
[TestCaseSource(nameof(testVectors))]
135138
public void TryDecode_TestVectors_ShouldDecodeCorrectly(byte[] expectedOutput, string input)
136139
{
137140
var buffer = new byte[Base85.Ascii85.GetSafeByteCountForDecoding(input)];
138-
Assert.That(Base85.Ascii85.TryDecode(input, buffer, out int numBytesWritten), Is.True);
139-
CollectionAssert.AreEqual(expectedOutput, buffer[..numBytesWritten]);
141+
Assert.Multiple(() =>
142+
{
143+
Assert.That(Base85.Ascii85.TryDecode(input, buffer, out int numBytesWritten), Is.True);
144+
Assert.That(buffer[..numBytesWritten], Is.EqualTo(expectedOutput));
145+
});
140146
}
141147
}

‎test/Base85/Base85AlphabetTest.cs

+5-2
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,10 @@ public void GetSafeCharCountForEncoding_Length_Works(int inputLen, int expectedS
3030
[Test]
3131
public void HasShortcut()
3232
{
33-
Assert.That(Base85.Ascii85.Alphabet.HasShortcut, Is.True);
34-
Assert.That(Base85.Z85.Alphabet.HasShortcut, Is.False);
33+
Assert.Multiple(() =>
34+
{
35+
Assert.That(Base85.Ascii85.Alphabet.HasShortcut, Is.True);
36+
Assert.That(Base85.Z85.Alphabet.HasShortcut, Is.False);
37+
});
3538
}
3639
}

‎test/Base85/Z85Test.cs

+1-1
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,6 @@ public void Encode_NullBuffer_ReturnsEmptyString()
3838
public void Decode_TestVectors_ShouldDecodeCorrectly(byte[] expectedOutput, string input)
3939
{
4040
var result = Base85.Z85.Decode(input);
41-
CollectionAssert.AreEqual(expectedOutput, result);
41+
Assert.That(result, Is.EqualTo(expectedOutput));
4242
}
4343
}

0 commit comments

Comments
 (0)