Test both managed/zlib System.IO.Compression implementations

System.IO.Compression has two implementations for compression/decompression: one based on zlib, and one implemented in managed code.  As we can use the managed implementation as a fallback in case zlib is unavailable, we need to ensure it's functioning properly.

This commit adds a debug-only static field to DeflateStream that supports overriding the normal logic for whether zlib or the managed implementation is used.  The DeflateStream and GZipStream tests are then augmented to force both implementations to be used.

Author: stephentoub

src/System.IO.Compression/src/System/IO/Compression/DeflateStream.cs

@@ -25,8 +25,13 @@ public partial class DeflateStream : Stream
         private bool _wroteHeader;
         private bool _wroteBytes;
 
-        private enum WorkerType : byte { Managed, ZLib, Unknown };
+        private enum WorkerType : byte { Unknown = 0, Managed = 1, ZLib = 2 };
         private static readonly WorkerType s_deflaterType = GetDeflaterType();
+#if DEBUG
+        // This field is used for testing purposes and is accessed via reflection.
+        // NOTE: If the name of this field changes, the test must also be updated.
+        private static WorkerType s_forcedTestingDeflaterType = WorkerType.Unknown;
+#endif
 
         public DeflateStream(Stream stream, CompressionMode mode)
             : this(stream, mode, false)
@@ -105,7 +110,17 @@ public DeflateStream(Stream stream, CompressionLevel compressionLevel, bool leav
 
         private static IDeflater CreateDeflater(CompressionLevel? compressionLevel)
         {
-            switch (s_deflaterType)
+            // The deflator type (zlib or managed) is normally determined by s_deflatorType,
+            // which is initialized by the provider based on what's available on the system.
+            // But for testing purposes, we sometimes want to override this, forcing
+            // compression/decompression to use a particular type.
+            WorkerType deflatorType = s_deflaterType;
+#if DEBUG
+            if (s_forcedTestingDeflaterType != WorkerType.Unknown)
+                deflatorType = s_forcedTestingDeflaterType;
+#endif
+
+            switch (deflatorType)
             {
                 case WorkerType.Managed:
                     return new DeflaterManaged();

src/System.IO.Compression/tests/DeflateStreamTests.cs

@@ -1,23 +1,40 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using System.Collections.Generic;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
-using System.IO;
-using System.Reflection;
-using System.IO.Compression;
 using Xunit;
 
 namespace System.IO.Compression.Tests
 {
-    public partial class DeflateStreamTests
+    public class ZLibDeflateStreamTests : DeflateStreamTests, IDisposable
+    {
+        public ZLibDeflateStreamTests() { SetWorkerMode("zlib"); }
+        public void Dispose() { SetWorkerMode("unknown"); }
+    }
+
+    public class ManagedDeflateStreamTests : DeflateStreamTests, IDisposable
+    {
+        public ManagedDeflateStreamTests() { SetWorkerMode("managed"); }
+        public void Dispose() { SetWorkerMode("unknown"); }
+    }
+
+    public abstract class DeflateStreamTests
     {
         static string gzTestFile(String fileName) { return Path.Combine("GZTestData", fileName); }
 
+        internal static void SetWorkerMode(string mode)
+        {
+            FieldInfo forceType = typeof(DeflateStream).GetTypeInfo().GetDeclaredField("s_forcedTestingDeflaterType");
+            if (forceType != null)
+            {
+                forceType.SetValue(null, mode == "zlib" ? (byte)2 : mode == "managed" ? (byte)1 : (byte)0);
+            }
+        }
+
         [Fact]
-        public static void BaseStream1()
+        public void BaseStream1()
         {
             var writeStream = new MemoryStream();
             var zip = new DeflateStream(writeStream, CompressionMode.Compress);
@@ -27,7 +44,7 @@ public static void BaseStream1()
         }
 
         [Fact]
-        public static void BaseStream2()
+        public void BaseStream2()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Decompress);
@@ -37,7 +54,7 @@ public static void BaseStream2()
         }
 
         [Fact]
-        public static async Task ModifyBaseStream()
+        public async Task ModifyBaseStream()
         {
             var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
             var newMs = StripHeaderAndFooter.Strip(ms);
@@ -52,7 +69,7 @@ public static async Task ModifyBaseStream()
         }
 
         [Fact]
-        public static void  DecompressCanRead()
+        public void DecompressCanRead()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Decompress);
@@ -64,7 +81,7 @@ public static void  DecompressCanRead()
         }
 
         [Fact]
-        public static void CompressCanWrite()
+        public void CompressCanWrite()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Compress);
@@ -75,15 +92,15 @@ public static void CompressCanWrite()
         }
 
         [Fact]
-        public static void CanDisposeBaseStream()
+        public void CanDisposeBaseStream()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Compress);
             ms.Dispose(); // This would throw if this was invalid
         }
 
         [Fact]
-        public static void CanDisposeDeflateStream()
+        public void CanDisposeDeflateStream()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Compress);
@@ -96,7 +113,7 @@ public static void CanDisposeDeflateStream()
         }
 
         [Fact]
-        public static async Task CanReadBaseStreamAfterDispose()
+        public async Task CanReadBaseStreamAfterDispose()
         {
             var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
             var newMs = StripHeaderAndFooter.Strip(ms);
@@ -114,7 +131,7 @@ public static async Task CanReadBaseStreamAfterDispose()
         }
 
         [Fact]
-        public static async Task DecompressWorks()
+        public async Task DecompressWorks()
         {
             var compareStream = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt"));
             var gzStream = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
@@ -123,7 +140,7 @@ public static async Task DecompressWorks()
         }
 
         [Fact]
-        public static async Task DecompressWorksWithBinaryFile()
+        public async Task DecompressWorksWithBinaryFile()
         {
             var compareStream = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.doc"));
             var gzStream = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.doc.gz"));
@@ -132,7 +149,7 @@ public static async Task DecompressWorksWithBinaryFile()
         }
 
         // Making this async since regular read/write are tested below
-        private static async Task DecompressAsync(MemoryStream compareStream, MemoryStream gzStream)
+        private async Task DecompressAsync(MemoryStream compareStream, MemoryStream gzStream)
         {
             var strippedMs = StripHeaderAndFooter.Strip(gzStream);
 
@@ -167,8 +184,9 @@ private static async Task DecompressAsync(MemoryStream compareStream, MemoryStre
                 Assert.Equal(compareArray[i], writtenArray[i]);
             }
         }
+
         [Fact]
-        public static async Task DecompressFailsWithRealGzStream()
+        public async Task DecompressFailsWithRealGzStream()
         {
             String[] files = { gzTestFile("GZTestDocument.doc.gz"), gzTestFile("GZTestDocument.txt.gz") };
             foreach (String fileName in files)
@@ -181,8 +199,9 @@ public static async Task DecompressFailsWithRealGzStream()
                 zip.Dispose();
             }
         }
+
         [Fact]
-        public static void NullBaseStreamThrows()
+        public void NullBaseStreamThrows()
         {
             Assert.Throws<ArgumentNullException>(() =>
             {
@@ -194,8 +213,9 @@ public static void NullBaseStreamThrows()
                 var deflate = new DeflateStream(null, CompressionMode.Compress);
             });
         }
+
         [Fact]
-        public static void DisposedBaseStreamThrows()
+        public void DisposedBaseStreamThrows()
         {
             var ms = new MemoryStream();
             ms.Dispose();
@@ -209,8 +229,9 @@ public static void DisposedBaseStreamThrows()
                 var deflate = new DeflateStream(ms, CompressionMode.Compress);
             });
         }
+
         [Fact]
-        public static void ReadOnlyStreamThrowsOnCompress()
+        public void ReadOnlyStreamThrowsOnCompress()
         {
             var ms = new LocalMemoryStream();
             ms.SetCanWrite(false);
@@ -220,8 +241,9 @@ public static void ReadOnlyStreamThrowsOnCompress()
                 var gzip = new DeflateStream(ms, CompressionMode.Compress);
             });
         }
+
         [Fact]
-        public static void WriteOnlyStreamThrowsOnDecompress()
+        public void WriteOnlyStreamThrowsOnDecompress()
         {
             var ms = new LocalMemoryStream();
             ms.SetCanRead(false);
@@ -231,8 +253,9 @@ public static void WriteOnlyStreamThrowsOnDecompress()
                 var gzip = new DeflateStream(ms, CompressionMode.Decompress);
             });
         }
+
         [Fact]
-        public static void TestCtors()
+        public void TestCtors()
         {
             CompressionLevel[] legalValues = new CompressionLevel[] { CompressionLevel.Optimal, CompressionLevel.Fastest, CompressionLevel.NoCompression };
 
@@ -246,23 +269,26 @@ public static void TestCtors()
                 }
             }
         }
+
         [Fact]
-        public static void TestLevelOptimial()
+        public void TestLevelOptimial()
         {
             TestCtor(CompressionLevel.Optimal);
         }
+
         [Fact]
-        public static void TestLevelNoCompression()
+        public void TestLevelNoCompression()
         {
             TestCtor(CompressionLevel.NoCompression);
         }
+
         [Fact]
-        public static void TestLevelFastest()
+        public void TestLevelFastest()
         {
             TestCtor(CompressionLevel.Fastest);
         }
 
-        public static void TestCtor(CompressionLevel level, bool? leaveOpen = null)
+        private static void TestCtor(CompressionLevel level, bool? leaveOpen = null)
         {
             //Create the DeflateStream
             int _bufferSize = 1024;
@@ -314,7 +340,7 @@ public static void TestCtor(CompressionLevel level, bool? leaveOpen = null)
         }
 
         [Fact]
-        public static async Task Flush()
+        public async Task Flush()
         {
             var ms = new MemoryStream();
             var ds = new DeflateStream(ms, CompressionMode.Compress);
@@ -323,16 +349,18 @@ public static async Task Flush()
 
             // Just ensuring Flush doesn't throw
         }
+
         [Fact]
-        public static void FlushFailsAfterDispose()
+        public void FlushFailsAfterDispose()
         {
             var ms = new MemoryStream();
             var ds = new DeflateStream(ms, CompressionMode.Compress);
             ds.Dispose();
             Assert.Throws<ObjectDisposedException>(() => { ds.Flush(); });
         }
+
         [Fact]
-        public static async Task FlushAsyncFailsAfterDispose()
+        public async Task FlushAsyncFailsAfterDispose()
         {
 
             var ms = new MemoryStream();
@@ -346,7 +374,7 @@ await Assert.ThrowsAsync<ObjectDisposedException>(async () =>
         }
 
         [Fact]
-        public static void TestSeekMethodsDecompress()
+        public void TestSeekMethodsDecompress()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Decompress);
@@ -360,8 +388,9 @@ public static void TestSeekMethodsDecompress()
             //Should we try all the enums? doesn't seem necessary
             Assert.Throws<NotSupportedException>(delegate { zip.Seek(100L, SeekOrigin.Begin); });
         }
+
         [Fact]
-        public static void TestSeekMethodsCompress()
+        public void TestSeekMethodsCompress()
         {
             var ms = new MemoryStream();
             var zip = new DeflateStream(ms, CompressionMode.Compress);