URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [dotzlib/] [DotZLib/] [UnitTests.cs] - Blame information for rev 756

Go to most recent revision | Details | Compare with Previous | View Log


//
// � Copyright Henrik Ravn 2004
//
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
 
using System;
using System.Collections;
using System.IO;
 
// uncomment the define below to include unit tests
//#define nunit
#if nunit
using NUnit.Framework;
 
// Unit tests for the DotZLib class library
// ----------------------------------------
//
// Use this with NUnit 2 from http://www.nunit.org
//
 
namespace DotZLibTests
{
    using DotZLib;
 
    // helper methods
    internal class Utils
    {
        public static bool byteArrEqual( byte[] lhs, byte[] rhs )
        {
            if (lhs.Length != rhs.Length)
                return false;
            for (int i = lhs.Length-1; i >= 0; --i)
                if (lhs[i] != rhs[i])
                    return false;
            return true;
        }
 
    }
 
 
    [TestFixture]
    public class CircBufferTests
    {
        #region Circular buffer tests
        [Test]
        public void SinglePutGet()
        {
            CircularBuffer buf = new CircularBuffer(10);
            Assert.AreEqual( 0, buf.Size );
            Assert.AreEqual( -1, buf.Get() );
 
            Assert.IsTrue(buf.Put( 1 ));
            Assert.AreEqual( 1, buf.Size );
            Assert.AreEqual( 1, buf.Get() );
            Assert.AreEqual( 0, buf.Size );
            Assert.AreEqual( -1, buf.Get() );
        }
 
        [Test]
        public void BlockPutGet()
        {
            CircularBuffer buf = new CircularBuffer(10);
            byte[] arr = {1,2,3,4,5,6,7,8,9,10};
            Assert.AreEqual( 10, buf.Put(arr,0,10) );
            Assert.AreEqual( 10, buf.Size );
            Assert.IsFalse( buf.Put(11) );
            Assert.AreEqual( 1, buf.Get() );
            Assert.IsTrue( buf.Put(11) );
 
            byte[] arr2 = (byte[])arr.Clone();
            Assert.AreEqual( 9, buf.Get(arr2,1,9) );
            Assert.IsTrue( Utils.byteArrEqual(arr,arr2) );
        }
 
        #endregion
    }
 
    [TestFixture]
    public class ChecksumTests
    {
        #region CRC32 Tests
        [Test]
        public void CRC32_Null()
        {
            CRC32Checksum crc32 = new CRC32Checksum();
            Assert.AreEqual( 0, crc32.Value );
 
            crc32 = new CRC32Checksum(1);
            Assert.AreEqual( 1, crc32.Value );
 
            crc32 = new CRC32Checksum(556);
            Assert.AreEqual( 556, crc32.Value );
        }
 
        [Test]
        public void CRC32_Data()
        {
            CRC32Checksum crc32 = new CRC32Checksum();
            byte[] data = { 1,2,3,4,5,6,7 };
            crc32.Update(data);
            Assert.AreEqual( 0x70e46888, crc32.Value  );
 
            crc32 = new CRC32Checksum();
            crc32.Update("penguin");
            Assert.AreEqual( 0x0e5c1a120, crc32.Value );
 
            crc32 = new CRC32Checksum(1);
            crc32.Update("penguin");
            Assert.AreEqual(0x43b6aa94, crc32.Value);
 
        }
        #endregion
 
        #region Adler tests
 
        [Test]
        public void Adler_Null()
        {
            AdlerChecksum adler = new AdlerChecksum();
            Assert.AreEqual(0, adler.Value);
 
            adler = new AdlerChecksum(1);
            Assert.AreEqual( 1, adler.Value );
 
            adler = new AdlerChecksum(556);
            Assert.AreEqual( 556, adler.Value );
        }
 
        [Test]
        public void Adler_Data()
        {
            AdlerChecksum adler = new AdlerChecksum(1);
            byte[] data = { 1,2,3,4,5,6,7 };
            adler.Update(data);
            Assert.AreEqual( 0x5b001d, adler.Value  );
 
            adler = new AdlerChecksum();
            adler.Update("penguin");
            Assert.AreEqual(0x0bcf02f6, adler.Value );
 
            adler = new AdlerChecksum(1);
            adler.Update("penguin");
            Assert.AreEqual(0x0bd602f7, adler.Value);
 
        }
        #endregion
    }
 
    [TestFixture]
    public class InfoTests
    {
        #region Info tests
        [Test]
        public void Info_Version()
        {
            Info info = new Info();
            Assert.AreEqual("1.2.3", Info.Version);
            Assert.AreEqual(32, info.SizeOfUInt);
            Assert.AreEqual(32, info.SizeOfULong);
            Assert.AreEqual(32, info.SizeOfPointer);
            Assert.AreEqual(32, info.SizeOfOffset);
        }
        #endregion
    }
 
    [TestFixture]
    public class DeflateInflateTests
    {
        #region Deflate tests
        [Test]
        public void Deflate_Init()
        {
            using (Deflater def = new Deflater(CompressLevel.Default))
            {
            }
        }
 
        private ArrayList compressedData = new ArrayList();
        private uint adler1;
 
        private ArrayList uncompressedData = new ArrayList();
        private uint adler2;
 
        public void CDataAvail(byte[] data, int startIndex, int count)
        {
            for (int i = 0; i < count; ++i)
                compressedData.Add(data[i+startIndex]);
        }
 
        [Test]
        public void Deflate_Compress()
        {
            compressedData.Clear();
 
            byte[] testData = new byte[35000];
            for (int i = 0; i < testData.Length; ++i)
                testData[i] = 5;
 
            using (Deflater def = new Deflater((CompressLevel)5))
            {
                def.DataAvailable += new DataAvailableHandler(CDataAvail);
                def.Add(testData);
                def.Finish();
                adler1 = def.Checksum;
            }
        }
        #endregion
 
        #region Inflate tests
        [Test]
        public void Inflate_Init()
        {
            using (Inflater inf = new Inflater())
            {
            }
        }
 
        private void DDataAvail(byte[] data, int startIndex, int count)
        {
            for (int i = 0; i < count; ++i)
                uncompressedData.Add(data[i+startIndex]);
        }
 
        [Test]
        public void Inflate_Expand()
        {
            uncompressedData.Clear();
 
            using (Inflater inf = new Inflater())
            {
                inf.DataAvailable += new DataAvailableHandler(DDataAvail);
                inf.Add((byte[])compressedData.ToArray(typeof(byte)));
                inf.Finish();
                adler2 = inf.Checksum;
            }
            Assert.AreEqual( adler1, adler2 );
        }
        #endregion
    }
 
    [TestFixture]
    public class GZipStreamTests
    {
        #region GZipStream test
        [Test]
        public void GZipStream_WriteRead()
        {
            using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best))
            {
                BinaryWriter writer = new BinaryWriter(gzOut);
                writer.Write("hi there");
                writer.Write(Math.PI);
                writer.Write(42);
            }
 
            using (GZipStream gzIn = new GZipStream("gzstream.gz"))
            {
                BinaryReader reader = new BinaryReader(gzIn);
                string s = reader.ReadString();
                Assert.AreEqual("hi there",s);
                double d = reader.ReadDouble();
                Assert.AreEqual(Math.PI, d);
                int i = reader.ReadInt32();
                Assert.AreEqual(42,i);
            }
 
        }
        #endregion
        }
}
 
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [dotzlib/] [DotZLib/] [UnitTests.cs] - Blame information for rev 756

Line No.	Rev	Author	Line
1	745	jeremybenn	`//`
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`