public async Task Decompress(CompressionType type)
{
string testFilePath = CreateCompressedFile(type);
int _bufferSize = 1024;
var bytes = new byte[_bufferSize];
using (MemoryStream gzStream = await LocalMemoryStream.readAppFileAsync(testFilePath))
using (MemoryStream strippedMs = StripHeaderAndFooter.Strip(gzStream))
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
for (int i = 0; i < Benchmark.InnerIterationCount; i++)
{
int retCount = -1;
using (DeflateStream zip = new DeflateStream(strippedMs, CompressionMode.Decompress, leaveOpen: true))
{
while (retCount != 0)
{
retCount = zip.Read(bytes, 0, _bufferSize);
}
}
strippedMs.Seek(0, SeekOrigin.Begin);
}
}
File.Delete(testFilePath);
}
public bool WriteHit = false; // methods of the underlying stream. This bool acts as a toggle to check that they're being used.
public static async Task <ManualSyncMemoryStream> GetStreamFromFileAsync(string testFile, bool sync = false, bool strip = false)
{
var baseStream = await StreamHelpers.CreateTempCopyStream(testFile);
if (strip)
{
baseStream = StripHeaderAndFooter.Strip(baseStream);
}
var ms = new ManualSyncMemoryStream(sync);
await baseStream.CopyToAsync(ms);
ms.Position = 0;
return(ms);
}
public async Task ModifyBaseStream()
{
var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
var newMs = StripHeaderAndFooter.Strip(ms);
var zip = new DeflateStream(newMs, CompressionMode.Decompress);
int size = 1024;
byte[] bytes = new byte[size];
zip.BaseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writable as expected
zip.BaseStream.Position = 0;
await zip.BaseStream.ReadAsync(bytes, 0, size);
}
public async Task CanReadBaseStreamAfterDispose()
{
var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
var newMs = StripHeaderAndFooter.Strip(ms);
var zip = new DeflateStream(newMs, CompressionMode.Decompress, true);
var baseStream = zip.BaseStream;
zip.Dispose();
int size = 1024;
Byte[] bytes = new Byte[size];
baseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writeable as expected
baseStream.Position = 0;
await baseStream.ReadAsync(bytes, 0, size);
}
// Making this async since regular read/write are tested below
private async Task DecompressAsync(MemoryStream compareStream, MemoryStream gzStream)
{
var sourceStream = StripHeaders ? StripHeaderAndFooter.Strip(gzStream) : gzStream;
var ms = new MemoryStream();
var zip = CreateStream(sourceStream, CompressionMode.Decompress);
var Stream = new MemoryStream();
int _bufferSize = 1024;
var bytes = new byte[_bufferSize];
bool finished = false;
int retCount;
while (!finished)
{
retCount = await ReadAsync(zip, bytes, 0, _bufferSize);
if (retCount != 0)
{
await Stream.WriteAsync(bytes, 0, retCount);
}
else
{
finished = true;
}
}
Stream.Position = 0;
compareStream.Position = 0;
byte[] compareArray = compareStream.ToArray();
byte[] writtenArray = Stream.ToArray();
Assert.Equal(compareArray.Length, writtenArray.Length);
for (int i = 0; i < compareArray.Length; i++)
{
Assert.Equal(compareArray[i], writtenArray[i]);
}
}
