← Back to branch summary

~ubuntu-branches/ubuntu/wily/luatex/wily

« back to all changes in this revision

Viewing changes to source/libs/zlib/zlib-1.2.3/contrib/dotzlib/DotZLib/UnitTests.cs

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Preining
  • Date: 2010-04-29 00:47:19 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20100429004719-o42etkqe90n97b9e
Tags: 0.60.1-1
* new upstream release, adapt build-script patch
* disable patch: upstream-epstopdf_cc_no_xpdf_patching, included upstream
* disable patch: libpoppler-0.12, not needed anymore

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/zlib/zlib-1.2.3/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'