Fossil SCM
|
1
|
//
|
|
2
|
// © Copyright Henrik Ravn 2004
|
|
3
|
//
|
|
4
|
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
|
5
|
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
|
|
6
|
//
|
|
7
|
|
|
8
|
using System;
|
|
9
|
using System.Collections;
|
|
10
|
using System.IO;
|
|
11
|
|
|
12
|
// uncomment the define below to include unit tests
|
|
13
|
//#define nunit
|
|
14
|
#if nunit
|
|
15
|
using NUnit.Framework;
|
|
16
|
|
|
17
|
// Unit tests for the DotZLib class library
|
|
18
|
// ----------------------------------------
|
|
19
|
//
|
|
20
|
// Use this with NUnit 2 from https://www.nunit.org
|
|
21
|
//
|
|
22
|
|
|
23
|
namespace DotZLibTests
|
|
24
|
{
|
|
25
|
using DotZLib;
|
|
26
|
|
|
27
|
// helper methods
|
|
28
|
internal class Utils
|
|
29
|
{
|
|
30
|
public static bool byteArrEqual( byte[] lhs, byte[] rhs )
|
|
31
|
{
|
|
32
|
if (lhs.Length != rhs.Length)
|
|
33
|
return false;
|
|
34
|
for (int i = lhs.Length-1; i >= 0; --i)
|
|
35
|
if (lhs[i] != rhs[i])
|
|
36
|
return false;
|
|
37
|
return true;
|
|
38
|
}
|
|
39
|
|
|
40
|
}
|
|
41
|
|
|
42
|
|
|
43
|
[TestFixture]
|
|
44
|
public class CircBufferTests
|
|
45
|
{
|
|
46
|
#region Circular buffer tests
|
|
47
|
[Test]
|
|
48
|
public void SinglePutGet()
|
|
49
|
{
|
|
50
|
CircularBuffer buf = new CircularBuffer(10);
|
|
51
|
Assert.AreEqual( 0, buf.Size );
|
|
52
|
Assert.AreEqual( -1, buf.Get() );
|
|
53
|
|
|
54
|
Assert.IsTrue(buf.Put( 1 ));
|
|
55
|
Assert.AreEqual( 1, buf.Size );
|
|
56
|
Assert.AreEqual( 1, buf.Get() );
|
|
57
|
Assert.AreEqual( 0, buf.Size );
|
|
58
|
Assert.AreEqual( -1, buf.Get() );
|
|
59
|
}
|
|
60
|
|
|
61
|
[Test]
|
|
62
|
public void BlockPutGet()
|
|
63
|
{
|
|
64
|
CircularBuffer buf = new CircularBuffer(10);
|
|
65
|
byte[] arr = {1,2,3,4,5,6,7,8,9,10};
|
|
66
|
Assert.AreEqual( 10, buf.Put(arr,0,10) );
|
|
67
|
Assert.AreEqual( 10, buf.Size );
|
|
68
|
Assert.IsFalse( buf.Put(11) );
|
|
69
|
Assert.AreEqual( 1, buf.Get() );
|
|
70
|
Assert.IsTrue( buf.Put(11) );
|
|
71
|
|
|
72
|
byte[] arr2 = (byte[])arr.Clone();
|
|
73
|
Assert.AreEqual( 9, buf.Get(arr2,1,9) );
|
|
74
|
Assert.IsTrue( Utils.byteArrEqual(arr,arr2) );
|
|
75
|
}
|
|
76
|
|
|
77
|
#endregion
|
|
78
|
}
|
|
79
|
|
|
80
|
[TestFixture]
|
|
81
|
public class ChecksumTests
|
|
82
|
{
|
|
83
|
#region CRC32 Tests
|
|
84
|
[Test]
|
|
85
|
public void CRC32_Null()
|
|
86
|
{
|
|
87
|
CRC32Checksum crc32 = new CRC32Checksum();
|
|
88
|
Assert.AreEqual( 0, crc32.Value );
|
|
89
|
|
|
90
|
crc32 = new CRC32Checksum(1);
|
|
91
|
Assert.AreEqual( 1, crc32.Value );
|
|
92
|
|
|
93
|
crc32 = new CRC32Checksum(556);
|
|
94
|
Assert.AreEqual( 556, crc32.Value );
|
|
95
|
}
|
|
96
|
|
|
97
|
[Test]
|
|
98
|
public void CRC32_Data()
|
|
99
|
{
|
|
100
|
CRC32Checksum crc32 = new CRC32Checksum();
|
|
101
|
byte[] data = { 1,2,3,4,5,6,7 };
|
|
102
|
crc32.Update(data);
|
|
103
|
Assert.AreEqual( 0x70e46888, crc32.Value );
|
|
104
|
|
|
105
|
crc32 = new CRC32Checksum();
|
|
106
|
crc32.Update("penguin");
|
|
107
|
Assert.AreEqual( 0x0e5c1a120, crc32.Value );
|
|
108
|
|
|
109
|
crc32 = new CRC32Checksum(1);
|
|
110
|
crc32.Update("penguin");
|
|
111
|
Assert.AreEqual(0x43b6aa94, crc32.Value);
|
|
112
|
|
|
113
|
}
|
|
114
|
#endregion
|
|
115
|
|
|
116
|
#region Adler tests
|
|
117
|
|
|
118
|
[Test]
|
|
119
|
public void Adler_Null()
|
|
120
|
{
|
|
121
|
AdlerChecksum adler = new AdlerChecksum();
|
|
122
|
Assert.AreEqual(0, adler.Value);
|
|
123
|
|
|
124
|
adler = new AdlerChecksum(1);
|
|
125
|
Assert.AreEqual( 1, adler.Value );
|
|
126
|
|
|
127
|
adler = new AdlerChecksum(556);
|
|
128
|
Assert.AreEqual( 556, adler.Value );
|
|
129
|
}
|
|
130
|
|
|
131
|
[Test]
|
|
132
|
public void Adler_Data()
|
|
133
|
{
|
|
134
|
AdlerChecksum adler = new AdlerChecksum(1);
|
|
135
|
byte[] data = { 1,2,3,4,5,6,7 };
|
|
136
|
adler.Update(data);
|
|
137
|
Assert.AreEqual( 0x5b001d, adler.Value );
|
|
138
|
|
|
139
|
adler = new AdlerChecksum();
|
|
140
|
adler.Update("penguin");
|
|
141
|
Assert.AreEqual(0x0bcf02f6, adler.Value );
|
|
142
|
|
|
143
|
adler = new AdlerChecksum(1);
|
|
144
|
adler.Update("penguin");
|
|
145
|
Assert.AreEqual(0x0bd602f7, adler.Value);
|
|
146
|
|
|
147
|
}
|
|
148
|
#endregion
|
|
149
|
}
|
|
150
|
|
|
151
|
[TestFixture]
|
|
152
|
public class InfoTests
|
|
153
|
{
|
|
154
|
#region Info tests
|
|
155
|
[Test]
|
|
156
|
public void Info_Version()
|
|
157
|
{
|
|
158
|
Info info = new Info();
|
|
159
|
Assert.AreEqual("1.3.2", Info.Version);
|
|
160
|
Assert.AreEqual(32, info.SizeOfUInt);
|
|
161
|
Assert.AreEqual(32, info.SizeOfULong);
|
|
162
|
Assert.AreEqual(32, info.SizeOfPointer);
|
|
163
|
Assert.AreEqual(32, info.SizeOfOffset);
|
|
164
|
}
|
|
165
|
#endregion
|
|
166
|
}
|
|
167
|
|
|
168
|
[TestFixture]
|
|
169
|
public class DeflateInflateTests
|
|
170
|
{
|
|
171
|
#region Deflate tests
|
|
172
|
[Test]
|
|
173
|
public void Deflate_Init()
|
|
174
|
{
|
|
175
|
using (Deflater def = new Deflater(CompressLevel.Default))
|
|
176
|
{
|
|
177
|
}
|
|
178
|
}
|
|
179
|
|
|
180
|
private ArrayList compressedData = new ArrayList();
|
|
181
|
private uint adler1;
|
|
182
|
|
|
183
|
private ArrayList uncompressedData = new ArrayList();
|
|
184
|
private uint adler2;
|
|
185
|
|
|
186
|
public void CDataAvail(byte[] data, int startIndex, int count)
|
|
187
|
{
|
|
188
|
for (int i = 0; i < count; ++i)
|
|
189
|
compressedData.Add(data[i+startIndex]);
|
|
190
|
}
|
|
191
|
|
|
192
|
[Test]
|
|
193
|
public void Deflate_Compress()
|
|
194
|
{
|
|
195
|
compressedData.Clear();
|
|
196
|
|
|
197
|
byte[] testData = new byte[35000];
|
|
198
|
for (int i = 0; i < testData.Length; ++i)
|
|
199
|
testData[i] = 5;
|
|
200
|
|
|
201
|
using (Deflater def = new Deflater((CompressLevel)5))
|
|
202
|
{
|
|
203
|
def.DataAvailable += new DataAvailableHandler(CDataAvail);
|
|
204
|
def.Add(testData);
|
|
205
|
def.Finish();
|
|
206
|
adler1 = def.Checksum;
|
|
207
|
}
|
|
208
|
}
|
|
209
|
#endregion
|
|
210
|
|
|
211
|
#region Inflate tests
|
|
212
|
[Test]
|
|
213
|
public void Inflate_Init()
|
|
214
|
{
|
|
215
|
using (Inflater inf = new Inflater())
|
|
216
|
{
|
|
217
|
}
|
|
218
|
}
|
|
219
|
|
|
220
|
private void DDataAvail(byte[] data, int startIndex, int count)
|
|
221
|
{
|
|
222
|
for (int i = 0; i < count; ++i)
|
|
223
|
uncompressedData.Add(data[i+startIndex]);
|
|
224
|
}
|
|
225
|
|
|
226
|
[Test]
|
|
227
|
public void Inflate_Expand()
|
|
228
|
{
|
|
229
|
uncompressedData.Clear();
|
|
230
|
|
|
231
|
using (Inflater inf = new Inflater())
|
|
232
|
{
|
|
233
|
inf.DataAvailable += new DataAvailableHandler(DDataAvail);
|
|
234
|
inf.Add((byte[])compressedData.ToArray(typeof(byte)));
|
|
235
|
inf.Finish();
|
|
236
|
adler2 = inf.Checksum;
|
|
237
|
}
|
|
238
|
Assert.AreEqual( adler1, adler2 );
|
|
239
|
}
|
|
240
|
#endregion
|
|
241
|
}
|
|
242
|
|
|
243
|
[TestFixture]
|
|
244
|
public class GZipStreamTests
|
|
245
|
{
|
|
246
|
#region GZipStream test
|
|
247
|
[Test]
|
|
248
|
public void GZipStream_WriteRead()
|
|
249
|
{
|
|
250
|
using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best))
|
|
251
|
{
|
|
252
|
BinaryWriter writer = new BinaryWriter(gzOut);
|
|
253
|
writer.Write("hi there");
|
|
254
|
writer.Write(Math.PI);
|
|
255
|
writer.Write(42);
|
|
256
|
}
|
|
257
|
|
|
258
|
using (GZipStream gzIn = new GZipStream("gzstream.gz"))
|
|
259
|
{
|
|
260
|
BinaryReader reader = new BinaryReader(gzIn);
|
|
261
|
string s = reader.ReadString();
|
|
262
|
Assert.AreEqual("hi there",s);
|
|
263
|
double d = reader.ReadDouble();
|
|
264
|
Assert.AreEqual(Math.PI, d);
|
|
265
|
int i = reader.ReadInt32();
|
|
266
|
Assert.AreEqual(42,i);
|
|
267
|
}
|
|
268
|
|
|
269
|
}
|
|
270
|
#endregion
|
|
271
|
}
|
|
272
|
}
|
|
273
|
|
|
274
|
#endif
|
|
275
|
|