public void Hash64_InvalidKeyLength_Throws(int keyLength)
{
var invalidKey = new byte[keyLength];
var buffer = new byte[0];
Assert.Throws <ArgumentException>(() => SipHash24.Hash64(buffer, invalidKey));
}
public void Hash64Async_BigEndian_Throws()
{
Bits.IsBigEndian = true;
Assert.ThrowsAsync <NotSupportedException>(async() =>
await SipHash24.Hash64Async(new MemoryStream(new byte[0]), new byte[16]));
Bits.IsBigEndian = false;
}
public void Hash64_Stream_InvalidKeyLength_Throws()
{
using (var stream = new MemoryStream(new byte[0]))
{
Assert.Throws <ArgumentException>(() => SipHash24.Hash64(stream, new byte[15]));
}
}
public void Hash64Async_InvalidKeyLength_Throws()
{
using (var stream = new MemoryStream(new byte[0]))
{
Assert.ThrowsAsync <ArgumentException>(async() =>
await SipHash24.Hash64Async(stream, new byte[15]));
}
}
public void ComputeHash_ExceptionTest()
{
SipHash24 hash = new SipHash24();
Assert.Throws <ArgumentNullException>(() => hash.ComputeHash(null, new byte[0]));
Assert.Throws <ArgumentNullException>(() => hash.ComputeHash(new byte[0], null));
Assert.Throws <ArgumentOutOfRangeException>(() => hash.ComputeHash(new byte[0], new byte[0]));
}
public void Hash64_Binary_TestVectors()
{
for (int i = 0; i < vectors.Length; ++i)
{
var buffer = getBuffer(i);
var result = SipHash24.Hash64(buffer, key);
var expectedResult = vectors[i];
Debug.WriteLine("testing iteration #" + i);
Assert.AreEqual(expectedResult, result);
}
}
public void Hash64_Stream_TestVectors()
{
for (int i = 0; i < vectors.Length; ++i)
{
var buffer = getBuffer(i);
using var stream = new MemoryStream(buffer);
var result = SipHash24.Hash64(stream, key);
var expectedResult = vectors[i];
Debug.WriteLine("testing iteration #" + i);
Assert.AreEqual(expectedResult, result);
}
}
public async Task Hash64Async_TestVectors()
{
for (int i = 0; i < vectors.Length; ++i)
{
var buffer = getBuffer(i);
using var stream = new MemoryStream(buffer);
ulong result = await SipHash24.Hash64Async(stream, key);
ulong expectedResult = vectors[i];
Assert.AreEqual(expectedResult, result);
}
}
public void ComputeHashTest()
{
// From last page of https://131002.net/siphash/siphash.pdf
SipHash24 hash = new SipHash24();
byte[] key = Enumerable.Range(0, 16).Select(x => (byte)x).ToArray();
byte[] data = Enumerable.Range(0, 15).Select(x => (byte)x).ToArray();
ulong actual = hash.ComputeHash(key, data);
ulong expected = 0xa129ca6149be45e5UL;
Assert.Equal(expected, actual);
}
public void ComputeHash_AllCasesTest(byte[] hashBa, int len)
{
// Tests from: https://github.com/veorq/SipHash/blob/bab35c64d10f63587a3693a71200620f0ee03cc4/vectors.h#L3-L196
// How its used: https://github.com/veorq/SipHash/blob/bab35c64d10f63587a3693a71200620f0ee03cc4/test.c#L69
SipHash24 hash = new SipHash24();
byte[] key = Enumerable.Range(0, 16).Select(x => (byte)x).ToArray();
byte[] data = Enumerable.Range(0, len).Select(x => (byte)x).ToArray();
ulong actual = hash.ComputeHash(key, data);
ulong expected = (ulong)hashBa[0] |
(ulong)hashBa[1] << 8 |
(ulong)hashBa[2] << 16 |
(ulong)hashBa[3] << 24 |
(ulong)hashBa[4] << 32 |
(ulong)hashBa[5] << 40 |
(ulong)hashBa[6] << 48 |
(ulong)hashBa[7] << 56;
Assert.Equal(expected, actual);
}
public void Hash64Async_BigEndian_Throws()
{
Assert.ThrowsAsync <NotSupportedException>(() =>
SipHash24.Hash64Async(new MemoryStream(new byte[0]), new byte[16]));
}
public void Hash64_BinaryBigEndian_Throws()
{
Assert.Throws <NotSupportedException>(() => SipHash24.Hash64(new byte[0], new byte[16]));
}
public void Hash64_StreamBigEndian_Throws()
{
Bits.IsBigEndian = true;
Assert.Throws <NotSupportedException>(() => SipHash24.Hash64(new MemoryStream(new byte[0]), new byte[16]));
Bits.IsBigEndian = false;
}
public void Hash64_BinaryBigEndian_Throws()
{
Bits.IsBigEndian = true;
Assert.Throws <NotSupportedException>(() => SipHash24.Hash64(new byte[0], new byte[16]));
Bits.IsBigEndian = false;
}
