Added further tests for stream ownership. Refactored tests somewhat adding TestSupport classes.

Added threaded zip tests.

Author: jfreilly

tests/AssemblyInfo.cs

@@ -23,7 +23,7 @@
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
 
-[assembly: AssemblyVersion("0.85.2.329")]
+[assembly: AssemblyVersion("0.85.3.346")]
 
 // The following attributes specify the key for the sign of your assembly. See the
 // .NET Framework documentation for more information about signing.

tests/Base/InflaterDeflaterTests.cs

@@ -9,6 +9,8 @@
 using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
 using ICSharpCode.SharpZipLib.GZip;
 
+using ICSharpCode.SharpZipLib.Tests.TestSupport;
+
 namespace ICSharpCode.SharpZipLib.Tests.Base
 {
 	/// <summary>
@@ -165,7 +167,7 @@ public void SmallBlocks()
 		}
 
 		[Test]
-        [Explicit]
+		[Explicit]
 		[Category("Base")]
 		[Category("ExcludeFromAutoBuild")]
 		public void FindBug()
@@ -230,6 +232,64 @@ public void CloseDeflatorWithNestedUsing()
 			}
 		}
 
+		[Test]
+		[Category("Base")]
+		public void DeflatorStreamOwnership()
+		{
+			MemoryStreamEx memStream = new MemoryStreamEx();
+			DeflaterOutputStream s = new DeflaterOutputStream(memStream);
+			
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+			
+			s.Close();
+			
+			Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
+			Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
+			
+			memStream = new MemoryStreamEx();
+			s = new DeflaterOutputStream(memStream);
+			
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+			
+			s.IsStreamOwner = false;
+			s.Close();
+			
+			Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
+			Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
+			
+		}
+
+		[Test]
+		[Category("Base")]
+		public void InflatorStreamOwnership()
+		{
+			MemoryStreamEx memStream = new MemoryStreamEx();
+			InflaterInputStream s = new InflaterInputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.Close();
+
+			Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
+			Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
+
+			memStream = new MemoryStreamEx();
+			s = new InflaterInputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.IsStreamOwner = false;
+			s.Close();
+
+			Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
+			Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
+
+		}
+		
 		[Test]
 		[Category("Base")]
 		public void CloseInflatorWithNestedUsing()

tests/GZip/GZipTests.cs

@@ -1,12 +1,15 @@
 using System;
 using System.IO;
+using System.Threading;
 
 using ICSharpCode.SharpZipLib.Zip.Compression;
 using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
 using ICSharpCode.SharpZipLib.GZip;
 
 using NUnit.Framework;
 
+using ICSharpCode.SharpZipLib.Tests.TestSupport;
+
 namespace ICSharpCode.SharpZipLib.Tests.GZip
 {
 	/// <summary>
@@ -24,21 +27,22 @@ public void TestGZip()
 		{
 			MemoryStream ms = new MemoryStream();
 			GZipOutputStream outStream = new GZipOutputStream(ms);
-			
+
 			byte[] buf = new byte[100000];
 			System.Random rnd = new Random();
 			rnd.NextBytes(buf);
-			
+
 			outStream.Write(buf, 0, buf.Length);
 			outStream.Flush();
 			outStream.Finish();
-			
+
 			ms.Seek(0, SeekOrigin.Begin);
-			
+
 			GZipInputStream inStream = new GZipInputStream(ms);
 			byte[] buf2 = new byte[buf.Length];
-			int    currentIndex  = 0;
-			int    count = buf2.Length;
+			int currentIndex = 0;
+			int count = buf2.Length;
+			
 			while (true) {
 				int numRead = inStream.Read(buf2, currentIndex, count);
 				if (numRead <= 0) {
@@ -47,6 +51,8 @@ public void TestGZip()
 				currentIndex += numRead;
 				count -= numRead;
 			}
+
+			Assert.AreEqual(0, count);
 
 			for (int i = 0; i < buf.Length; ++i) {
 				Assert.AreEqual(buf2[i], buf[i]);
@@ -57,14 +63,16 @@ public void TestGZip()
 		/// Writing GZip headers is delayed so that this stream can be used with HTTP/IIS.
 		/// </summary>
 		[Test]
+		[Category("GZip")]
 		public void DelayedHeaderWriteNoData()
 		{
 			MemoryStream ms = new MemoryStream();
 			Assert.AreEqual(0, ms.Length);
-			using (GZipOutputStream outStream = new GZipOutputStream(ms))
-			{
+			
+			using (GZipOutputStream outStream = new GZipOutputStream(ms)) {
 				Assert.AreEqual(0, ms.Length);
 			}
+			
 			byte[] data = ms.ToArray();
 
 			Assert.IsTrue(data.Length > 0);
@@ -74,12 +82,12 @@ public void DelayedHeaderWriteNoData()
 		/// Writing GZip headers is delayed so that this stream can be used with HTTP/IIS.
 		/// </summary>
 		[Test]
+		[Category("GZip")]
 		public void DelayedHeaderWriteWithData()
 		{
 			MemoryStream ms = new MemoryStream();
 			Assert.AreEqual(0, ms.Length);
-			using (GZipOutputStream outStream = new GZipOutputStream(ms))
-			{
+			using (GZipOutputStream outStream = new GZipOutputStream(ms)) {
 				Assert.AreEqual(0, ms.Length);
 				outStream.WriteByte(45);
 
@@ -93,19 +101,163 @@ public void DelayedHeaderWriteWithData()
 		}
 
 		[Test]
+		[Category("GZip")]
 		public void ZeroLengthInputStream()
 		{
 			GZipInputStream gzi = new GZipInputStream(new MemoryStream());
 			bool exception = false;
 			try {
 				gzi.ReadByte();
 			}
-			catch
-			{
+			catch {
 				exception = true;
 			}
-			
+
 			Assert.IsTrue(exception, "reading from an empty stream should cause an exception");
 		}
+
+		[Test]
+		[Category("GZip")]
+		public void OutputStreamOwnership()
+		{
+			MemoryStreamEx memStream = new MemoryStreamEx();
+			GZipOutputStream s = new GZipOutputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.Close();
+
+			Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
+			Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
+
+			memStream = new MemoryStreamEx();
+			s = new GZipOutputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.IsStreamOwner = false;
+			s.Close();
+
+			Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
+			Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
+		}
+
+		[Test]
+		[Category("GZip")]
+		public void InputStreamOwnership()
+		{
+			MemoryStreamEx memStream = new MemoryStreamEx();
+			GZipInputStream s = new GZipInputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.Close();
+
+			Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
+			Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
+
+			memStream = new MemoryStreamEx();
+			s = new GZipInputStream(memStream);
+
+			Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
+			Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
+
+			s.IsStreamOwner = false;
+			s.Close();
+
+			Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
+			Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
+
+		}
+
+		[Test]
+		[Category("GZip")]
+		[Category("Long Running")]
+		public void BigStream()
+		{
+			window_ = new WindowedStream(0x3ffff);
+			outStream_ = new GZipOutputStream(window_);
+			inStream_ = new GZipInputStream(window_);
+
+			long target = 0x10000000;
+			readTarget_ = writeTarget_ = target;
+
+			Thread reader = new Thread(Reader);
+			reader.Name = "Reader";
+			reader.Start();
+
+			Thread writer = new Thread(Writer);
+			writer.Name = "Writer";
+
+			DateTime startTime = DateTime.Now;
+			writer.Start();
+
+			writer.Join();
+			reader.Join();
+
+			DateTime endTime = DateTime.Now;
+
+			TimeSpan span = endTime - startTime;
+			Console.WriteLine("Time {0}  processes {1} KB/Sec", span, (target / 1024) / span.TotalSeconds);
+		}
+
+		void Reader()
+		{
+			const int Size = 8192;
+			int readBytes = 1;
+			byte[] buffer = new byte[Size];
+
+			long passifierLevel = readTarget_ - 0x10000000;
+
+			while ( (readTarget_ > 0) && (readBytes > 0) ) {
+				int count = Size;
+				if (count > readTarget_) {
+					count = (int)readTarget_;
+				}
+
+				readBytes = inStream_.Read(buffer, 0, count);
+				readTarget_ -= readBytes;
+
+				if (readTarget_ <= passifierLevel) {
+					Console.WriteLine("Reader {0} bytes remaining", readTarget_);
+					passifierLevel = readTarget_ - 0x10000000;
+				}
+			}
+
+			Assert.IsTrue(window_.IsClosed, "Window should be closed");
+
+			// This shouldnt read any data but should read the footer
+			readBytes = inStream_.Read(buffer, 0, 1);
+			Assert.AreEqual(0, readBytes, "Stream should be empty");
+			Assert.AreEqual(0, window_.Length, "Window should be closed");
+			inStream_.Close();
+		}
+
+		void Writer()
+		{
+			const int Size = 8192;
+
+			byte[] buffer = new byte[Size];
+
+			while (writeTarget_ > 0) {
+				int thisTime = Size;
+				if (thisTime > writeTarget_) {
+					thisTime = (int)writeTarget_;
+				}
+
+				outStream_.Write(buffer, 0, thisTime);
+				writeTarget_-= thisTime;
+			}
+			outStream_.Close();
+		}
+
+		WindowedStream window_;
+		GZipOutputStream outStream_;
+		GZipInputStream inStream_;
+		long readTarget_;
+		long writeTarget_;
 	}
 }

tests/SharpZipLibTests.csproj

@@ -43,18 +43,20 @@
     <StartArguments>SharpZipLibTests.dll</StartArguments>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.4.1.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\Bin\Nunit-2.4\bin\nunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Data" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
-    <Reference Include="nunit.framework">
-      <HintPath>..\Nunit\nunit.framework.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="TestSupport\RingBuffer.cs" />
+    <Compile Include="TestSupport\Streams.cs" />
     <Compile Include="Zip\ZipTests.cs" />
     <Compile Include="BZip2\Bzip2Tests.cs" />
     <Compile Include="GZip\GZipTests.cs" />
@@ -67,8 +69,5 @@
       <Name>ICSharpCode.SharpZLib</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Support\" />
-  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>