← Back to branch summary

~ubuntu-branches/ubuntu/wily/zlib/wily

« back to all changes in this revision

Viewing changes to contrib/dotzlib/DotZLib/UnitTests.cs

  • Committer: Package Import Robot
  • Author(s): Mark Brown
  • Date: 2012-06-22 16:55:56 UTC
  • mfrom: (1.1.23 sid)
  • Revision ID: package-import@ubuntu.com-20120622165556-9xuc7gnq4w25b3i0
http://bugs.debian.org/678511
Yet more s390x cleanup.  Thanks to the s390x porters for thei
prompt an efficient buildd monitoring (closes: #678511).

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/dotzlib/DotZLib/UnitTests.cs
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 http://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 http://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.2.3", 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
 
 
b'\\ No newline at end of file'