wabbajack/Wabbajack.Hashing.xxHash64.Test/HashTests.cs

using System;
using System.Data.HashFunction.xxHash;
using FsCheck.Xunit;
using Xunit;

namespace Wabbajack.Hashing.xxHash64.Test
{
    public class HashTests
    {
        private static readonly Hash Hash1 = new(1);
        private static readonly Hash Hash1a = new(1);
        private static readonly Hash Hash2 = new(2);

        [Property(MaxTest = 1024)]
        public void CompareResults(byte[] data)
        {
            var hash = new xxHashAlgorithm(0);
            Assert.Equal(HashOld(data), hash.HashBytes(data));
        }

        [Property(MaxTest = 1024 * 1024)]
        public void ToFromBase64(ulong hash)
        {
            var a = new Hash(hash);
            var b = Hash.FromBase64(a.ToBase64());
            Assert.Equal(a, b);
        }
        
        [Property(MaxTest = 1024 * 1024)]
        public void ToFromBase64Span(ulong hash)
        {
            hash = ulong.MaxValue - hash;
            Span<byte> data = stackalloc byte[12];
            var a = new Hash(hash);
            a.ToBase64(data);
            var b = Hash.FromBase64(data);
            Assert.Equal(a, b);
        }

        private ulong HashOld(byte[] data)
        {
            var config = new xxHashConfig { HashSizeInBits = 64 };
            return BitConverter.ToUInt64(xxHashFactory.Instance.Create(config).ComputeHash(data).Hash);
        }

        [Fact]
        public void HashesAreEquatable()
        {
            Assert.Equal(Hash1, Hash1a);
            Assert.True(Hash1 == Hash1a);
            Assert.True(Hash1 != Hash2);
        }

        [Fact]
        public void HashesAreSortable()
        {
            Assert.Equal(0, Hash1.CompareTo(Hash1a));
            Assert.Equal(-1, Hash1.CompareTo(Hash2));
            Assert.Equal(1, Hash2.CompareTo(Hash1));
        }

        [Fact]
        public void HashesConvertToBase64()
        {
            Assert.Equal("AQAAAAAAAAA=", Hash1.ToBase64());
            Assert.Equal("AQAAAAAAAAA=", Hash1.ToString());
            Assert.Equal(Hash1, Hash.Interpret(Hash1.ToBase64()));
        }

        [Fact]
        public void HashesConvertToHex()
        {
            Assert.Equal("0100000000000000", Hash1.ToHex());
            Assert.Equal(Hash1, Hash.Interpret(Hash1.ToHex()));
        }

        [Fact]
        public void HashesConvertToLong()
        {
            Assert.Equal(Hash1, Hash.Interpret(((long)Hash1).ToString()));
        }

        [Fact]
        public void MiscMethods()
        {
            Assert.Equal(1, Hash1.GetHashCode());
            Assert.Equal(1, (long)Hash1);
            Assert.Equal((ulong)1, (ulong)Hash1);
            Assert.True(Hash1.Equals(Hash1a));
            Assert.True(Hash1.Equals((object)Hash1a));
            Assert.NotEqual(Hash1, (object)4);
            Assert.Equal(Hash1, Hash.FromULong(1));
            Assert.Equal(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, Hash1.ToArray());
        }
    }
}