public void CouldRoundtripToString()
{
var h1 = Hash16.Random();
var s1 = h1.ToString();
Console.WriteLine(s1);
var h2 = new Hash16(s1);
var s2 = h2.ToString();
Assert.AreEqual(s1, s2, "strings equal");
Assert.AreEqual(h1, h2, "hashes equal");
Assert.AreEqual(h1.ToString(), s2);
}
private static Hash16 CouldChainHashesBench_ChainLibsodium(int count, Hash16 h1)
{
Hash16 h = default;
using (Benchmark.Run("Chain Libsodium", count * 32))
{
for (int i = 0; i < count; i++)
{
h = Hash16.Chain2(in h1, h1.AsSpan());
}
}
return(h);
}
public unsafe void CouldChainHashes()
{
Console.WriteLine("Default: " + default(Hash16).ToString());
var h1 = Hash16.Random();
var h2 = Hash16.Random();
var rm = BufferPool.Retain(Hash16.Size * 2, true);
var ptr = (byte *)rm.Pointer;
*(Hash16 *)ptr = h1;
*(Hash16 *)(ptr + Hash16.Size) = h2;
var db = new DirectBuffer(Hash16.Size * 2, ptr);
var chainStr = Hash16.Chain(h1, h2.AsSpan()).ToString();
Console.WriteLine(chainStr);
var chainStr2 = Hash16.Chain2(h1, h2.AsSpan()).ToString();
Console.WriteLine(chainStr2);
Assert.AreEqual(chainStr, chainStr2);
Span <byte> output = stackalloc byte[Hash16.Size];
//SauceControl.Blake2Fast.Blake2b.ComputeAndWriteHash(Hash32.Size,
// h1.AsSpan(), h2.AsSpan(), output);
//var reference = Unsafe.As<byte, Hash32>(ref output[0]);
//Assert.AreEqual(chained, reference);
//var incrHash = SauceControl.Blake2Fast.Blake2b.CreateIncrementalHasher(Hash32.Size);
//incrHash.Update(h1.AsSpan());
//incrHash.Update(default(Hash32).AsSpan());
//incrHash.Update(default(Hash32).AsSpan());
//incrHash.Update(default(Hash32).AsSpan());
//incrHash.Update(h2.AsSpan());
//incrHash.TryFinish(output, out _);
//var incremental = Unsafe.As<byte, Hash32>(ref output[0]);
//Console.WriteLine(incremental);
Spreads.Algorithms.Hash.Blake2b.ComputeAndWriteHash(Hash16.Size,
db, output);
var manual = Unsafe.As <byte, Hash16>(ref output[0]);
// Assert.AreEqual(chained, manual);
}
public void Constructor_ValueComesOutAgainAsExpected_OK()
{
// ReSharper disable RedundantExplicitArraySize
var b = new byte[16]
{
0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88,
0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
};
// ReSharper restore RedundantExplicitArraySize
var s1 = ByteArrayHelper.ByteArrayToString(b);
var s2 = new Hash16(b).HashAsString;
Console.WriteLine($"s1 {s1}");
Console.WriteLine($"s2 {s2}");
Assert.That(s2, Is.EqualTo("ffeeddccbbaa99887766554433221100"));
}
public unsafe void CouldChainHashesBench()
{
var h = Hash16.Random();
var count = 1_000_000;
var rounds = 10;
var h1 = Hash16.Chain(h, h.AsSpan());
var h2 = Hash16.Chain2(h, h.AsSpan());
for (int _ = 0; _ < rounds; _++)
{
h1 = CouldChainHashesBench_ChainSimd(count, h);
h2 = CouldChainHashesBench_ChainLibsodium(count, h);
Assert.AreEqual(h1.ToString(), h2.ToString());
Console.WriteLine(h1.ToString());
h = h1;
}
Benchmark.Dump();
}
public void HashAsString_Init1_OK()
{
// ReSharper disable RedundantExplicitArraySize
var b = new byte[16]
{
0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88,
0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
};
// ReSharper restore RedundantExplicitArraySize
byte[] hash;
using (var md5 = MD5.Create())
{
hash = md5.ComputeHash(b);
}
var h16 = new Hash16(hash);
Console.WriteLine($"h16.HashAsString {h16.HashAsString}");
Console.WriteLine($" old hex {ByteArrayHelper.ByteArrayToString(hash)}");
Assert.That(h16.HashAsString, Is.EqualTo("a4bd60352d683c3eac5f826528bbfd02"));
}
public void Constructor_Basic_OK()
{
var h = new Hash16();
Assert.That(h.HashAsString, Is.EqualTo("00000000000000000000000000000000"));
}
public Crc16Algorithm(Hash16 hash)
{
this.hash = hash;
}
