private byte[] InflateBuffer(byte[] b, int length)
{
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
ZlibCodec decompressor = new ZlibCodec();
byte[] DecompressedBytes = new byte[length];
TestContext.WriteLine("\n============================================");
TestContext.WriteLine("Size of Buffer to Inflate: {0} bytes.", b.Length);
MemoryStream ms = new MemoryStream(DecompressedBytes);
int rc = decompressor.InitializeInflate();
decompressor.InputBuffer = b;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = b.Length;
decompressor.OutputBuffer = buffer;
for (int pass = 0; pass < 2; pass++)
{
FlushType flush = (pass==0)
? FlushType.None
: FlushType.Finish;
do
{
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = buffer.Length;
rc = decompressor.Inflate(flush);
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new Exception("inflating: " + decompressor.Message);
if (buffer.Length - decompressor.AvailableBytesOut > 0)
ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
}
while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
}
decompressor.EndInflate();
TestContext.WriteLine("TBO({0}).", decompressor.TotalBytesOut);
return DecompressedBytes;
}
public void Zlib_Codec_TestLargeDeflateInflate()
{
int rc;
int j;
int bufferSize = 80000;
byte[] compressedBytes = new byte[bufferSize];
byte[] workBuffer = new byte[bufferSize / 4];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.Level1);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message));
compressingStream.OutputBuffer = compressedBytes;
compressingStream.AvailableBytesOut = compressedBytes.Length;
compressingStream.NextOut = 0;
System.Random rnd = new Random();
for (int k = 0; k < 4; k++)
{
switch (k)
{
case 0:
// At this point, workBuffer is all zeroes, so it should compress very well.
break;
case 1:
// switch to no compression, keep same workBuffer (all zeroes):
compressingStream.SetDeflateParams(CompressionLevel.None, CompressionStrategy.Default);
break;
case 2:
// Insert data into workBuffer, and switch back to compressing mode.
// we'll use lengths of the same random byte:
for (int i = 0; i < workBuffer.Length / 1000; i++)
{
byte b = (byte)rnd.Next();
int n = 500 + rnd.Next(500);
for (j = 0; j < n; j++)
workBuffer[j + i] = b;
i += j - 1;
}
compressingStream.SetDeflateParams(CompressionLevel.BestCompression, CompressionStrategy.Filtered);
break;
case 3:
// insert totally random data into the workBuffer
rnd.NextBytes(workBuffer);
break;
}
compressingStream.InputBuffer = workBuffer;
compressingStream.NextIn = 0;
compressingStream.AvailableBytesIn = workBuffer.Length;
rc = compressingStream.Deflate(FlushType.None);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate({0}) [{1}]", k, compressingStream.Message));
if (k == 0)
Assert.AreEqual<int>(0, compressingStream.AvailableBytesIn, "Deflate should be greedy.");
TestContext.WriteLine("Stage {0}: uncompressed/compresssed bytes so far: ({1,6}/{2,6})",
k, compressingStream.TotalBytesIn, compressingStream.TotalBytesOut);
}
rc = compressingStream.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressingStream.Message));
rc = compressingStream.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message));
TestContext.WriteLine("Final: uncompressed/compressed bytes: ({0,6},{1,6})",
compressingStream.TotalBytesIn, compressingStream.TotalBytesOut);
ZlibCodec decompressingStream = new ZlibCodec(CompressionMode.Decompress);
decompressingStream.InputBuffer = compressedBytes;
decompressingStream.NextIn = 0;
decompressingStream.AvailableBytesIn = bufferSize;
// upon inflating, we overwrite the decompressedBytes buffer repeatedly
int nCycles = 0;
while (true)
{
decompressingStream.OutputBuffer = workBuffer;
decompressingStream.NextOut = 0;
decompressingStream.AvailableBytesOut = workBuffer.Length;
rc = decompressingStream.Inflate(FlushType.None);
nCycles++;
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}] TotalBytesOut={1}",
decompressingStream.Message, decompressingStream.TotalBytesOut));
}
rc = decompressingStream.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message));
Assert.AreEqual<int>(4 * workBuffer.Length, (int)decompressingStream.TotalBytesOut);
TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
TestContext.WriteLine("decompressed length (expected): {0}", 4 * workBuffer.Length);
TestContext.WriteLine("decompressed length (actual) : {0}", decompressingStream.TotalBytesOut);
TestContext.WriteLine("decompression cycles: {0}", nCycles);
}
public void Zlib_BasicDictionaryDeflateInflate()
{
int rc;
int comprLen = 40000;
int uncomprLen = comprLen;
byte[] uncompr = new byte[uncomprLen];
byte[] compr = new byte[comprLen];
//long dictId;
ZlibCodec compressor = new ZlibCodec();
rc = compressor.InitializeDeflate(CompressionLevel.BestCompression);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressor.Message));
string dictionaryWord = "hello ";
byte[] dictionary = System.Text.ASCIIEncoding.ASCII.GetBytes(dictionaryWord);
string TextToCompress = "hello, hello! How are you, Joe? I said hello. ";
byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
rc = compressor.SetDictionary(dictionary);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at SetDeflateDictionary() [{0}]", compressor.Message));
int dictId = compressor.Adler32;
compressor.OutputBuffer = compr;
compressor.NextOut = 0;
compressor.AvailableBytesOut = comprLen;
compressor.InputBuffer = BytesToCompress;
compressor.NextIn = 0;
compressor.AvailableBytesIn = BytesToCompress.Length;
rc = compressor.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message));
rc = compressor.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressor.Message));
ZlibCodec decompressor = new ZlibCodec();
decompressor.InputBuffer = compr;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = comprLen;
rc = decompressor.InitializeInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressor.Message));
decompressor.OutputBuffer = uncompr;
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = uncomprLen;
while (true)
{
rc = decompressor.Inflate(FlushType.None);
if (rc == ZlibConstants.Z_STREAM_END)
{
break;
}
if (rc == ZlibConstants.Z_NEED_DICT)
{
Assert.AreEqual<long>(dictId, decompressor.Adler32, "Unexpected Dictionary");
rc = decompressor.SetDictionary(dictionary);
}
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate/SetInflateDictionary() [{0}]", decompressor.Message));
}
rc = decompressor.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message));
int j = 0;
for (; j < uncompr.Length; j++)
if (uncompr[j] == 0)
break;
Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths"));
int i = 0;
for (i = 0; i < j; i++)
if (TextToCompress[i] != uncompr[i])
break;
Assert.AreEqual<int>(j, i, String.Format("Non-identical content"));
var result = System.Text.ASCIIEncoding.ASCII.GetString(uncompr, 0, j);
TestContext.WriteLine("orig length: {0}", TextToCompress.Length);
TestContext.WriteLine("compressed length: {0}", compressor.TotalBytesOut);
TestContext.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut);
TestContext.WriteLine("result length: {0}", result.Length);
TestContext.WriteLine("result of inflate:\n{0}", result);
}
public void Zlib_TestFlushSync()
{
int rc;
int bufferSize = 40000;
byte[] CompressedBytes = new byte[bufferSize];
byte[] DecompressedBytes = new byte[bufferSize];
string TextToCompress = "This is the text that will be compressed.";
byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
ZlibCodec compressor = new ZlibCodec(CompressionMode.Compress);
compressor.InputBuffer = BytesToCompress;
compressor.NextIn = 0;
compressor.AvailableBytesIn = 3;
compressor.OutputBuffer = CompressedBytes;
compressor.NextOut = 0;
compressor.AvailableBytesOut = CompressedBytes.Length;
rc = compressor.Deflate(FlushType.Full);
CompressedBytes[3]++; // force an error in first compressed block // dinoch - ??
compressor.AvailableBytesIn = TextToCompress.Length - 3;
rc = compressor.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message));
rc = compressor.EndDeflate();
bufferSize = (int)(compressor.TotalBytesOut);
ZlibCodec decompressor = new ZlibCodec(CompressionMode.Decompress);
decompressor.InputBuffer = CompressedBytes;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = 2;
decompressor.OutputBuffer = DecompressedBytes;
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = DecompressedBytes.Length;
rc = decompressor.Inflate(FlushType.None);
decompressor.AvailableBytesIn = bufferSize - 2;
rc = decompressor.SyncInflate();
bool gotException = false;
try
{
rc = decompressor.Inflate(FlushType.Finish);
}
catch (ZlibException ex1)
{
TestContext.WriteLine("Got Expected Exception: " + ex1);
gotException = true;
}
Assert.IsTrue(gotException, "inflate should report DATA_ERROR");
rc = decompressor.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message));
int j = 0;
for (; j < DecompressedBytes.Length; j++)
if (DecompressedBytes[j] == 0)
break;
var result = System.Text.ASCIIEncoding.ASCII.GetString(DecompressedBytes, 0, j);
Assert.AreEqual<int>(TextToCompress.Length, result.Length + 3, "Strings are unequal lengths");
Console.WriteLine("orig length: {0}", TextToCompress.Length);
Console.WriteLine("compressed length: {0}", compressor.TotalBytesOut);
Console.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut);
Console.WriteLine("result length: {0}", result.Length);
Console.WriteLine("result of inflate:\n(Thi){0}", result);
}
public void Zlib_BasicDeflateAndInflate()
{
string TextToCompress = LoremIpsum;
int rc;
int bufferSize = 40000;
byte[] compressedBytes = new byte[bufferSize];
byte[] decompressedBytes = new byte[bufferSize];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.Default);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message));
compressingStream.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
compressingStream.NextIn = 0;
compressingStream.OutputBuffer = compressedBytes;
compressingStream.NextOut = 0;
while (compressingStream.TotalBytesIn != TextToCompress.Length && compressingStream.TotalBytesOut < bufferSize)
{
compressingStream.AvailableBytesIn = compressingStream.AvailableBytesOut = 1; // force small buffers
rc = compressingStream.Deflate(FlushType.None);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(1) [{0}]", compressingStream.Message));
}
while (true)
{
compressingStream.AvailableBytesOut = 1;
rc = compressingStream.Deflate(FlushType.Finish);
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(2) [{0}]", compressingStream.Message));
}
rc = compressingStream.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message));
ZlibCodec decompressingStream = new ZlibCodec();
decompressingStream.InputBuffer = compressedBytes;
decompressingStream.NextIn = 0;
decompressingStream.OutputBuffer = decompressedBytes;
decompressingStream.NextOut = 0;
rc = decompressingStream.InitializeInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflateInit");
while (decompressingStream.TotalBytesOut < decompressedBytes.Length && decompressingStream.TotalBytesIn < bufferSize)
{
decompressingStream.AvailableBytesIn = decompressingStream.AvailableBytesOut = 1; /* force small buffers */
rc = decompressingStream.Inflate(FlushType.None);
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflate");
}
rc = decompressingStream.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflateEnd");
int j = 0;
for (; j < decompressedBytes.Length; j++)
if (decompressedBytes[j] == 0)
break;
Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths"));
int i = 0;
for (i = 0; i < j; i++)
if (TextToCompress[i] != decompressedBytes[i])
break;
Assert.AreEqual<int>(j, i, String.Format("Non-identical content"));
var result = System.Text.ASCIIEncoding.ASCII.GetString(decompressedBytes, 0, j);
TestContext.WriteLine("orig length: {0}", TextToCompress.Length);
TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
TestContext.WriteLine("decompressed length: {0}", decompressingStream.TotalBytesOut);
TestContext.WriteLine("result length: {0}", result.Length);
TestContext.WriteLine("result of inflate:\n{0}", result);
return;
}
