public void Parsing() { Assert.False(HashCode128.TryParse(null, out HashCode128 hash)); Assert.False(HashCode128.TryParse("", out hash)); Assert.False(HashCode128.TryParse("123456789ABCDE", out hash)); Assert.False(HashCode128.TryParse("Well, this isn't likely to work, is it?", out hash)); Assert.False(HashCode128.TryParse("123456789abcdef01", out hash)); Assert.Equal(hash, HashCode128.Zero); Assert.Equal(default(HashCode128), hash); Assert.True(HashCode128.TryParse("123456789abcdef00fedcba987654321", out hash)); Assert.Equal(hash, HashCode128.Parse(" 123456789ABCD EF0 0fe DCB a98 765 4321 ")); Assert.Equal(HashCode128.Parse("00000000000000000000000000000000"), HashCode128.Zero); Assert.Equal(hash.GetHashCode(), HashCode128.Parse("123456789abcdef00fedcba987654321").GetHashCode()); Assert.NotEqual(hash.GetHashCode(), HashCode128.Zero.GetHashCode()); Assert.Equal(0, HashCode128.Zero.GetHashCode()); Assert.Equal <ulong>(0x123456789abcdef0, hash.UHash1); Assert.Equal <ulong>(0x0fedcba987654321, hash.UHash2); Assert.Equal(0x123456789abcdef0, hash.Hash1); Assert.Equal(0x0fedcba987654321, hash.Hash2); Assert.Equal(hash, new HashCode128(0x123456789abcdef0u, 0x0fedcba987654321)); Assert.Equal(hash, new HashCode128(0x123456789abcdef0, 0x0fedcba987654321)); Assert.Equal(hash, HashCode128.Parse("0x123456789abcdef00fedcba987654321")); Assert.Equal(hash, HashCode128.Parse("0x123456789abcdef00fedcba987654321")); Assert.False(HashCode128.TryParse("x123456789abcdef00fedcba987654321", out hash)); Assert.False(HashCode128.TryParse("0xx123456789abcdef00fedcba987654321", out hash)); Assert.False(HashCode128.TryParse("1234x6789abcdef00fedcba987654321", out hash)); }
public void ConstructorsEquivalent() { ulong ui1 = 0xdeadcafe; ulong ui2 = 0xbaceba11; SpookyHash fromU = new SpookyHash(ui1, ui2); SpookyHash fromZeroU = new SpookyHash(); fromZeroU.Init(ui1, ui2); long l1 = unchecked ((long)ui1); long l2 = unchecked ((long)ui2); SpookyHash fromL = new SpookyHash(l1, l2); SpookyHash fromZeroL = new SpookyHash(); fromZeroL.Init(l1, l2); fromU.Update(MediumLengthString); fromZeroU.Update(MediumLengthString); fromL.Update(MediumLengthString); fromZeroL.Update(MediumLengthString); HashCode128 hash = fromU.Final(); Assert.Equal(hash, fromZeroU.Final()); Assert.Equal(hash, fromL.Final()); Assert.Equal(hash, fromZeroL.Final()); Assert.Equal(hash.ToString(), fromZeroL.Final().ToString()); }
public unsafe void Hash128PtrOverloads() { ulong seed1 = 238929482; ulong seed2 = 19384920392; string testString = "This is a test string"; ulong hash1 = seed1; ulong hash2 = seed2; fixed(void *ptr = testString) { int len = testString.Length * 2; SpookyHash.Hash128(ptr, len, ref hash1, ref hash2); HashCode128 hc = new HashCode128(hash1, hash2); Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, seed1, seed2)); Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, (long)seed1, (long)seed2)); Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, seed1, seed2)); Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, (long)seed1, (long)seed2)); } SpookyHash.Hash128(default(void *), 50, ref hash1, ref hash2); Assert.Equal(0UL, hash1); Assert.Equal(0UL, hash2); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, seed1, seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, (long)seed1, (long)seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, seed1, seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, (long)seed1, (long)seed2)); }
public void StringExtension() { string testString; using (Stream stm = GetStream()) using (StreamReader tr = new StreamReader(stm)) { testString = tr.ReadToEnd(); } SpookyHash sh = new SpookyHash(); sh.Update(testString); HashCode128 h = sh.Final(); int len = testString.Length; Assert.Equal(h, testString.SpookyHash128()); Assert.Equal(h, testString.SpookyHash128(0, len, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF)); Assert.Equal( h, unchecked (testString.SpookyHash128(0, len, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF))); Assert.Equal(h, testString.SpookyHash128(0, len)); HashCode128 hashSlice = testString.SpookyHash128(50, 100, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF); Assert.NotEqual(h, hashSlice); Assert.Equal( hashSlice, unchecked (testString.SpookyHash128(50, 100, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF))); long longHash = testString.SpookyHash64(0, len, unchecked ((long)0xDEADBEEFDEADBEEF)); Assert.Equal(longHash, testString.SpookyHash64(unchecked ((long)0xDEADBEEFDEADBEEF))); Assert.Equal(longHash, testString.SpookyHash64(0, len)); Assert.Equal(longHash, testString.SpookyHash64()); int hash = testString.SpookyHash32(0, len, unchecked ((int)0xDEADBEEF)); Assert.Equal(hash, testString.SpookyHash32(unchecked ((int)0xDEADBEEF))); Assert.Equal(hash, testString.SpookyHash32(0, len)); Assert.Equal(hash, testString.SpookyHash32()); Assert.Equal(HashCode128.Zero, default(string).SpookyHash128()); Assert.Equal( HashCode128.Zero, default(string).SpookyHash128(0, 200, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF)); Assert.Equal( HashCode128.Zero, unchecked (default(string).SpookyHash128(0, 200, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF))); Assert.Equal(HashCode128.Zero, default(string).SpookyHash128(0, 200)); Assert.Equal( HashCode128.Zero, default(string).SpookyHash128(50, 100, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF)); Assert.Equal(0, default(string).SpookyHash64(0, 200, unchecked ((long)0xDEADBEEFDEADBEEF))); Assert.Equal(0, default(string).SpookyHash64(unchecked ((long)0xDEADBEEFDEADBEEF))); Assert.Equal(0, default(string).SpookyHash64(0, 200)); Assert.Equal(0, default(string).SpookyHash64()); Assert.Equal(0, default(string).SpookyHash32(0, 200, unchecked ((int)0xDEADBEEF))); Assert.Equal(0, default(string).SpookyHash32(unchecked ((int)0xDEADBEEF))); Assert.Equal(0, default(string).SpookyHash32(0, 200)); Assert.Equal(0, default(string).SpookyHash32()); }
public static HashCode128 ToHashCode128(this IHashValue hashVal, bool strictMode = true) { if (hashVal is null) { return(HashCode128.Zero); } var hex = hashVal.GetHexString(); return(strictMode ? HashCode128.Parse(hex) : HashCode128.ParseLoosely(hex)); }
public void OutputTest() { var hash = HashCode128.Parse("123456789abcdef00fedcba987654321"); hash.GetHexString(false).ShouldBe("123456789abcdef00fedcba987654321"); hash.GetHexString(true).ShouldBe("123456789ABCDEF00FEDCBA987654321"); hash.GetBinString(false).ShouldBe("10010001101000101011001111000100110101011110011011110111100000000111111101101110010111010100110000111011001010100001100100001"); hash.GetBinString(true).ShouldBe("00010010001101000101011001111000100110101011110011011110111100000000111111101101110010111010100110000111011001010100001100100001"); }
#pragma warning disable 1718 //Yes, I'm testing the obvious! public void EqualsOps() { Assert.True(HashCode128.Zero == HashCode128.Zero); Assert.True( HashCode128.Parse("0123456789abcdef0123456789abcdef") == HashCode128.Parse("0123456789ABCDEF0123456789ABCDEF")); Assert.False(HashCode128.Zero != HashCode128.Zero); Assert.False( HashCode128.Parse("0123456789abcdef0123456789abcdef") != HashCode128.Parse("0123456789ABCDEF0123456789ABCDEF")); Assert.True(HashCode128.Parse("0123456789abcdef0123456789abcdef") != HashCode128.Zero); Assert.False(HashCode128.Parse("0123456789abcdef0123456789abcdef") == HashCode128.Zero); }
public void EqualsObj() { Assert.Equal(HashCode128.Zero, (object)HashCode128.Zero); object boxed = HashCode128.Parse("0123456789abcdef0123456789ABCDEF"); Assert.True(boxed.Equals(HashCode128.Parse("0123456789ABCDEF0123456789ABCDEF"))); Assert.False(boxed.Equals(HashCode128.Zero)); Assert.False(boxed.Equals("not a hash code")); Assert.True( Equals( HashCode128.Parse("fed c b a9876543210 0123456789ABCDEF"), HashCode128.Parse("FE DCBA 98765 432 10 0123456789ABCD EF "))); }
public void FinalsEquivalent() { SpookyHash sh = new SpookyHash(); sh.Update("abcdefg"); HashCode128 h128 = sh.Final(); sh.Final(out ulong u1, out ulong u2); Assert.Equal(h128.UHash1, u1); Assert.Equal(h128.UHash2, u2); sh.Final(out long l1, out long l2); Assert.Equal(h128.Hash1, l1); Assert.Equal(h128.Hash2, l2); }
public static HashCode128 SafeHashCode128(this IHashValue hashVal, bool strictMode = true) { if (hashVal is null) { return(HashCode128.Zero); } var hex = hashVal.GetHexString(); return(strictMode ? HashCode128.TryParse(hex, out var hash) ? hash : HashCode128.Zero : HashCode128.TryParseLoosely(hex, out hash) ? hash : HashCode128.Zero); }
public void BadFormatTooShortLow() { Assert.Throws <FormatException>( () => HashCode128.Parse("0123456789abcdef01234 ")); }
public void BadFormatTooShortHigh() { Assert.Throws <FormatException>(() => HashCode128.Parse(new string(' ', 32))); }
public void BadFormatTooShortPadded() { Assert.Throws <FormatException>( () => HashCode128.Parse("1234 ")); }
public void BadFormatDouble0X() { Assert.Throws <FormatException>( () => HashCode128.Parse("0x0x123456543456765445612345654345676544561234565434567654456")); }
public void BadFormatLow() { Assert.Throws <FormatException>( () => HashCode128.Parse("0123456789f12323432343234324324323433232sdrtyrtyttytrty")); }
public void BadFormatHigh() { Assert.Throws <FormatException>( () => HashCode128.Parse( "76544561234565434567654456012sdfafasjkl;fdsafdk1234565434561234565434567654456")); }
public void BadFormat() { Assert.Throws <FormatException>(() => HashCode128.Parse("0123456780123457833943")); }
public void ArgumentNull() { Assert.Throws <ArgumentNullException>("s", () => HashCode128.Parse(null)); }
public unsafe void Hash128PtrOverloads() { ulong seed1 = 238929482; ulong seed2 = 19384920392; string testString = "This is a test string"; ulong hash1 = seed1; ulong hash2 = seed2; fixed(void* ptr = testString) { int len = testString.Length * 2; SpookyHash.Hash128(ptr, len, ref hash1, ref hash2); HashCode128 hc = new HashCode128(hash1, hash2); Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, seed1, seed2)); Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, (long)seed1, (long)seed2)); Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, seed1, seed2)); Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, (long)seed1, (long)seed2)); } void* nullPointer = null; SpookyHash.Hash128(nullPointer, 50, ref hash1, ref hash2); Assert.Equal(0UL, hash1); Assert.Equal(0UL, hash2); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, seed1, seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, (long)seed1, (long)seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, seed1, seed2)); Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, (long)seed1, (long)seed2)); }
public void ToStringTests() { Assert.Equal( "0123456789ABCDEF0123456789ABCDEF", HashCode128.Parse("0123456789abcdef0123456789ABCDEF").ToString()); }