Skip to content

Commit e44b07e

Browse files
jzebedeejzebedee
committed
Update DecompressorTests
Use repeatable random Use file-scoped namespaces
1 parent f008474 commit e44b07e

1 file changed

Lines changed: 118 additions & 117 deletions

File tree

‎test/LibDeflate.Tests/DecompressorTests.cs‎

Lines changed: 118 additions & 117 deletions
Original file line numberDiff line numberDiff line change
@@ -6,155 +6,156 @@
66
using System.Linq;
77
using Xunit;
88

9-
namespace LibDeflate.Tests
9+
namespace LibDeflate.Tests;
10+
using static Helpers;
11+
12+
public class DecompressorTests
1013
{
11-
public class DecompressorTests
12-
{
13-
public delegate ReadOnlyMemory<byte> BclDeflater(ReadOnlyMemory<byte> inflatedInput);
14+
public delegate ReadOnlyMemory<byte> BclDeflater(ReadOnlyMemory<byte> inflatedInput);
1415

15-
public static IEnumerable<object[]> Decompressors()
16-
{
17-
var input = GetRandomBuffer(length: 0x7900);
16+
public static IEnumerable<object[]> Decompressors()
17+
{
18+
var input = GetRandomBuffer(length: 0x7900);
1819

19-
yield return new object[] { new DeflateDecompressor(), input, (BclDeflater)Deflate };
20-
yield return new object[] { new ZlibDecompressor(), input, (BclDeflater)ZlibDeflate };
21-
yield return new object[] { new GzipDecompressor(), input, (BclDeflater)GzipDeflate };
20+
yield return new object[] { new DeflateDecompressor(), input, (BclDeflater)Deflate };
21+
yield return new object[] { new ZlibDecompressor(), input, (BclDeflater)ZlibDeflate };
22+
yield return new object[] { new GzipDecompressor(), input, (BclDeflater)GzipDeflate };
2223

23-
static ReadOnlyMemory<byte> Deflate(ReadOnlyMemory<byte> inflatedInput)
24-
=> BclCompressionHelper.FlateToBuffer(inflatedInput.Span, CompressionMode.Compress);
24+
static ReadOnlyMemory<byte> Deflate(ReadOnlyMemory<byte> inflatedInput)
25+
=> BclCompressionHelper.FlateToBuffer(inflatedInput.Span, CompressionMode.Compress);
2526

26-
static ReadOnlyMemory<byte> ZlibDeflate(ReadOnlyMemory<byte> inflatedInput)
27-
=> BclCompressionHelper.ZlibToBuffer(inflatedInput.Span, CompressionMode.Compress);
27+
static ReadOnlyMemory<byte> ZlibDeflate(ReadOnlyMemory<byte> inflatedInput)
28+
=> BclCompressionHelper.ZlibToBuffer(inflatedInput.Span, CompressionMode.Compress);
2829

29-
static ReadOnlyMemory<byte> GzipDeflate(ReadOnlyMemory<byte> inflatedInput)
30-
=> BclCompressionHelper.GzipToBuffer(inflatedInput.Span, CompressionMode.Compress);
31-
}
30+
static ReadOnlyMemory<byte> GzipDeflate(ReadOnlyMemory<byte> inflatedInput)
31+
=> BclCompressionHelper.GzipToBuffer(inflatedInput.Span, CompressionMode.Compress);
32+
}
3233

33-
private static readonly Random _rand = new();
34-
private static byte[] GetRandomBuffer(int length)
35-
{
36-
var input = new byte[length];
37-
_rand.NextBytes(input);
38-
return input;
39-
}
34+
private static byte[] GetRandomBuffer(int length)
35+
{
36+
var rand = GetRepeatableRandom();
37+
var input = new byte[length];
38+
rand.NextBytes(input);
39+
return input;
40+
}
4041

41-
private static byte[] GetOversizedInputBuffer(ReadOnlySpan<byte> input, out int expectedReadLength)
42-
{
43-
var oversizedMs = new MemoryStream();
44-
oversizedMs.Write(input);
42+
private static byte[] GetOversizedInputBuffer(ReadOnlySpan<byte> input, out int expectedReadLength)
43+
{
44+
var rand = GetRepeatableRandom();
45+
var oversizedMs = new MemoryStream();
46+
oversizedMs.Write(input);
4547

46-
expectedReadLength = (int)oversizedMs.Length;
47-
Span<byte> appendedGarbage = new byte[0x40];
48-
_rand.NextBytes(appendedGarbage);
49-
oversizedMs.Write(appendedGarbage);
48+
expectedReadLength = (int)oversizedMs.Length;
49+
Span<byte> appendedGarbage = new byte[0x40];
50+
rand.NextBytes(appendedGarbage);
51+
oversizedMs.Write(appendedGarbage);
5052

51-
return oversizedMs.GetBuffer()[..(int)oversizedMs.Length];
52-
}
53+
return oversizedMs.GetBuffer()[..(int)oversizedMs.Length];
54+
}
5355

54-
[Theory]
55-
[MemberData(nameof(Decompressors))]
56-
public void DecompressOwnedBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
56+
[Theory]
57+
[MemberData(nameof(Decompressors))]
58+
public void DecompressOwnedBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
59+
{
60+
using (decompressor)
5761
{
58-
using (decompressor)
62+
//compress with BCL
63+
var bclDeflated = bclDeflater(inputMemory);
64+
//sanity-check
65+
//if (decompressor is ZlibDecompressor)
66+
//{
67+
// var bclRoundtrip = BclCompressionHelper.ZlibToBuffer(bclDeflated.Span, CompressionMode.Decompress).Span;
68+
// Assert.True(bclRoundtrip.SequenceEqual(inputMemory.Span));
69+
//}
70+
71+
//decompress result with our lib
72+
var status = decompressor.Decompress(bclDeflated.Span, inputMemory.Length, out var outputOwner);
73+
using (outputOwner)
5974
{
60-
//compress with BCL
61-
var bclDeflated = bclDeflater(inputMemory);
62-
//sanity-check
63-
//if (decompressor is ZlibDecompressor)
64-
//{
65-
// var bclRoundtrip = BclCompressionHelper.ZlibToBuffer(bclDeflated.Span, CompressionMode.Decompress).Span;
66-
// Assert.True(bclRoundtrip.SequenceEqual(inputMemory.Span));
67-
//}
68-
69-
//decompress result with our lib
70-
var status = decompressor.Decompress(bclDeflated.Span, inputMemory.Length, out var outputOwner);
71-
using (outputOwner)
72-
{
73-
Assert.Equal(OperationStatus.Done, status);
74-
Assert.NotNull(outputOwner);
75-
76-
//ensure inflated results match input
77-
var output = outputOwner.Memory.Span;
78-
Assert.True(output.SequenceEqual(inputMemory.Span));
79-
}
75+
Assert.Equal(OperationStatus.Done, status);
76+
Assert.NotNull(outputOwner);
77+
78+
//ensure inflated results match input
79+
var output = outputOwner.Memory.Span;
80+
Assert.True(output.SequenceEqual(inputMemory.Span));
8081
}
8182
}
83+
}
8284

83-
[Theory]
84-
[MemberData(nameof(Decompressors))]
85-
public void DecompressProvidedBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
85+
[Theory]
86+
[MemberData(nameof(Decompressors))]
87+
public void DecompressProvidedBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
88+
{
89+
using (decompressor)
8690
{
87-
using (decompressor)
88-
{
89-
//compress with BCL
90-
var bclDeflated = bclDeflater(inputMemory);
91+
//compress with BCL
92+
var bclDeflated = bclDeflater(inputMemory);
9193

92-
Span<byte> outputSpan = new byte[inputMemory.Length + 0x1000];
94+
Span<byte> outputSpan = new byte[inputMemory.Length + 0x1000];
9395

94-
//decompress result with our lib
95-
var status = decompressor.Decompress(bclDeflated.Span, outputSpan, out int bytesWritten);
96-
Assert.Equal(OperationStatus.Done, status);
97-
Assert.True(bytesWritten > 0);
96+
//decompress result with our lib
97+
var status = decompressor.Decompress(bclDeflated.Span, outputSpan, out int bytesWritten);
98+
Assert.Equal(OperationStatus.Done, status);
99+
Assert.True(bytesWritten > 0);
98100

99-
//ensure inflated results match input
100-
Assert.True(outputSpan[..bytesWritten].SequenceEqual(inputMemory.Span));
101-
}
101+
//ensure inflated results match input
102+
Assert.True(outputSpan[..bytesWritten].SequenceEqual(inputMemory.Span));
102103
}
104+
}
103105

104-
[Theory]
105-
[MemberData(nameof(Decompressors))]
106-
public void DecompressOwnedShortBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
106+
[Theory]
107+
[MemberData(nameof(Decompressors))]
108+
public void DecompressOwnedShortBufferTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
109+
{
110+
using (decompressor)
107111
{
108-
using (decompressor)
109-
{
110-
//compress with BCL
111-
var bclDeflated = bclDeflater(inputMemory);
112+
//compress with BCL
113+
var bclDeflated = bclDeflater(inputMemory);
112114

113-
//decompress result with our lib
114-
var status = decompressor.Decompress(bclDeflated.Span, inputMemory.Length - 1, out var outputOwner);
115-
Assert.NotEqual(OperationStatus.Done, status);
116-
Assert.Null(outputOwner);
117-
}
115+
//decompress result with our lib
116+
var status = decompressor.Decompress(bclDeflated.Span, inputMemory.Length - 1, out var outputOwner);
117+
Assert.NotEqual(OperationStatus.Done, status);
118+
Assert.Null(outputOwner);
118119
}
120+
}
119121

120-
[Theory]
121-
[MemberData(nameof(Decompressors))]
122-
public void DecompressOversizedInputTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
123-
{
124-
var bclDeflated = bclDeflater(inputMemory);
125-
var deflatedInput = GetOversizedInputBuffer(bclDeflated.Span, out var expectedReadLength);
126-
var inflatedOutput = new byte[inputMemory.Length];
122+
[Theory]
123+
[MemberData(nameof(Decompressors))]
124+
public void DecompressOversizedInputTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
125+
{
126+
var bclDeflated = bclDeflater(inputMemory);
127+
var deflatedInput = GetOversizedInputBuffer(bclDeflated.Span, out var expectedReadLength);
128+
var inflatedOutput = new byte[inputMemory.Length];
127129

128-
using (decompressor)
129-
{
130-
var status = decompressor.Decompress(deflatedInput, inflatedOutput, out var bytesWritten, out int bytesRead);
131-
Assert.Equal(OperationStatus.Done, status);
130+
using (decompressor)
131+
{
132+
var status = decompressor.Decompress(deflatedInput, inflatedOutput, out var bytesWritten, out int bytesRead);
133+
Assert.Equal(OperationStatus.Done, status);
132134

133-
var outSpan = new ReadOnlySpan<byte>(inflatedOutput, 0, bytesWritten);
134-
Assert.True(inputMemory.Span.SequenceEqual(outSpan));
135-
Assert.Equal(expectedReadLength, bytesRead);
136-
}
135+
var outSpan = new ReadOnlySpan<byte>(inflatedOutput, 0, bytesWritten);
136+
Assert.True(inputMemory.Span.SequenceEqual(outSpan));
137+
Assert.Equal(expectedReadLength, bytesRead);
137138
}
139+
}
138140

139-
[Theory]
140-
[MemberData(nameof(Decompressors))]
141-
public void DecompressOversizedInputUnknownSizeTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
142-
{
143-
var bclDeflated = bclDeflater(inputMemory);
144-
var deflatedInput = GetOversizedInputBuffer(bclDeflated.Span, out var expectedReadLength);
141+
[Theory]
142+
[MemberData(nameof(Decompressors))]
143+
public void DecompressOversizedInputUnknownSizeTest(Decompressor decompressor, ReadOnlyMemory<byte> inputMemory, BclDeflater bclDeflater)
144+
{
145+
var bclDeflated = bclDeflater(inputMemory);
146+
var deflatedInput = GetOversizedInputBuffer(bclDeflated.Span, out var expectedReadLength);
145147

146-
using (decompressor)
148+
using (decompressor)
149+
{
150+
var status = decompressor.Decompress(deflatedInput, inputMemory.Length, out var outputOwner, out int bytesRead);
151+
using (outputOwner)
147152
{
148-
var status = decompressor.Decompress(deflatedInput, inputMemory.Length, out var outputOwner, out int bytesRead);
149-
using (outputOwner)
150-
{
151-
Assert.Equal(OperationStatus.Done, status);
152-
Assert.NotNull(outputOwner);
153-
154-
var output = outputOwner.Memory.Span;
155-
Assert.True(inputMemory.Span.SequenceEqual(output));
156-
Assert.Equal(expectedReadLength, bytesRead);
157-
}
153+
Assert.Equal(OperationStatus.Done, status);
154+
Assert.NotNull(outputOwner);
155+
156+
var output = outputOwner.Memory.Span;
157+
Assert.True(inputMemory.Span.SequenceEqual(output));
158+
Assert.Equal(expectedReadLength, bytesRead);
158159
}
159160
}
160161
}

0 commit comments

Comments
 (0)