public static void DeflateParallelStream_Decompress_EqualsSourceData(CompressionLevel compressionLevel)
{
byte[] compressedData;
byte[] decompressedData;
using (var compressed = new MemoryStream())
{
using (var compressStream = new DeflateParallelStream(compressed, compressionLevel, 32 * 1024, leaveOpen: true))
{
foreach (var data in DataList)
{
compressStream.Write(data, 0, data.Length);
}
}
compressedData = compressed.ToArray();
compressed.Seek(0, SeekOrigin.Begin);
using (var decompressStream = new DeflateParallelStream(compressed, CompressionMode.Decompress, leaveOpen: true))
{
using (var decompressed = new MemoryStream())
{
decompressStream.CopyTo(decompressed, bufferSize: 32 * 1024);
decompressedData = decompressed.ToArray();
}
}
}
Assert.True(DataListFlat.SequenceEqual(decompressedData));
}
public static void DeflateParallelStream_Compress_NoOperation_StreamUntouched()
{
using (var stream = new MemoryStream())
{
using (var compressStream = new DeflateParallelStream(stream, CompressionMode.Compress, leaveOpen: true))
{
// No Operation
}
Assert.Equal(0, stream.Position);
Assert.Equal(0, stream.Length);
}
}
public static void DeflateParallelStream_Compress_SizeIncreases()
{
byte[] compressedData;
using (var compressed = new MemoryStream())
{
using (var compressStream = new DeflateParallelStream(compressed, CompressionLevel.NoCompression, 32 * 1024, leaveOpen: true))
{
foreach (var data in DataList)
{
compressStream.Write(data, 0, data.Length);
}
}
compressedData = compressed.ToArray();
}
Console.WriteLine($"Source size = {DataListSize} -> Compressed size = {compressedData.Length} (NoCompression)");
Assert.True(compressedData.Length > DataListSize);
}
public static void DeflateParallelStream_Decompress_NoOperation_StreamUntouched()
{
using (var stream = new MemoryStream())
{
using (var compressStream = new DeflateParallelStream(stream, CompressionMode.Compress, leaveOpen: true))
{
var data = GenerateData(1024, 1024);
compressStream.Write(data, 0, data.Length);
}
stream.Seek(0, SeekOrigin.Begin);
using (var decompressSTream = new DeflateParallelStream(stream, CompressionMode.Decompress, leaveOpen: true))
{
// No Operation
}
Assert.Equal(0, stream.Position);
}
}
public static void DeflateParallelStream_Decompress_ArgumentValidation()
{
DeflateParallelStream stream;
using (stream = new DeflateParallelStream(new MemoryStream(), CompressionMode.Decompress))
{
Assert.Throws <ArgumentNullException>(() => stream.Read(buffer: null, offset: 0, count: 0));
Assert.Throws <ArgumentOutOfRangeException>(() => stream.Read(buffer: new byte[0], offset: -1, count: 0));
Assert.Throws <ArgumentOutOfRangeException>(() => stream.Read(buffer: new byte[0], offset: 0, count: -1));
Assert.Throws <ArgumentException>(() => stream.Read(buffer: new byte[0], offset: 0, count: 1));
Assert.Throws <InvalidOperationException>(() => stream.Write(new byte[0], 0, 0));
Assert.Throws <NotSupportedException>(() => stream.Length);
Assert.Throws <NotSupportedException>(() => stream.Position);
Assert.Throws <NotSupportedException>(() => stream.Position = 0);
Assert.Throws <NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin));
Assert.Throws <NotSupportedException>(() => stream.SetLength(0));
}
Assert.Throws <ObjectDisposedException>(() => stream.Read(new byte[0], 0, 0));
Assert.Throws <ObjectDisposedException>(() => stream.Flush());
}
