public void BinaryDeltaReader_ReadsLegacyDelta()
{
// Arrange
var deltaStream = new MemoryStream(FastRsyncLegacyMetadataDelta);
// Act
IDeltaReader target = new BinaryDeltaReader(deltaStream, null);
// Assert
Assert.AreEqual(RsyncFormatType.FastRsync, target.Type);
Assert.AreEqual(new XxHashAlgorithm().Name, target.HashAlgorithm.Name);
Assert.AreEqual(new XxHashAlgorithm().HashLength, target.HashAlgorithm.HashLength);
Assert.AreEqual(FastRsyncLegacyDeltaExpectedFileHash, target.Metadata.ExpectedFileHash);
Assert.AreEqual("MD5", target.Metadata.ExpectedFileHashAlgorithm);
Assert.AreEqual(new XxHashAlgorithm().Name, target.Metadata.HashAlgorithm);
Assert.Null(target.Metadata.BaseFileHash);
Assert.Null(target.Metadata.BaseFileHashAlgorithm);
}
public int Execute(string[] commandLineArguments)
{
options.Parse(commandLineArguments);
if (string.IsNullOrWhiteSpace(deltaFilePath))
{
throw new OptionException("No delta file was specified", "delta-file");
}
deltaFilePath = Path.GetFullPath(deltaFilePath);
if (!File.Exists(deltaFilePath))
{
throw new FileNotFoundException("File not found: " + deltaFilePath, deltaFilePath);
}
using (var deltaStream = new FileStream(deltaFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var reader = new BinaryDeltaReader(deltaStream, null);
reader.ApplyAsync(data =>
{
if (data.Length > 20)
{
Console.WriteLine("Data: ({0} bytes): {1}...", data.Length,
BitConverter.ToString(data.Take(20).ToArray()));
}
else
{
Console.WriteLine("Data: ({0} bytes): {1}", data.Length, BitConverter.ToString(data.ToArray()));
}
return(Task.CompletedTask);
},
(start, offset) =>
{
Console.WriteLine("Copy: {0:X} to {1:X}", start, offset);
return(Task.CompletedTask);
}).GetAwaiter().GetResult();
}
return(0);
}
public void GZip_CompressData_RsyncSignatureAndPatch(int dataLength)
{
// Arrange
var dataBasis = new byte[dataLength];
new Random().NextBytes(dataBasis);
var basisStream = new MemoryStream(dataBasis);
var basisStreamCompressed = new MemoryStream();
var basisStreamCompressedSignature = new MemoryStream();
var newFileStream = new MemoryStream();
newFileStream.Write(dataBasis, 10, dataLength * 4 / 5);
var newRandomData = new byte[dataLength * 2 / 5];
new Random().NextBytes(newRandomData);
newFileStream.Write(newRandomData, 0, newRandomData.Length);
newFileStream.Seek(0, SeekOrigin.Begin);
var newFileStreamCompressed = new MemoryStream();
var deltaStream = new MemoryStream();
var patchedCompressedStream = new MemoryStream();
// Act
GZip.Compress(basisStream, basisStreamCompressed);
basisStreamCompressed.Seek(0, SeekOrigin.Begin);
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(basisStreamCompressed, new SignatureWriter(basisStreamCompressedSignature));
basisStreamCompressedSignature.Seek(0, SeekOrigin.Begin);
GZip.Compress(newFileStream, newFileStreamCompressed);
newFileStreamCompressed.Seek(0, SeekOrigin.Begin);
var deltaBuilder = new DeltaBuilder();
deltaBuilder.BuildDelta(newFileStreamCompressed, new SignatureReader(basisStreamCompressedSignature, null),
new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
deltaStream.Seek(0, SeekOrigin.Begin);
var deltaApplier = new DeltaApplier
{
SkipHashCheck = true
};
var deltaReader = new BinaryDeltaReader(deltaStream, null);
deltaApplier.Apply(basisStreamCompressed, deltaReader, patchedCompressedStream);
deltaApplier.HashCheck(deltaReader, patchedCompressedStream);
// Assert
Assert.AreEqual(newFileStreamCompressed.ToArray(), patchedCompressedStream.ToArray());
patchedCompressedStream.Seek(0, SeekOrigin.Begin);
var decompressedStream = new MemoryStream();
using (var gz = new GZipStream(patchedCompressedStream, CompressionMode.Decompress))
{
gz.CopyTo(decompressedStream);
}
var dataOutput = decompressedStream.ToArray();
Assert.AreEqual(newFileStream.ToArray(), dataOutput);
}
