protected DedupNode HashIsStable(HashType hashType, uint byteCount, string expectedHash, int seed = 0)
{
DedupNode node;
if (hashType == HashType.Dedup64K) // COMChunker only supports 64K.
{
if (Chunker.IsComChunkerSupported)
{
using (var chunker = new ComChunker(ChunkerConfiguration.SupportedComChunkerConfiguration))
using (var defaultHasher = new DedupNodeOrChunkHashAlgorithm(chunker))
{
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, true);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, true);
}
}
}
using (var defaultHasher = new DedupNodeOrChunkHashAlgorithm(new ManagedChunker(hashType.GetChunkerConfiguration())))
{
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, true);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, byteCount, expectedHash, seed, true);
}
return(node);
}
private DedupNode HashIsStable(uint byteCount, string expectedHash, int seed = 0)
{
DedupNode node;
if (Chunker.IsComChunkerSupported)
{
using (var chunker = new ComChunker(ChunkerConfiguration.Default))
using (var hasher = new DedupNodeHashAlgorithm(chunker))
{
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, true);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, true);
}
}
using (var chunker = new ManagedChunker(ChunkerConfiguration.Default))
using (var hasher = new DedupNodeHashAlgorithm(chunker))
{
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, true);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, false);
node = HashIsStableForChunker(hasher, byteCount, expectedHash, seed, true);
}
return(node);
}
public void ComChunkerWorksOnThreading()
{
Thread.CurrentThread.GetApartmentState().Should().Be(ApartmentState.MTA);
var chunker = new ComChunker(ChunkerConfiguration.Default);
Task.Run(() =>
{
using var session = chunker.BeginChunking(chunk => { });
session.PushBuffer(new ArraySegment <byte>(new byte[1]));
}).GetAwaiter().GetResult();
}
private DedupNode HashIsStable(uint byteCount, string expectedHash, int seed = 0)
{
if (DedupNodeHashAlgorithm.IsComChunkerSupported)
{
using (var chunker = new ComChunker())
{
HashIsStableForChunker(chunker, byteCount, expectedHash, seed);
}
}
using (var chunker = new ManagedChunker())
{
return(HashIsStableForChunker(chunker, byteCount, expectedHash, seed));
}
}
public void ComChunkerWorksOnThreading()
{
// For some reason current thread is STAThread, so we need to start a new one.
var thread = new Thread(() =>
{
Thread.CurrentThread.GetApartmentState().Should().Be(ApartmentState.MTA);
var chunker = new ComChunker();
Task.Run(() =>
{
using var session = chunker.BeginChunking(chunk => { });
session.PushBuffer(new ArraySegment <byte>(new byte[1]));
}).GetAwaiter().GetResult();
});
thread.Start();
thread.Join();
}
protected DedupNode HashIsStable(HashType hashType, uint byteCount, string expectedHash, int seed = 0)
{
byte[] bytes = new byte[byteCount];
if (byteCount > 0)
{
FillBufferWithTestContent(seed, bytes);
}
DedupNode node;
if (hashType == HashType.Dedup64K) // COMChunker only supports 64K.
{
if (Chunker.IsComChunkerSupported)
{
using (var chunker = new ComChunker(ChunkerConfiguration.SupportedComChunkerConfiguration))
using (var defaultHasher = new DedupNodeOrChunkHashAlgorithm(chunker))
{
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, true);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, true);
}
}
}
using (var defaultHasher = new DedupNodeOrChunkHashAlgorithm(new ManagedChunker(hashType.GetChunkerConfiguration())))
{
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, true);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, false);
node = HashIsStableForChunker(defaultHasher, bytes, expectedHash, seed, true);
}
HashCanBeVerified(node, bytes, expectedHash, seed);
return(node);
}
