public void Compressor_CanCompressIonic()
{
ICompressor compressor = new GZipCompressor();
string archive = compressor.Compress(TestFilePath);
Assert.IsTrue(File.Exists(archive));
}
public void CompressionTest()
{
AutoResetEvent waitHandle = new AutoResetEvent(false);
compressor = new GZipCompressor(waitHandle);
//startFileName = @"video.avi";
string decompressedFileName = @"Decompressed_" + startFileName;
compressor.OnCompressionComplete += compressor_OnCompressionComplete;
compressor.Compress(startFileName, endFileName);
waitHandle.WaitOne();
string startFileHash = "";
string decompressedFileHash = "";
MD5 md5hash = MD5.Create();
compressor.Decompress(endFileName, decompressedFileName);
waitHandle.WaitOne();
using (Stream startFileStream = File.OpenRead(startFileName))
using (Stream decompressedFIleStream = File.OpenRead(decompressedFileName))
{
startFileHash = Encoding.Default.GetString(md5hash.ComputeHash(startFileStream));
decompressedFileHash = Encoding.Default.GetString(md5hash.ComputeHash(decompressedFIleStream));
}
Assert.AreEqual(startFileHash, decompressedFileHash);
}
public void Compressor_CanCompressIonic()
{
ICompressor compressor = new GZipCompressor();
string archive = compressor.Compress(TestFilePath);
Assert.IsTrue(File.Exists(archive));
}
public virtual void Compress(string srcPath, string destPath)
{
using (ICompressor cmpr = new GZipCompressor(srcPath, destPath))
{
cmpr.OnCompleted += CompressionCompleted;
cmpr.Compress();
}
}
public void Compressor_CanDecompressIonic()
{
ICompressor compressor = new GZipCompressor();
string file = compressor.Decompress(compressor.Compress(TestFilePath));
Assert.IsTrue(File.Exists(file));
Assert.AreEqual(TestFilePath, file);
}
public void Compressor_CanDecompressIonic()
{
ICompressor compressor = new GZipCompressor();
string file = compressor.Decompress(compressor.Compress(TestFilePath));
Assert.IsTrue(File.Exists(file));
Assert.AreEqual(TestFilePath, file);
}
public void TestCompress_NullBytes()
{
GZipCompressor c = new GZipCompressor();
byte[] compressed = c.Compress(null);
Assert.IsNotNull(compressed);
Assert.AreEqual(0, compressed.Length);
}
public void TestCompressDecompressEmptyByteArray()
{
ICompressor compressor = new GZipCompressor();
var originalBytes = new byte[0];
var compressedBytes = compressor.Compress(originalBytes);
var decompressedBytes = compressor.Decompress(compressedBytes);
CollectionAssert.AreEqual(originalBytes, decompressedBytes);
}
public void TestCompressDecompressSomeByteArray()
{
ICompressor compressor = new GZipCompressor();
var originalBytes = Encoding.UTF8.GetBytes("Hello, World!");
var compressedBytes = compressor.Compress(originalBytes);
var decompressedBytes = compressor.Decompress(compressedBytes);
CollectionAssert.AreEqual(originalBytes, decompressedBytes);
}
public void CompressTest()
{
GZipCompressor target = new GZipCompressor(); // TODO: Initialize to an appropriate value
UTF8Encoding encoding = new UTF8Encoding();
byte[] content = encoding.GetBytes("abc@123"); // TODO: Initialize to an appropriate value
Stream requestStream = new MemoryStream(); // TODO: Initialize to an appropriate value
target.Compress(content, requestStream);
Assert.IsNotNull(requestStream);
}
public void TestDecompress_CompressedBytes()
{
GZipCompressor c = new GZipCompressor();
string str = "Hello";
byte[] strBytes = System.Text.Encoding.UTF8.GetBytes(str);
byte[] compressed = c.Compress(strBytes);
byte[] decompressed = c.Decompress(compressed);
string strDecompressed = System.Text.Encoding.Default.GetString(decompressed);
Assert.AreEqual(str, strDecompressed);
}
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 MustPerformCorrectly()
{
var data = Encoding.UTF8.GetBytes(String.Join(" ", Enumerable.Repeat("A comparatively easy text to compress.", 100)));
var compressed = sut.Compress(new MemoryStream(data));
compressed.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(ID1, compressed.ReadByte());
Assert.AreEqual(ID2, compressed.ReadByte());
Assert.AreEqual(CM, compressed.ReadByte());
Assert.IsTrue(compressed.Length < data.Length);
var decompressed = sut.Decompress(compressed);
decompressed.Seek(0, SeekOrigin.Begin);
foreach (var item in data)
{
Assert.AreEqual(item, decompressed.ReadByte());
}
Assert.IsTrue(decompressed.Length == data.Length);
}
public void TestCompressSeveralChunks()
{
var originalByteChunks = new List <byte[]>(3)
{
Encoding.UTF8.GetBytes("High-Speed Recovery"),
Encoding.UTF8.GetBytes("Verified Recoverability"),
Encoding.UTF8.GetBytes("Complete Visibility")
};
var compressor = new GZipCompressor();
var inputHolder = new FileChunkHolder();
var outputHolder = new FileChunkHolder();
inputHolder.Add(0, originalByteChunks[0]);
inputHolder.Add(1, originalByteChunks[1]);
inputHolder.Add(2, originalByteChunks[2]);
Assert.AreEqual(originalByteChunks.Count, inputHolder.Count());
Assert.AreEqual(0, outputHolder.Count());
var commands = new List <ICommand>(3)
{
new CompressChunkCommand(0, inputHolder, outputHolder, compressor),
new CompressChunkCommand(1, inputHolder, outputHolder, compressor),
new CompressChunkCommand(2, inputHolder, outputHolder, compressor)
};
foreach (var command in commands)
{
command.Execute();
}
Assert.AreEqual(0, inputHolder.Count());
Assert.AreEqual(originalByteChunks.Count, outputHolder.Count());
CollectionAssert.AreEqual(compressor.Compress(originalByteChunks[0]), outputHolder.Get(0));
CollectionAssert.AreEqual(compressor.Compress(originalByteChunks[1]), outputHolder.Get(1));
CollectionAssert.AreEqual(compressor.Compress(originalByteChunks[2]), outputHolder.Get(2));
}
/// <summary>
/// Compress the byte array value of a message.
/// </summary>
/// <param name="value">A byte array to compress.</param>
/// <param name="encoding">
/// The encoding used to convert the string to a byte array.
/// </param>
/// <returns>The compressed byte array.</returns>
public byte[] Compress(byte[] value, Encoding encoding)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
var compressor = new GZipCompressor();
return(encoding.GetBytes(Convert.ToBase64String(compressor.Compress(value))));
}
public void GZipStream_Compressor_2()
{
byte[] input = Encoding.UTF8.GetBytes("ABCDEF");
// Compress first,
// 1F-8B-08-00-00-00-00-00-00-0A-73-74-72-76-71-75-03-00-69-FE-76-BB-06-00-00-00
byte[] compBytes = GZipCompressor.Compress(input);
// then Decompress
byte[] decompBytes = GZipCompressor.Decompress(compBytes);
// Comprare SHA256 Digest
byte[] inputDigest = TestSetup.SHA256Digest(input);
byte[] decompDigest = TestSetup.SHA256Digest(decompBytes);
Assert.IsTrue(decompDigest.SequenceEqual(inputDigest));
}
public void TestExecuteCompressionTaskOnWholeFile()
{
var inputFile = new FileInfo("input.txt");
var outputFile = new FileInfo("input.txt.gz");
File.Delete(outputFile.Name);
var inputHolder = new FileChunkHolder();
var outputHolder = new FileChunkHolder();
var compressor = new GZipCompressor();
var task = new CompressionTask(0, inputHolder, outputHolder, compressor,
inputFile.Name, 0, (int)inputFile.Length, outputFile.Name);
task.Start();
Assert.AreEqual(0, inputHolder.Count());
Assert.AreEqual(0, outputHolder.Count());
CollectionAssert.AreEqual(compressor.Compress(File.ReadAllBytes(inputFile.Name)), File.ReadAllBytes(outputFile.Name));
}
public void TestCompressOneChunk()
{
var originalBytes = Encoding.UTF8.GetBytes("AVAILABILITY for the Always-On Enterprise");
var compressor = new GZipCompressor();
var inputHolder = new FileChunkHolder();
var outputHolder = new FileChunkHolder();
inputHolder.Add(0, originalBytes);
Assert.AreEqual(1, inputHolder.Count());
Assert.AreEqual(0, outputHolder.Count());
var command = new CompressChunkCommand(0, inputHolder, outputHolder, compressor);
command.Execute();
Assert.AreEqual(0, inputHolder.Count());
Assert.AreEqual(1, outputHolder.Count());
CollectionAssert.AreEqual(compressor.Compress(originalBytes), outputHolder.Get(0));
}
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);
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 LZ4_Read_Write_Faster_Than_GZip()
{
var gzipCompressor = new GZipCompressor();
var lz4Compressor = new LZ4Compressor();
double gzipSeconds = 0;
double lz4Seconds = 0;
Stopwatch watch = new Stopwatch();
watch.Start();
for (int i = 0; i < 1000; i++)
{
byte[] data = TestHelper.GetRandomByteArray(10);
byte[] compressed = gzipCompressor.Compress(data);
byte[] deflated = gzipCompressor.Decompress(compressed);
Assert.IsTrue(data.SequenceEqual(deflated));
}
watch.Stop();
gzipSeconds = watch.Elapsed.TotalSeconds;
watch = new Stopwatch();
watch.Start();
for (int i = 0; i < 1000; i++)
{
byte[] data = TestHelper.GetRandomByteArray(10);
byte[] compressed = lz4Compressor.Compress(data);
byte[] deflated = lz4Compressor.Decompress(compressed);
Assert.IsTrue(data.SequenceEqual(deflated));
}
watch.Stop();
lz4Seconds = watch.Elapsed.TotalSeconds;
Assert.IsTrue(lz4Seconds < gzipSeconds);
}
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 GZipStream_Compressor_1()
{
void Template(string fileName, ZLibCompLevel level)
{
string filePath = Path.Combine(TestSetup.SampleDir, fileName);
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (MemoryStream compMs = GZipCompressor.Compress(fs))
using (MemoryStream decompMs = GZipCompressor.Decompress(compMs))
{
// Compare SHA256 Digest
fs.Position = 0;
byte[] fileDigest = TestSetup.SHA256Digest(fs);
byte[] decompDigest = TestSetup.SHA256Digest(decompMs);
Assert.IsTrue(decompDigest.SequenceEqual(fileDigest));
}
}
Template("ex1.jpg", ZLibCompLevel.Default);
Template("ex2.jpg", ZLibCompLevel.BestCompression);
Template("ex3.jpg", ZLibCompLevel.BestSpeed);
}
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);
}
public void Decompress()
{
var TestObject = new GZipCompressor();
string Data = "This is a bit of data that I want to compress";
Assert.Equal("This is a bit of data that I want to compress", TestObject.Decompress(TestObject.Compress(Data.ToByteArray())).ToString(null));
}
public void Compress()
{
var TestObject = new GZipCompressor();
string Data = "This is a bit of data that I want to compress";
Assert.Equal("H4sIAAAAAAAACwrJyCxWAKJEhaTMEoX8NIWUxJJEhZKMxBIFT4XyxLwShZJ8heT83IKi1OJiAAAAAP//", Convert.ToBase64String(TestObject.Compress(Data.ToByteArray())));
}
