public void IHashFunction_ComputeHashAsync_Stream_InvalidHashSize_Throws()
{
var hashSizes = KnownValues.Select(kv => kv.HashSize)
.Distinct();
// Ignore if hash function does not seem to have a configurable hashSize constructor.
foreach (var hashSize in hashSizes)
{
Mock <IHashFunctionAsyncT> hashFunctionMock = CreateHashFunctionMock(hashSize);
hashFunctionMock.CallBase = true;
hashFunctionMock
.SetupGet(hf => hf.HashSize)
.Returns(-1);
var hashFunction = hashFunctionMock.Object;
using (var ms = new SlowAsyncStream(new MemoryStream()))
{
var aggregateException =
Assert.Throws <AggregateException>(() =>
hashFunction.ComputeHashAsync(ms).Wait());
var resultingException =
Assert.Single(aggregateException.InnerExceptions);
Assert.Contains("HashSize",
Assert.IsType <InvalidOperationException>(
resultingException)
.Message);
}
}
}
public async void IHashFunctionAsync_ComputeHashAsync_Stream_Seekable_MatchesKnownValues()
{
foreach (var knownValue in KnownValues)
{
var hf = CreateHashFunction(knownValue.HashSize);
using (var ms = new SlowAsyncStream(new MemoryStream(knownValue.TestValue)))
{
var hashResults = await hf.ComputeHashAsync(ms);
Assert.Equal(
new HashValue(knownValue.ExpectedValue.Take((hf.HashSizeInBits + 7) / 8), hf.HashSizeInBits),
hashResults);
}
}
}
public async void IHashFunctionAsync_ComputeHashAsync_Stream_NonSeekable_MatchesKnownValues()
{
foreach (var knownValueGroup in KnownValues.GroupBy(kv => kv.HashSize))
{
var hf = CreateHashFunction(knownValueGroup.Key);
foreach (var knownValue in knownValueGroup)
{
using (var ms = new SlowAsyncStream(new NonSeekableMemoryStream(knownValue.TestValue)))
{
var hashResults = await hf.ComputeHashAsync(ms);
Assert.Equal(
knownValue.ExpectedValue.Take((hf.HashSize + 7) / 8),
hashResults);
}
}
}
}
