protected void InstanceVerifyResetStateDriver(TestCase testCase)
{
NonCryptographicHashAlgorithm hash = CreateInstance();
Span <byte> buf = stackalloc byte[233];
int written = hash.GetHashAndReset(buf);
ReadOnlySpan <byte> ret = buf.Slice(0, written);
VerifyEmptyResult(ret);
hash.Append(testCase.Input);
hash.Reset();
hash.GetCurrentHash(buf);
VerifyEmptyResult(ret);
// Manual call to Reset while already in a pristine state.
hash.Reset();
hash.GetCurrentHash(buf);
VerifyEmptyResult(ret);
hash.Append(testCase.Input);
hash.GetHashAndReset(buf);
testCase.VerifyResponse(ret);
hash.GetHashAndReset(buf);
VerifyEmptyResult(ret);
}
protected void InstanceMultiAppendGetCurrentHashDriver(TestCase testCase)
{
ReadOnlySpan <byte> source = testCase.Input;
int div3 = source.Length / 3;
NonCryptographicHashAlgorithm hash = CreateInstance();
hash.Append(source.Slice(0, div3));
source = source.Slice(div3);
hash.Append(source.Slice(0, div3));
source = source.Slice(div3);
hash.Append(source);
Span <byte> buf = stackalloc byte[256];
// May as well check unaligned writes.
Span <byte> destination = buf.Slice(1);
int written = hash.GetCurrentHash(destination);
ReadOnlySpan <byte> answer = destination.Slice(0, written);
testCase.VerifyResponse(answer);
destination.Clear();
hash.GetCurrentHash(destination);
testCase.VerifyResponse(answer);
}
protected void InstanceAppendAllocateDriver(TestCase testCase)
{
NonCryptographicHashAlgorithm hash = CreateInstance();
hash.Append(testCase.Input);
byte[] output = hash.GetCurrentHash();
Assert.Equal(testCase.OutputHex, TestCase.ToHexString(output));
}
protected void InstanceVerifyEmptyStateDriver(TestCase testCase)
{
Span <byte> buf = stackalloc byte[256];
NonCryptographicHashAlgorithm hash = CreateInstance();
int written = hash.GetCurrentHash(buf);
VerifyEmptyResult(buf.Slice(0, written));
written = hash.GetHashAndReset(buf);
VerifyEmptyResult(buf.Slice(0, written));
}
protected void InstanceMultiAppendLargeInputDriver(LargeTestCase testCase)
{
NonCryptographicHashAlgorithm hash = CreateInstance();
foreach (ReadOnlyMemory <byte> chunk in testCase.EnumerateDataChunks())
{
hash.Append(chunk.Span);
}
byte[] answer = hash.GetHashAndReset();
testCase.VerifyResponse(answer);
}
protected void InstanceAppendAllocateAndResetDriver(TestCase testCase)
{
NonCryptographicHashAlgorithm hash = CreateInstance();
hash.Append(testCase.Input);
byte[] output = hash.GetHashAndReset();
Assert.Equal(testCase.OutputHex, TestCase.ToHexString(output));
int written = hash.GetHashAndReset(output);
Assert.Equal(output.Length, written);
VerifyEmptyResult(output);
}
public void VerifyLengthProperty()
{
NonCryptographicHashAlgorithm hash = CreateInstance();
Assert.Equal(_hashLengthInBytes, hash.HashLengthInBytes);
}
