public void DecodeFromSlowStream()
{
var original = Tools.FindFile($"corpus/reymont");
var encoded = Path.GetTempFileName();
try
{
ReferenceLZ4.Encode("-1 -BD -B4", original, encoded);
var origStream = File.OpenRead(encoded);
// We need this to work even if the stream gives us only a single byte at a time
var slowStream = new FakeNetworkStream(origStream);
using (var input = LZ4Stream.Decode(slowStream, LZ4MemoryHelper.M1))
{
var buffer = new byte[0x80000];
Assert.Equal(5000, input.Read(buffer, 0, 5000));
Assert.Equal(0x10000 - 5000, input.Read(buffer, 0, 0x10000));
}
}
finally
{
File.Delete(encoded);
}
}
public void IndependentBlockDecoder(string filename, string options)
{
var original = Tools.FindFile($"corpus/{filename}");
var encoded = Path.GetTempFileName();
var decoded = Path.GetTempFileName();
try
{
ReferenceLZ4.Encode(options, original, encoded);
using (var decoder = new LZ4DecoderStream(
File.OpenRead(encoded),
fi => new LZ4BlockDecoder(fi.BlockSize)))
using (var writer = File.OpenWrite(decoded))
{
decoder.CopyTo(writer);
}
Tools.SameFiles(original, decoded);
}
finally
{
File.Delete(encoded);
File.Delete(decoded);
}
}
private static void TestDecoder(string original, string options, int chunkSize)
{
original = Tools.FindFile(original);
var encoded = Path.GetTempFileName();
var decoded = Path.GetTempFileName();
try
{
ReferenceLZ4.Encode(options, original, encoded);
TestedLZ4.Decode(encoded, decoded, chunkSize);
Tools.SameFiles(original, decoded);
}
finally
{
File.Delete(encoded);
File.Delete(decoded);
}
}
private static void TestEncoder(string original, int chunkSize, LZ4Settings settings)
{
original = Tools.FindFile(original);
var encoded = Path.GetTempFileName();
var decoded = Path.GetTempFileName();
try
{
TestedLZ4.Encode(original, encoded, chunkSize, settings);
ReferenceLZ4.Decode(encoded, decoded);
Tools.SameFiles(original, decoded);
}
finally
{
File.Delete(encoded);
File.Delete(decoded);
}
}
public void InteractiveReadingReturnsBytesAsSoonAsTheyAreAvailable()
{
var original = Tools.FindFile($"corpus/reymont");
var encoded = Path.GetTempFileName();
try
{
ReferenceLZ4.Encode("-1 -BD -B4", original, encoded);
using (var input = LZ4Stream.Decode(File.OpenRead(encoded), LZ4MemoryHelper.M1))
{
var buffer = new byte[0x80000];
Assert.Equal(5000, input.Read(buffer, 0, 5000));
Assert.Equal(0x10000 - 5000, input.Read(buffer, 0, 0x10000));
}
}
finally
{
File.Delete(encoded);
}
}
public void LengthAndPositionInStream(string filename, string options, int chunkSize)
{
var original = Tools.FindFile($"corpus/{filename}");
var expectedLength = new FileInfo(original).Length;
var expectedPosition = 0L;
var encoded = Path.GetTempFileName();
try
{
ReferenceLZ4.Encode(options, original, encoded);
using (var stream = LZ4Stream.Decode(File.OpenRead(encoded)))
{
var random = new Random(0);
Assert.Equal(expectedLength, stream.Length);
var buffer = new byte[chunkSize];
while (true)
{
var read = stream.Read(buffer, 0, random.Next(1, chunkSize));
if (read == 0)
{
break;
}
expectedPosition += read;
Assert.Equal(expectedPosition, stream.Position);
}
Assert.Equal(expectedLength, stream.Position);
}
}
finally
{
File.Delete(encoded);
}
}
private void TestEncoding(string original, int chunkSize, string options, string contentType = "??")
{
original = Tools.FindFile(original);
var encoded = Path.GetTempFileName();
var decoded = Path.GetTempFileName();
LZ4Settings settings = Tools.ParseSettings(options);
try
{
var stopwatch = Stopwatch.StartNew();
TestedLZ4.Encode(original, encoded, chunkSize, settings);
stopwatch.Stop();
var testedEncodeTime = stopwatch.Elapsed;
stopwatch.Restart();
TestedLZ4.Decode(encoded, decoded, chunkSize);
stopwatch.Stop();
var testedDecodeTime = stopwatch.Elapsed;
long testedEncodeSize = new FileInfo(encoded).Length;
long testedOriginalSize = new FileInfo(original).Length;
double testedCompress = (double)testedEncodeSize / (double)testedOriginalSize * 100;
stopwatch.Restart();
ReferenceLZ4.Encode(options, original, encoded);
stopwatch.Stop();
var refEncodeTime = stopwatch.Elapsed;
stopwatch.Restart();
ReferenceLZ4.Decode(encoded, decoded);
stopwatch.Stop();
var refDecodeTime = stopwatch.Elapsed;
string encoderWinner = null;
if (testedEncodeTime > refEncodeTime)
{
encoderWinner = string.Format("Native wins by {0}", (testedEncodeTime - refEncodeTime));
}
else if (refEncodeTime > testedEncodeTime)
{
encoderWinner = string.Format("Implement wins by {0}", (refEncodeTime - testedEncodeTime));
}
else
{
encoderWinner = "Tied!";
}
string decoderWinner = null;
if (testedDecodeTime > refDecodeTime)
{
decoderWinner = string.Format("Native wins by {0}", (testedDecodeTime - refDecodeTime));
}
else if (refDecodeTime > testedDecodeTime)
{
decoderWinner = string.Format("Implement wins by {0}", (refDecodeTime - testedDecodeTime));
}
else
{
decoderWinner = "Tied!";
}
string settingsFormatted = string.Format("Level = {0}, BlockSize = {1}, Chaining = {2}",
settings.Level,
settings.BlockSize,
settings.Chaining);
string report = string.Format("Encoding payload '{0}' ({1}) implement vs native performance results: \n", original, contentType);
report += string.Format("*** {0} ***\n", settingsFormatted);
report += string.Format("- Encoder: {0} vs {1}\n", testedEncodeTime, refEncodeTime);
report += " => " + encoderWinner + "\n";
report += string.Format("- Decoder: {0} vs {1}\n", testedDecodeTime, refDecodeTime);
report += " => " + decoderWinner + "\n";
report += string.Format("- Reduced size from {0} to {1} => {2}% of original size\n", testedOriginalSize, testedEncodeSize, testedCompress);
output.WriteLine("[TOUT/PERF] " + report);
}
finally
{
File.Delete(encoded);
File.Delete(decoded);
}
}
