6
6
using System . IO ;
7
7
using System . Security ;
8
8
using System . Text ;
9
+ using System . Threading . Tasks ;
9
10
10
11
namespace ICSharpCode . SharpZipLib . Tests . Base
11
12
{
@@ -15,19 +16,50 @@ namespace ICSharpCode.SharpZipLib.Tests.Base
15
16
[ TestFixture ]
16
17
public class InflaterDeflaterTestSuite
17
18
{
18
- private void Inflate ( MemoryStream ms , byte [ ] original , int level , bool zlib )
19
+ private void VerifyInflatedData ( byte [ ] original , byte [ ] buf2 , int level , bool zlib )
20
+ {
21
+ for ( int i = 0 ; i < original . Length ; ++ i )
22
+ {
23
+ if ( buf2 [ i ] != original [ i ] )
24
+ {
25
+ string description = string . Format ( "Difference at {0} level {1} zlib {2} " , i , level , zlib ) ;
26
+ if ( original . Length < 2048 )
27
+ {
28
+ var builder = new StringBuilder ( description ) ;
29
+ for ( int d = 0 ; d < original . Length ; ++ d )
30
+ {
31
+ builder . AppendFormat ( "{0} " , original [ d ] ) ;
32
+ }
33
+
34
+ Assert . Fail ( builder . ToString ( ) ) ;
35
+ }
36
+ else
37
+ {
38
+ Assert . Fail ( description ) ;
39
+ }
40
+ }
41
+ }
42
+ }
43
+
44
+ private static InflaterInputStream GetInflaterInputStream ( Stream compressedStream , bool zlib )
19
45
{
20
- ms . Seek ( 0 , SeekOrigin . Begin ) ;
46
+ compressedStream . Seek ( 0 , SeekOrigin . Begin ) ;
21
47
22
48
var inflater = new Inflater ( ! zlib ) ;
23
- var inStream = new InflaterInputStream ( ms , inflater ) ;
24
- byte [ ] buf2 = new byte [ original . Length ] ;
49
+ var inStream = new InflaterInputStream ( compressedStream , inflater ) ;
25
50
26
- int currentIndex = 0 ;
27
- int count = buf2 . Length ;
51
+ return inStream ;
52
+ }
28
53
29
- try
54
+ private void Inflate ( MemoryStream ms , byte [ ] original , int level , bool zlib )
55
+ {
56
+ byte [ ] buf2 = new byte [ original . Length ] ;
57
+
58
+ using ( var inStream = GetInflaterInputStream ( ms , zlib ) )
30
59
{
60
+ int currentIndex = 0 ;
61
+ int count = buf2 . Length ;
62
+
31
63
while ( true )
32
64
{
33
65
int numRead = inStream . Read ( buf2 , currentIndex , count ) ;
@@ -38,40 +70,37 @@ private void Inflate(MemoryStream ms, byte[] original, int level, bool zlib)
38
70
currentIndex += numRead ;
39
71
count -= numRead ;
40
72
}
41
- }
42
- catch ( Exception ex )
43
- {
44
- Console . WriteLine ( "Unexpected exception - '{0}'" , ex . Message ) ;
45
- throw ;
46
- }
47
73
48
- if ( currentIndex != original . Length )
49
- {
50
- Console . WriteLine ( "Original {0}, new {1}" , original . Length , currentIndex ) ;
51
- Assert . Fail ( "Lengths different" ) ;
74
+ Assert . That ( currentIndex , Is . EqualTo ( original . Length ) , "Decompressed data must have the same length as the original data" ) ;
52
75
}
53
76
54
- for ( int i = 0 ; i < original . Length ; ++ i )
77
+ VerifyInflatedData ( original , buf2 , level , zlib ) ;
78
+ }
79
+
80
+ private async Task InflateAsync ( MemoryStream ms , byte [ ] original , int level , bool zlib )
81
+ {
82
+ byte [ ] buf2 = new byte [ original . Length ] ;
83
+
84
+ using ( var inStream = GetInflaterInputStream ( ms , zlib ) )
55
85
{
56
- if ( buf2 [ i ] != original [ i ] )
57
- {
58
- string description = string . Format ( "Difference at {0} level {1} zlib {2} " , i , level , zlib ) ;
59
- if ( original . Length < 2048 )
60
- {
61
- var builder = new StringBuilder ( description ) ;
62
- for ( int d = 0 ; d < original . Length ; ++ d )
63
- {
64
- builder . AppendFormat ( "{0} " , original [ d ] ) ;
65
- }
86
+ int currentIndex = 0 ;
87
+ int count = buf2 . Length ;
66
88
67
- Assert . Fail ( builder . ToString ( ) ) ;
68
- }
69
- else
89
+ while ( true )
90
+ {
91
+ int numRead = await inStream . ReadAsync ( buf2 , currentIndex , count ) ;
92
+ if ( numRead <= 0 )
70
93
{
71
- Assert . Fail ( description ) ;
94
+ break ;
72
95
}
96
+ currentIndex += numRead ;
97
+ count -= numRead ;
73
98
}
99
+
100
+ Assert . That ( currentIndex , Is . EqualTo ( original . Length ) , "Decompressed data must have the same length as the original data" ) ;
74
101
}
102
+
103
+ VerifyInflatedData ( original , buf2 , level , zlib ) ;
75
104
}
76
105
77
106
private MemoryStream Deflate ( byte [ ] data , int level , bool zlib )
@@ -89,16 +118,46 @@ private MemoryStream Deflate(byte[] data, int level, bool zlib)
89
118
return memoryStream ;
90
119
}
91
120
92
- private void RandomDeflateInflate ( int size , int level , bool zlib )
121
+ private async Task < MemoryStream > DeflateAsync ( byte [ ] data , int level , bool zlib )
122
+ {
123
+ var memoryStream = new MemoryStream ( ) ;
124
+
125
+ var deflater = new Deflater ( level , ! zlib ) ;
126
+ using ( DeflaterOutputStream outStream = new DeflaterOutputStream ( memoryStream , deflater ) )
127
+ {
128
+ outStream . IsStreamOwner = false ;
129
+ await outStream . WriteAsync ( data , 0 , data . Length ) ;
130
+ await outStream . FlushAsync ( ) ;
131
+ outStream . Finish ( ) ;
132
+ }
133
+ return memoryStream ;
134
+ }
135
+
136
+ private static byte [ ] GetRandomTestData ( int size )
93
137
{
94
138
byte [ ] buffer = new byte [ size ] ;
95
139
var rnd = new Random ( ) ;
96
140
rnd . NextBytes ( buffer ) ;
97
141
142
+ return buffer ;
143
+ }
144
+
145
+ private void RandomDeflateInflate ( int size , int level , bool zlib )
146
+ {
147
+ byte [ ] buffer = GetRandomTestData ( size ) ;
148
+
98
149
MemoryStream ms = Deflate ( buffer , level , zlib ) ;
99
150
Inflate ( ms , buffer , level , zlib ) ;
100
151
}
101
152
153
+ private async Task RandomDeflateInflateAsync ( int size , int level , bool zlib )
154
+ {
155
+ byte [ ] buffer = GetRandomTestData ( size ) ;
156
+
157
+ MemoryStream ms = await DeflateAsync ( buffer , level , zlib ) ;
158
+ await InflateAsync ( ms , buffer , level , zlib ) ;
159
+ }
160
+
102
161
/// <summary>
103
162
/// Basic inflate/deflate test
104
163
/// </summary>
@@ -109,12 +168,23 @@ public void InflateDeflateZlib([Range(0, 9)] int level)
109
168
RandomDeflateInflate ( 100000 , level , true ) ;
110
169
}
111
170
171
+ /// <summary>
172
+ /// Basic async inflate/deflate test
173
+ /// </summary>
174
+ [ Test ]
175
+ [ Category ( "Base" ) ]
176
+ [ Category ( "Async" ) ]
177
+ public async Task InflateDeflateZlibAsync ( [ Range ( 0 , 9 ) ] int level )
178
+ {
179
+ await RandomDeflateInflateAsync ( 100000 , level , true ) ;
180
+ }
181
+
112
182
private delegate void RunCompress ( byte [ ] buffer ) ;
113
183
114
184
private int runLevel ;
115
185
private bool runZlib ;
116
186
private long runCount ;
117
- private Random runRandom = new Random ( 5 ) ;
187
+ private readonly Random runRandom = new Random ( 5 ) ;
118
188
119
189
private void DeflateAndInflate ( byte [ ] buffer )
120
190
{
@@ -169,6 +239,17 @@ public void InflateDeflateNonZlib([Range(0, 9)] int level)
169
239
RandomDeflateInflate ( 100000 , level , false ) ;
170
240
}
171
241
242
+ /// <summary>
243
+ /// Basic async inflate/deflate test
244
+ /// </summary>
245
+ [ Test ]
246
+ [ Category ( "Base" ) ]
247
+ [ Category ( "Async" ) ]
248
+ public async Task InflateDeflateNonZlibAsync ( [ Range ( 0 , 9 ) ] int level )
249
+ {
250
+ await RandomDeflateInflateAsync ( 100000 , level , false ) ;
251
+ }
252
+
172
253
173
254
[ Test ]
174
255
[ Category ( "Base" ) ]
0 commit comments