1 files changed, 274 insertions, 0 deletions
diff --git a/contrib/dotzlib/DotZLib/UnitTests.cs b/contrib/dotzlib/DotZLib/UnitTests.cs
new file mode 100644
index 0000000..2f374b6
--- /dev/null
+++ b/contrib/dotzlib/DotZLib/UnitTests.cs
@@ -0,0 +1,274 @@
+//
+// © 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.2", 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
+\ No newline at end of file

diff --git a/contrib/dotzlib/DotZLib/UnitTests.cs b/contrib/dotzlib/DotZLib/UnitTests.cs new file mode 100644 index 0000000..2f374b6 --- /dev/null +++ b/contrib/dotzlib/DotZLib/UnitTests.cs
@@ -0,0 +1,274 @@
	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.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 \ No newline at end of file