예제 #1
0
        public void Gzip_Flush()
        {
            // Verify behavior of flushing a compression stream
            using (MemoryStream compressed = new MemoryStream())
            {
                using (GzipWriter stream = new GzipWriter(compressed, true))
                {
                    stream.Write(s_sampledata, 0, s_sampledata.Length);

                    // Get the unflushed length of the compressed stream and flush it
                    long unflushed = compressed.Length;
                    stream.Flush();

                    // The expectation is that the output stream will be longer after the flush
                    long flushedonce = compressed.Length;
                    Assert.IsTrue(compressed.Length > unflushed);

                    // Flushing the same data a second time should not have any impact at all
                    stream.Flush();
                    Assert.AreEqual(compressed.Length, flushedonce);

                    // The stream should still be writable after a flush operation
                    stream.Write(s_sampledata, 0, s_sampledata.Length / 10);
                }
            }

            // Verify behavior of flushing a decompression stream
            using (GzipReader stream = new GzipReader(new MemoryStream(s_sampledata)))
            {
                // Flush has no effect on decompression streams, just ensure it doesn't throw
                stream.Flush();
            }
        }
예제 #2
0
 public void Gzip_CompressExternal()
 {
     // This method generates an output file that can be tested externally; "thethreemusketeers.txt" is
     // set to Copy Always to the output directory, it can be diffed after running the external tool
     using (GzipWriter writer = new GzipWriter(File.Create(Path.Combine(Environment.CurrentDirectory, "thethreemusketeers.gz"))))
     {
         writer.Write(s_sampledata);
         writer.Flush();
     }
 }
예제 #3
0
        public void Gzip_CompressionLevel()
        {
            using (MemoryStream source = new MemoryStream(s_sampledata))
            {
                long none, fastest, optimal;                        // Size of compressed streams

                // Compress using CompressionLevel.NoCompression
                using (MemoryStream compressed = new MemoryStream())
                {
                    using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.NoCompression))
                    {
                        compressor.Write(s_sampledata, 0, s_sampledata.Length);
                        compressor.Flush();
                        none = compressed.Length;
                    }
                }

                // Compress using CompressionLevel.Fastest
                using (MemoryStream compressed = new MemoryStream())
                {
                    using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.Fastest))
                    {
                        compressor.Write(s_sampledata, 0, s_sampledata.Length);
                        compressor.Flush();
                        fastest = compressed.Length;
                    }
                }

                // Compress using CompressionLevel.Optimal
                using (MemoryStream compressed = new MemoryStream())
                {
                    using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.Optimal))
                    {
                        compressor.Write(s_sampledata, 0, s_sampledata.Length);
                        compressor.Flush();
                        optimal = compressed.Length;
                    }
                }

                // Fastest should produce better results than no compression
                Assert.IsTrue(fastest < none);

                // Optimal should produce better results than fastest
                Assert.IsTrue(optimal < fastest);

                // Fastest should be smaller than the original length
                Assert.IsTrue(fastest < source.Length);

                // No compression should be BIGGER than the original length
                Assert.IsTrue(source.Length < none);
            }
        }
예제 #4
0
        public void Gzip_GzipException()
        {
            using (MemoryStream compressed = new MemoryStream())
            {
                // Start with a compressed MemoryStream created from the sample data
                using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.Optimal, true))
                {
                    compressor.Write(s_sampledata, 0, s_sampledata.Length);
                    compressor.Flush();
                }

                byte[]        buffer       = new byte[8192];
                GzipException thrown       = null;
                GzipException deserialized = null;

                // Create a decompressor to test exception cases
                using (GzipReader decompressor = new GzipReader(compressed, true))
                {
                    // Attempting to read from the middle of the compressed stream should throw a GzipException
                    compressed.Position = compressed.Length / 2;
                    try { decompressor.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
                    catch (GzipException ex) { thrown = ex; }

                    Assert.IsNotNull(thrown);
                    Assert.IsInstanceOfType(thrown, typeof(GzipException));

                    // Check the error code property
                    Assert.AreEqual(-3, thrown.ErrorCode);                              // Z_DATA_ERROR (-3)

                    // Serialize and de-serialize the exception with a BinaryFormatter
                    BinaryFormatter formatter = new BinaryFormatter();
                    using (MemoryStream memstream = new MemoryStream())
                    {
                        formatter.Serialize(memstream, thrown);
                        memstream.Seek(0, 0);
                        deserialized = (GzipException)formatter.Deserialize(memstream);
                    }

                    // Check that the exceptions are equivalent
                    Assert.AreEqual(thrown.ErrorCode, deserialized.ErrorCode);
                    Assert.AreEqual(thrown.StackTrace, deserialized.StackTrace);
                    Assert.AreEqual(thrown.ToString(), deserialized.ToString());
                }
            }
        }
예제 #5
0
        public void Gzip_Write()
        {
            byte[] buffer = new byte[8192];                     // 8KiB data buffer

            // Compress the sample data using a call to Write directly
            using (MemoryStream compressed = new MemoryStream())
            {
                // Check the constructor for ArgumentNullException while we're here
                try { using (GzipWriter compressor = new GzipWriter(null)) { }; Assert.Fail("Constructor should have thrown an exception"); }
                catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

                using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.Optimal, true))
                {
                    // Send in some bum arguments to Write() to check they are caught
                    try { compressor.Write(null); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

                    try { compressor.Write(null, 0, 0); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

                    try { compressor.Write(s_sampledata, -1, 0); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

                    try { compressor.Write(s_sampledata, 0, -1); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

                    try { compressor.Write(s_sampledata, 0, s_sampledata.Length + 1024); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentException)); }

                    // Not writing anything shouldn't throw an exception
                    compressor.Write(s_sampledata, 0, 0);

                    // Compress the data; there really isn't much that can go wrong with Write() itself
                    compressor.Write(s_sampledata, 0, s_sampledata.Length);
                    compressor.Flush();
                }

                using (GzipReader reader = new GzipReader(compressed, true))
                {
                    try { reader.Write(buffer, 0, buffer.Length); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(NotSupportedException)); }
                }
            }
        }
예제 #6
0
        public void Gzip_Encoder()
        {
            // The GzipEncoder is just a wrapper around GzipWriter that provides
            // more complete control over the compression/encoder parameters
            GzipEncoder encoder = new GzipEncoder();

            // Check the default values
            Assert.AreEqual(65536, encoder.BufferSize);
            Assert.AreEqual(GzipCompressionLevel.Default, encoder.CompressionLevel);

            // Set some bad values and ensure they are caught by the encoder property setters
            try { encoder.BufferSize = -1; Assert.Fail("Property should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

            try { encoder.CompressionLevel = new GzipCompressionLevel(-2); Assert.Fail("Property should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

            try { encoder.CompressionLevel = new GzipCompressionLevel(10); Assert.Fail("Property should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

            // Set some good values
            encoder.BufferSize = 8192;
            Assert.AreEqual(8192, encoder.BufferSize);

            encoder.CompressionLevel = GzipCompressionLevel.Fastest;
            Assert.AreEqual(GzipCompressionLevel.Fastest, encoder.CompressionLevel);

            encoder.CompressionStrategy = GzipCompressionStrategy.HuffmanOnly;
            Assert.AreEqual(GzipCompressionStrategy.HuffmanOnly, encoder.CompressionStrategy);
            encoder.CompressionStrategy = GzipCompressionStrategy.Default;              // put this back

            encoder.MemoryUsage = GzipMemoryUsageLevel.Optimal;
            Assert.AreEqual(GzipMemoryUsageLevel.Optimal, encoder.MemoryUsage);
            encoder.MemoryUsage = GzipMemoryUsageLevel.Default;                                         // put this back

            // Check all of the Encoder methods work and encode as expected
            byte[] expected, actual;
            using (MemoryStream ms = new MemoryStream())
            {
                using (var writer = new GzipWriter(ms, CompressionLevel.Fastest, true)) writer.Write(s_sampledata, 0, s_sampledata.Length);
                expected = ms.ToArray();
            }

            // Check parameter validations
            try { actual = encoder.Encode((byte[])null); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { actual = encoder.Encode((Stream)null); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { actual = encoder.Encode(null, 0, 0); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode(s_sampledata, null); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode((byte[])null, new MemoryStream()); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode((byte[])null, 0, 0, new MemoryStream()); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode(s_sampledata, 0, s_sampledata.Length, (Stream)null); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode((Stream)null, new MemoryStream()); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            try { encoder.Encode(new MemoryStream(), (Stream)null); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

            // Check actual encoding operations
            actual = encoder.Encode(s_sampledata);
            Assert.IsTrue(Enumerable.SequenceEqual(expected, actual));

            actual = encoder.Encode(new MemoryStream(s_sampledata));
            Assert.IsTrue(Enumerable.SequenceEqual(expected, actual));

            actual = encoder.Encode(s_sampledata, 0, s_sampledata.Length);
            Assert.IsTrue(Enumerable.SequenceEqual(expected, actual));

            using (MemoryStream dest = new MemoryStream())
            {
                encoder.Encode(s_sampledata, dest);
                Assert.IsTrue(Enumerable.SequenceEqual(expected, dest.ToArray()));
            }

            using (MemoryStream dest = new MemoryStream())
            {
                encoder.Encode(new MemoryStream(s_sampledata), dest);
                Assert.IsTrue(Enumerable.SequenceEqual(expected, dest.ToArray()));
            }

            using (MemoryStream dest = new MemoryStream())
            {
                encoder.Encode(s_sampledata, 0, s_sampledata.Length, dest);
                Assert.IsTrue(Enumerable.SequenceEqual(expected, dest.ToArray()));
            }
        }
예제 #7
0
        public void Gzip_Read()
        {
            byte[] buffer = new byte[8192];                     // 8KiB data buffer

            using (MemoryStream compressed = new MemoryStream())
            {
                // Start with a compressed MemoryStream created from the sample data
                using (GzipWriter compressor = new GzipWriter(compressed, CompressionLevel.Optimal, true))
                {
                    try { compressor.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(NotSupportedException)); }

                    compressor.Write(s_sampledata, 0, s_sampledata.Length);
                    compressor.Flush();
                }

                // Check the constructor for ArgumentNullException while we're here
                try { using (GzipReader decompressor = new GzipReader(null, false)) { }; Assert.Fail("Constructor should have thrown an exception"); }
                catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

                // Create a decompressor to test some of the error cases
                using (GzipReader decompressor = new GzipReader(compressed, true))
                {
                    // Send in some bum arguments to Read() to check they are caught
                    try { decompressor.Read(null, 0, 0); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentNullException)); }

                    try { decompressor.Read(buffer, -1, 0); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

                    try { decompressor.Read(buffer, 0, -1); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }

                    try { decompressor.Read(buffer, 0, buffer.Length + 1024); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentException)); }

                    // Attempting to read from the end of the compressed stream should throw an InvalidDataException
                    try { decompressor.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(InvalidDataException)); }

                    // Attempting to read from the middle of the compressed stream should throw a GzipException
                    compressed.Position = compressed.Position / 2;
                    try { decompressor.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(GzipException)); }

                    // The decompression stream is trashed at this point since the input buffer was filled
                    // with data from the middle.  Thought about a special case handler for that, but it's
                    // a fringe case.  Verify that the stream is indeed trashed ...
                    compressed.Position = 0;
                    try { decompressor.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
                    catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(GzipException)); }
                }

                // Create a new decompressor against the same stream and make sure it doesn't throw
                using (GzipReader decompressor = new GzipReader(compressed, true))
                {
                    // Reading zero bytes should not throw an exception
                    decompressor.Read(buffer, 0, 0);

                    while (decompressor.Read(buffer, 0, 8192) != 0)
                    {
                    }
                }
            }
        }
예제 #8
0
        public void Gzip_WriterDispose()
        {
            byte[] buffer = new byte[8192];                     // 8KiB data buffer

            // Create a dummy stream and immediately dispose of it
            GzipWriter stream = new GzipWriter(new MemoryStream(s_sampledata), CompressionLevel.Optimal);

            stream.Dispose();

            // Test double dispose
            stream.Dispose();

            // All properties and methods should throw an ObjectDisposedException
            try { var bs = stream.BaseStream; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { var b = stream.CanRead; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { var b = stream.CanSeek; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { var b = stream.CanWrite; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Flush(); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { var l = stream.Length; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { var l = stream.Position; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Position = 12345L; Assert.Fail("Property access should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Read(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Seek(0, SeekOrigin.Current); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.SetLength(12345L); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Write(buffer); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            try { stream.Write(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            // Ensure that an underlying stream is disposed of properly if leaveopen is not set
            MemoryStream ms = new MemoryStream(s_sampledata);

            using (GzipWriter compressor = new GzipWriter(ms, CompressionLevel.Fastest)) { }
            try { ms.Write(buffer, 0, 8192); Assert.Fail("Method call should have thrown an exception"); }
            catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ObjectDisposedException)); }

            // Ensure that an underlying stream is not disposed of if leaveopen is set
            ms = new MemoryStream(s_sampledata);
            using (GzipWriter compressor = new GzipWriter(ms, CompressionLevel.Fastest, true)) { }
            ms.Write(buffer, 0, 8192);
            ms.Dispose();
        }