public void GzipCompressedStreamIsSuccessfullyDecompressed()
{
Stream compressedStream = new MemoryStream(GZippedData);
Stream decompressedStream = _gzipDecompressor.Decompress(compressedStream);
string decodedString = Encoding.UTF8.GetString(((MemoryStream)decompressedStream).ToArray());
Assert.That(decodedString, Is.EqualTo("GzipDecompressionTest\n"));
}
public virtual void Decompress(string srcPath, string destPath)
{
using (IDecompressor dcmpr = new GZipDecompressor(srcPath, destPath))
{
dcmpr.OnCompleted += DecompressionCompleted;
dcmpr.Decompress();
}
}
public void GZipCompressorBytesExtesionWorks()
{
var compressor = new GZipCompressor();
var compressed = compressor.Compress(Encoding.UTF8.GetBytes("test"));
Assert.IsNotNull(compressed);
var decompressor = new GZipDecompressor();
var decompressed = decompressor.Decompress(compressed);
Assert.IsNotNull(decompressed);
Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed));
}
public void GZipCompressorStringExtesionWorks()
{
var compressor = new GZipCompressor();
var compressed = compressor.Compress("test");
compressed.Should().NotBeNull();
var decompressor = new GZipDecompressor();
var decompressed = decompressor.Decompress(compressed);
decompressed.Should().NotBeNull();
Encoding.UTF8.GetString(decompressed).Should().Be("test");
}
public void GZipCompressorBytesExtesionWorks()
{
var compressor = new GZipCompressor();
var compressed = compressor.Compress(Encoding.UTF8.GetBytes("test"));
Assert.IsNotNull(compressed);
var decompressor = new GZipDecompressor();
var decompressed = decompressor.Decompress(compressed);
Assert.IsNotNull(decompressed);
Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed));
}
public void TestCompliance2()
{
var path1 = TestUtil.GetTestDataDir() + "file2.gz";
var path2 = TestUtil.GetTestDataDir() + "file2";
var input = new FileStream(path1, FileMode.Open);
var output = new MemoryStream();
GZipDecompressor.Decompress(input, output);
int count;
var rawData = ReadFile(path2, out count);
var uncompressed = output.ToArray();
CollectionAssert.AreEqual(rawData.Take(count), uncompressed);
}
/// <summary>
/// Decompress the string value of a message.
/// </summary>
/// <param name="value">A string to decompress.</param>
/// <param name="encoding">
/// The encoding used to convert the string to a byte array.
/// </param>
/// <returns>The decompressed string.</returns>
public string Decompress(string value, Encoding encoding)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
var decompressor = new GZipDecompressor();
return(encoding.GetString(decompressor.Decompress(Convert.FromBase64String(value))));
}
public void TestCompliance1()
{
var path1 = TestUtil.GetTestDataDir() + "file1.gz";
var path2 = TestUtil.GetTestDataDir() + "file1";
var input = new FileStream(path1, FileMode.Open);
var output = new MemoryStream();
GZipDecompressor.Decompress(input, output);
var inputNotCompressed = new FileStream(path2, FileMode.Open);
var rawData = new byte[inputNotCompressed.Length];
var count = inputNotCompressed.Read(rawData, 0, rawData.Length);
var uncompressed = output.ToArray();
CollectionAssert.AreEqual(rawData.Take(count), uncompressed);
}
public void GZipICompressorIDecompressorWorks()
{
var compressor = new GZipCompressor();
var data = Encoding.UTF8.GetBytes("test");
byte[] compressed;
using (var inputStream = new MemoryStream(data))
{
compressed = compressor.Compress(inputStream);
}
Console.WriteLine(compressed.Length);
Assert.IsNotNull(compressed);
var decompressor = new GZipDecompressor();
byte[] decompressed;
using (var inputStream = new MemoryStream(compressed))
{
decompressed = decompressor.Decompress(inputStream);
}
Assert.IsNotNull(decompressed);
Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed));
}
public void TestSelfCompliance()
{
var path1 = TestUtil.GetTestDataDir() + "file";
var path2 = TestUtil.GetTestDataDir() + "file.gz";
var path3 = TestUtil.GetTestDataDir() + "outFile";
var stream1 = new FileStream(path1, FileMode.Open);
var stream2 = new FileStream(path2, FileMode.Create);
GZipCompressor.Compress(stream1, stream2);
stream2.Seek(0, SeekOrigin.Begin);
var stream3 = new FileStream(path3, FileMode.Create);
GZipDecompressor.Decompress(stream2, stream3);
stream1.Close();
stream2.Close();
stream3.Close();
int count1, count2;
var buffer1 = ReadFile(path1, out count1);
var buffer2 = ReadFile(path3, out count2);
CollectionAssert.AreEqual(buffer1.Take(count1), buffer2.Take(count2));
}
public void GZipICompressorIDecompressorWorks()
{
var compressor = new GZipCompressor();
var data = Encoding.UTF8.GetBytes("test");
byte[] compressed;
using (var inputStream = new MemoryStream(data))
{
compressed = compressor.Compress(inputStream);
}
Console.WriteLine(compressed.Length);
compressed.Should().NotBeNull();
var decompressor = new GZipDecompressor();
byte[] decompressed;
using (var inputStream = new MemoryStream(compressed))
{
decompressed = decompressor.Decompress(inputStream);
}
decompressed.Should().NotBeNull();
Encoding.UTF8.GetString(decompressed).Should().Be("test");
}
public void GZipICompressorIDecompressorWorks()
{
var compressor = new GZipCompressor();
var data = Encoding.UTF8.GetBytes("test");
byte[] compressed;
using (var inputStream = new MemoryStream(data))
{
compressed = compressor.Compress(inputStream);
}
Console.WriteLine(compressed.Length);
Assert.IsNotNull(compressed);
var decompressor = new GZipDecompressor();
byte[] decompressed;
using (var inputStream = new MemoryStream(compressed))
{
decompressed = decompressor.Decompress(inputStream);
}
Assert.IsNotNull(decompressed);
Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed));
}
public void TestBasicGZipRoundtrip2()
{
const string testString = "ユチエフ-8は素晴らしいです";
var data = Encoding.UTF8.GetBytes(testString);
var dataStream = new MemoryStream(data, 0, data.Length);
var encodedDataStream = new MemoryStream();
GZipCompressor.Compress(dataStream, encodedDataStream);
var encodedData = encodedDataStream.ToArray();
var decodedDataStream = new MemoryStream();
encodedDataStream.Seek(0, SeekOrigin.Begin);
GZipDecompressor.Decompress(encodedDataStream, decodedDataStream);
var decodedData = decodedDataStream.ToArray();
var resultString = Encoding.UTF8.GetString(decodedData);
Console.WriteLine("{0} {1} {2}", data.Length, encodedData.Length, decodedData.Length);
Console.WriteLine(encodedData.Aggregate("", (s, b) => s + ", " + b));
Console.WriteLine(testString);
Console.WriteLine(resultString);
Assert.AreEqual(testString, resultString);
}
private void decompress(byte[] data)
{
DataInputStream stream = new DataInputStream(data);
if (_keys != null && _keys.Length != 0)
{
stream.decodeXTEA(_keys);
}
int compression = stream.readUnsignedByte();
_compression = (CompressionType)(compression > 2 ? 2 : compression);
int compressedLength = stream.readInt();
if (compressedLength < 0 || compressedLength > 1000000)
{
throw new InvalidOperationException("INVALID ARCHIVE HEADER");
}
int length;
switch (_compression)
{
case CompressionType.RAW:
_data = new byte[compressedLength];
checkRevision(stream, compressedLength);
stream.Read(_data, 0, compressedLength);
break;
case CompressionType.BZIP:
length = stream.readInt();
if (length <= 0)
{
_data = null;
}
else
{
_data = new byte[length];
checkRevision(stream, compressedLength);
BZip2Decompressor.Decompress(_data, data);
}
break;
default: // GZIP
length = stream.readInt();
if (length <= 0 || length > 1000000000)
{
_data = null;
}
else
{
_data = new byte[length];
checkRevision(stream, compressedLength);
GZipDecompressor.Decompress(_data, stream);
}
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiverMessage"/> class.
/// </summary>
/// <param name="getRawPayload">
/// A function that returns the raw payload. Note that the <see cref="Payload"/> struct
/// is implicitly convertable from the string and byte array types (i.e. this function
/// can just return a string or byte array).
/// </param>
protected ReceiverMessage(Func <Payload> getRawPayload)
{
if (getRawPayload == null)
{
throw new ArgumentNullException(nameof(getRawPayload));
}
var rawPayload = new Lazy <object>(() => getRawPayload().Value
?? throw new InvalidOperationException("Cannot decode/decompress null payload."));
_stringPayload = new Lazy <string>(() =>
{
if (rawPayload.Value is string stringPayload)
{
if (this.IsCompressed())
{
if (this.IsBinary())
{
return(Convert.ToBase64String(_gzip.Decompress(Convert.FromBase64String(stringPayload))));
}
return(Encoding.UTF8.GetString(_gzip.Decompress(Convert.FromBase64String(stringPayload))));
}
return(stringPayload);
}
if (rawPayload.Value is byte[] binaryPayload)
{
if (this.IsCompressed())
{
binaryPayload = _gzip.Decompress(binaryPayload);
}
if (this.IsBinary())
{
return(Convert.ToBase64String(binaryPayload));
}
return(Encoding.UTF8.GetString(binaryPayload));
}
throw new InvalidOperationException($"Unknown payload type: {rawPayload.GetType().FullName}");
});
_binaryPayload = new Lazy <byte[]>(() =>
{
if (rawPayload.Value is string stringPayload)
{
if (this.IsCompressed())
{
return(_gzip.Decompress(Convert.FromBase64String(stringPayload)));
}
if (this.IsBinary())
{
return(Convert.FromBase64String(stringPayload));
}
return(Encoding.UTF8.GetBytes(stringPayload));
}
if (rawPayload.Value is byte[] binaryPayload)
{
if (this.IsCompressed())
{
return(_gzip.Decompress(binaryPayload));
}
return(binaryPayload);
}
throw new InvalidOperationException($"Unknown payload type: {rawPayload.GetType().FullName}");
});
_headers = new Lazy <HeaderDictionary>(() =>
{
var headers = new Dictionary <string, object>();
InitializeHeaders(headers);
return(new HeaderDictionary(headers));
});
}
