public void Zlib_ParallelDeflateStream() { var sw = new System.Diagnostics.Stopwatch(); sw.Start(); TestContext.WriteLine("{0}: Zlib_ParallelDeflateStream Start", sw.Elapsed); int sz = 256*1024 + this.rnd.Next(120000); string FileToCompress = System.IO.Path.Combine(TopLevelDir, String.Format("Zlib_ParallelDeflateStream.{0}.txt", sz)); CreateAndFillFileText( FileToCompress, sz); TestContext.WriteLine("{0}: Created file: {1}", sw.Elapsed, FileToCompress ); byte[] original = File.ReadAllBytes(FileToCompress); int crc1 = DoCrc(FileToCompress); TestContext.WriteLine("{0}: Original CRC: {1:X8}", sw.Elapsed, crc1 ); byte[] working = new byte[WORKING_BUFFER_SIZE]; int n = -1; long originalLength; MemoryStream ms1 = new MemoryStream(); { using (FileStream fs1 = File.OpenRead(FileToCompress)) { originalLength = fs1.Length; using (var compressor = new Alienlab.Zlib.ParallelDeflateOutputStream(ms1, true)) { while ((n = fs1.Read(working, 0, working.Length)) != 0) { compressor.Write(working, 0, n); } } } ms1.Seek(0, SeekOrigin.Begin); } TestContext.WriteLine("{0}: Compressed {1} bytes into {2} bytes", sw.Elapsed, originalLength, ms1.Length); var crc = new Alienlab.Crc.CRC32(); int crc2= 0; byte[] decompressedBytes= null; using (MemoryStream ms2 = new MemoryStream()) { using (var decompressor = new DeflateStream(ms1, CompressionMode.Decompress, false)) { while ((n = decompressor.Read(working, 0, working.Length)) != 0) { ms2.Write(working, 0, n); } } TestContext.WriteLine("{0}: Decompressed", sw.Elapsed); TestContext.WriteLine("{0}: Decompressed length: {1}", sw.Elapsed, ms2.Length); ms2.Seek(0, SeekOrigin.Begin); crc2 = crc.GetCrc32(ms2); decompressedBytes = ms2.ToArray(); TestContext.WriteLine("{0}: Decompressed CRC: {1:X8}", sw.Elapsed, crc2 ); } TestContext.WriteLine("{0}: Checking...", sw.Elapsed ); bool check = true; if (originalLength != decompressedBytes.Length) { TestContext.WriteLine("Different lengths."); check = false; } else { for (int i = 0; i < decompressedBytes.Length; i++) { if (original[i] != decompressedBytes[i]) { TestContext.WriteLine("byte {0} differs", i); check = false; break; } } } Assert.IsTrue(check,"Data check failed"); TestContext.WriteLine("{0}: Done...", sw.Elapsed ); }
public void Zlib_Streams_VariousSizes() { byte[] working = new byte[WORKING_BUFFER_SIZE]; int n = -1; Int32[] Sizes = { 8000, 88000, 188000, 388000, 580000, 1580000 }; for (int p = 0; p < Sizes.Length; p++) { // both binary and text files for (int m = 0; m < 2; m++) { int sz = this.rnd.Next(Sizes[p]) + Sizes[p]; string FileToCompress = System.IO.Path.Combine(TopLevelDir, String.Format("Zlib_Streams.{0}.{1}", sz, (m == 0) ? "txt" : "bin")); Assert.IsFalse(System.IO.File.Exists(FileToCompress), "The temporary file '{0}' already exists.", FileToCompress); TestContext.WriteLine("Creating file {0} {1} bytes", FileToCompress, sz); if (m == 0) CreateAndFillFileText(FileToCompress, sz); else _CreateAndFillBinary(FileToCompress, sz, false); int crc1 = DoCrc(FileToCompress); TestContext.WriteLine("Initial CRC: 0x{0:X8}", crc1); // try both GZipStream and DeflateStream for (int k = 0; k < 2; k++) { // compress with Alienlab.and System.IO.Compression for (int i = 0; i < 2; i++) { string CompressedFileRoot = String.Format("{0}.{1}.{2}.compressed", FileToCompress, (k == 0) ? "GZIP" : "DEFLATE", (i == 0) ? "Ionic" : "BCL"); int x = k + i * 2; int z = (x == 0) ? 4 : 1; // why 4 trials?? (only for GZIP and Alienlab. for (int h = 0; h < z; h++) { string CompressedFile = (x == 0) ? CompressedFileRoot + ".trial" + h : CompressedFileRoot; using (var input = System.IO.File.OpenRead(FileToCompress)) { using (var raw = System.IO.File.Create(CompressedFile)) { Stream compressor = null; try { switch (x) { case 0: // k == 0, i == 0 compressor = new Alienlab.Zlib.GZipStream(raw, CompressionMode.Compress, true); break; case 1: // k == 1, i == 0 compressor = new Alienlab.Zlib.DeflateStream(raw, CompressionMode.Compress, true); break; case 2: // k == 0, i == 1 compressor = new System.IO.Compression.GZipStream(raw, System.IO.Compression.CompressionMode.Compress, true); break; case 3: // k == 1, i == 1 compressor = new System.IO.Compression.DeflateStream(raw, System.IO.Compression.CompressionMode.Compress, true); break; } //TestContext.WriteLine("Compress with: {0} ..", compressor.GetType().FullName); TestContext.WriteLine("........{0} ...", System.IO.Path.GetFileName(CompressedFile)); if (x == 0) { if (h != 0) { Alienlab.Zlib.GZipStream gzip = compressor as Alienlab.Zlib.GZipStream; if (h % 2 == 1) gzip.FileName = FileToCompress; if (h > 2) gzip.Comment = "Compressing: " + FileToCompress; } } n = -1; while ((n = input.Read(working, 0, working.Length)) != 0) { compressor.Write(working, 0, n); } } finally { if (compressor != null) compressor.Dispose(); } } } // now, decompress with Alienlab.and System.IO.Compression // for (int j = 0; j < 2; j++) for (int j = 1; j >= 0; j--) { using (var input = System.IO.File.OpenRead(CompressedFile)) { Stream decompressor = null; try { int w = k + j * 2; switch (w) { case 0: // k == 0, j == 0 decompressor = new Alienlab.Zlib.GZipStream(input, CompressionMode.Decompress, true); break; case 1: // k == 1, j == 0 decompressor = new Alienlab.Zlib.DeflateStream(input, CompressionMode.Decompress, true); break; case 2: // k == 0, j == 1 decompressor = new System.IO.Compression.GZipStream(input, System.IO.Compression.CompressionMode.Decompress, true); break; case 3: // k == 1, j == 1 decompressor = new System.IO.Compression.DeflateStream(input, System.IO.Compression.CompressionMode.Decompress, true); break; } //TestContext.WriteLine("Decompress: {0} ...", decompressor.GetType().FullName); string DecompressedFile = String.Format("{0}.{1}.decompressed", CompressedFile, (j == 0) ? "Ionic" : "BCL"); TestContext.WriteLine("........{0} ...", System.IO.Path.GetFileName(DecompressedFile)); using (var s2 = System.IO.File.Create(DecompressedFile)) { n = -1; while (n != 0) { n = decompressor.Read(working, 0, working.Length); if (n > 0) s2.Write(working, 0, n); } } int crc2 = DoCrc(DecompressedFile); Assert.AreEqual<UInt32>((UInt32)crc1, (UInt32)crc2); } finally { if (decompressor != null) decompressor.Dispose(); } } } } } } } } TestContext.WriteLine("Done."); }
private void PerformTrialWi8870(byte[] buffer) { TestContext.WriteLine("Original"); byte[] compressedBytes = null; using (MemoryStream ms1 = new MemoryStream()) { using (DeflateStream compressor = new DeflateStream(ms1, CompressionMode.Compress, false)) { compressor.Write(buffer, 0, buffer.Length); } compressedBytes = ms1.ToArray(); } TestContext.WriteLine("Compressed {0} bytes into {1} bytes", buffer.Length, compressedBytes.Length); byte[] decompressed= null; using (MemoryStream ms2 = new MemoryStream()) { using (var deflateStream = new DeflateStream(ms2, CompressionMode.Decompress, false)) { deflateStream.Write(compressedBytes, 0, compressedBytes.Length); } decompressed = ms2.ToArray(); } TestContext.WriteLine("Decompressed"); bool check = true; if (buffer.Length != decompressed.Length) { TestContext.WriteLine("Different lengths."); check = false; } else { for (int i=0; i < buffer.Length; i++) { if (buffer[i] != decompressed[i]) { TestContext.WriteLine("byte {0} differs", i); check = false; break; } } } Assert.IsTrue(check,"Data check failed."); }
public void Zlib_DisposedException_DeflateStream() { string TextToCompress = LetMeDoItNow; MemoryStream ms1= new MemoryStream(); Stream compressor= new DeflateStream(ms1, CompressionMode.Compress, false); TestContext.WriteLine("Text to compress is {0} bytes: '{1}'", TextToCompress.Length, TextToCompress); TestContext.WriteLine("using compressor: {0}", compressor.GetType().FullName); StreamWriter sw = new StreamWriter(compressor, Encoding.ASCII); sw.Write(TextToCompress); sw.Close(); // implicitly closes compressor sw.Close(); // implicitly closes compressor, again compressor.Close(); // explicitly closes compressor var a = ms1.ToArray(); TestContext.WriteLine("Compressed stream is {0} bytes long", a.Length); var ms2 = new MemoryStream(a); Stream decompressor = new DeflateStream(ms2, CompressionMode.Decompress, false); TestContext.WriteLine("using decompressor: {0}", decompressor.GetType().FullName); var sr = new StreamReader(decompressor, Encoding.ASCII); string DecompressedText = sr.ReadToEnd(); sr.Close(); TestContext.WriteLine("decompressor.CanRead = {0}",decompressor.CanRead); TestContext.WriteLine("Read {0} characters: '{1}'", DecompressedText.Length, DecompressedText); TestContext.WriteLine("\n"); Assert.AreEqual<String>(TextToCompress, DecompressedText); }
public void Zlib_CloseTwice() { string TextToCompress = LetMeDoItNow; for (int i = 0; i < 3; i++) { MemoryStream ms1= new MemoryStream(); Stream compressor = null; switch (i) { case 0: compressor= new DeflateStream(ms1, CompressionMode.Compress, CompressionLevel.BestCompression, false); break; case 1: compressor = new GZipStream(ms1, CompressionMode.Compress, false); break; case 2: compressor = new ZlibStream(ms1, CompressionMode.Compress, false); break; } TestContext.WriteLine("Text to compress is {0} bytes: '{1}'", TextToCompress.Length, TextToCompress); TestContext.WriteLine("using compressor: {0}", compressor.GetType().FullName); StreamWriter sw = new StreamWriter(compressor, Encoding.ASCII); sw.Write(TextToCompress); sw.Close(); // implicitly closes compressor sw.Close();// implicitly closes compressor, again compressor.Close(); // explicitly closes compressor var a = ms1.ToArray(); TestContext.WriteLine("Compressed stream is {0} bytes long", a.Length); var ms2 = new MemoryStream(a); Stream decompressor = null; switch (i) { case 0: decompressor = new DeflateStream(ms2, CompressionMode.Decompress, false); break; case 1: decompressor = new GZipStream(ms2, CompressionMode.Decompress, false); break; case 2: decompressor = new ZlibStream(ms2, CompressionMode.Decompress, false); break; } TestContext.WriteLine("using decompressor: {0}", decompressor.GetType().FullName); var sr = new StreamReader(decompressor, Encoding.ASCII); string DecompressedText = sr.ReadToEnd(); // verify that multiple calls to Close() do not throw sr.Close(); sr.Close(); decompressor.Close(); TestContext.WriteLine("Read {0} characters: '{1}'", DecompressedText.Length, DecompressedText); TestContext.WriteLine("\n"); Assert.AreEqual<String>(TextToCompress, DecompressedText); } }
public void Zlib_DeflateStream_InMemory() { String TextToCompress = UntilHeExtends; CompressionLevel[] levels = {CompressionLevel.Level0, CompressionLevel.Level1, CompressionLevel.Default, CompressionLevel.Level7, CompressionLevel.BestCompression}; // compress with various Alienlab.levels, and System.IO.Compression (default level) for (int k= 0; k < levels.Length + 1; k++) { MemoryStream ms= new MemoryStream(); Stream compressor = null; if (k == levels.Length) compressor = new System.IO.Compression.DeflateStream(ms, System.IO.Compression.CompressionMode.Compress, false); else { compressor = new Alienlab.Zlib.DeflateStream(ms, CompressionMode.Compress, levels[k], false); TestContext.WriteLine("using level: {0}", levels[k].ToString()); } TestContext.WriteLine("Text to compress is {0} bytes: '{1}'", TextToCompress.Length, TextToCompress); TestContext.WriteLine("using compressor: {0}", compressor.GetType().FullName); StreamWriter sw = new StreamWriter(compressor, Encoding.ASCII); sw.Write(TextToCompress); sw.Close(); var a = ms.ToArray(); TestContext.WriteLine("Compressed stream is {0} bytes long", a.Length); // de-compress with both Alienlab.and System.IO.Compression for (int j = 0; j < 2; j++) { var slow = new MySlowMemoryStream(a); // want to force EOF Stream decompressor = null; switch (j) { case 0: decompressor = new Alienlab.Zlib.DeflateStream(slow, CompressionMode.Decompress, false); break; case 1: decompressor = new System.IO.Compression.DeflateStream(slow, System.IO.Compression.CompressionMode.Decompress, false); break; } TestContext.WriteLine("using decompressor: {0}", decompressor.GetType().FullName); var sr = new StreamReader(decompressor, Encoding.ASCII); string DecompressedText = sr.ReadToEnd(); TestContext.WriteLine("Read {0} characters: '{1}'", DecompressedText.Length, DecompressedText); TestContext.WriteLine("\n"); Assert.AreEqual<String>(TextToCompress, DecompressedText); } } }
/// <summary> /// Uncompress a DEFLATE'd byte array into a byte array. /// </summary> /// /// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso> /// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso> /// <seealso cref="GZipStream.UncompressBuffer(byte[])">GZipStream.UncompressBuffer(byte[])</seealso> /// <seealso cref="ZlibStream.UncompressBuffer(byte[])">ZlibStream.UncompressBuffer(byte[])</seealso> /// /// <param name="compressed"> /// A buffer containing data that has been compressed with DEFLATE. /// </param> /// /// <returns>The data in uncompressed form</returns> public static byte[] UncompressBuffer(byte[] compressed) { using (var input = new System.IO.MemoryStream(compressed)) { System.IO.Stream decompressor = new DeflateStream( input, CompressionMode.Decompress ); return ZlibBaseStream.UncompressBuffer(compressed, decompressor); } }
/// <summary> /// Compress a byte array into a new byte array using DEFLATE. /// </summary> /// /// <remarks> /// Uncompress it with <see cref="DeflateStream.UncompressBuffer(byte[])"/>. /// </remarks> /// /// <seealso cref="DeflateStream.CompressString(string)">DeflateStream.CompressString(string)</seealso> /// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso> /// <seealso cref="GZipStream.CompressBuffer(byte[])">GZipStream.CompressBuffer(byte[])</seealso> /// <seealso cref="ZlibStream.CompressBuffer(byte[])">ZlibStream.CompressBuffer(byte[])</seealso> /// /// <param name="b"> /// A buffer to compress. /// </param> /// /// <returns>The data in compressed form</returns> public static byte[] CompressBuffer(byte[] b) { using (var ms = new System.IO.MemoryStream()) { System.IO.Stream compressor = new DeflateStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression ); ZlibBaseStream.CompressBuffer(b, compressor); return ms.ToArray(); } }