Feat: Prowlhash test suite

.github/workflows/build.yml

@@ -1,15 +1,14 @@
 # This workflow will build a .NET project
 # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
 
-name: Build
+name: Build and Test
 
 on:
   push:
   pull_request:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     steps:
@@ -31,3 +30,7 @@ jobs:
       # Build
       - name: Build
         run: dotnet build --no-restore
+
+      # Test
+      - name: Test
+        run: dotnet test

Prowl.Runtime.Test/ColorTests.cs

@@ -0,0 +1,155 @@
+using Xunit;
+
+namespace Prowl.Runtime.Test;
+
+public class ColorTests
+{
+    [Fact]
+    public void Grayscale_Calculation_Is_Correct()
+    {
+        var color = new Color(0.5f, 0.5f, 0.5f, 1f);
+        Assert.Equal(0.5f, color.grayscale);
+    }
+
+    [Fact]
+    public void Indexer_Get_Returns_Correct_Value()
+    {
+        var color = new Color(0.1f, 0.2f, 0.3f, 0.4f);
+        Assert.Equal(0.1f, color[0]);
+        Assert.Equal(0.2f, color[1]);
+        Assert.Equal(0.3f, color[2]);
+        Assert.Equal(0.4f, color[3]);
+    }
+
+    [Fact]
+    public void Indexer_Set_Sets_Correct_Value()
+    {
+        var color = new Color(0.1f, 0.2f, 0.3f, 0.4f);
+        color[0] = 0.5f;
+        Assert.Equal(0.5f, color.r);
+    }
+
+    [Fact]
+    public void Indexer_Set_Throws_Exception_For_Invalid_Index()
+    {
+        var color = new Color(0.1f, 0.2f, 0.3f, 0.4f);
+        Assert.Throws<IndexOutOfRangeException>(() => color[4] = 0.5f);
+    }
+
+    [Fact]
+    public void Lerp_Returns_Correct_Value()
+    {
+        var color1 = new Color(0f, 0f, 0f, 1f);
+        var color2 = new Color(1f, 1f, 1f, 1f);
+        var lerpColor = Color.Lerp(color1, color2, 0.5f);
+        Assert.Equal(new Color(0.5f, 0.5f, 0.5f, 1f), lerpColor);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 0, 0, 0, 1)]
+    [InlineData(1, 1, 1, 1, 1, 1, 1, 1)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f)]
+    public void Equality_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float r2, float g2, float b2,
+        float a2)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var color2 = new Color(r2, g2, b2, a2);
+        Assert.Equal(r1 == r2 && g1 == g2 && b1 == b2 && a1 == a2, color1 == color2);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 0, 0, 0, 1)]
+    [InlineData(1, 1, 1, 1, 0, 0, 0, 1)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 1, 1, 1, 1)]
+    public void Inequality_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float r2, float g2,
+        float b2, float a2)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var color2 = new Color(r2, g2, b2, a2);
+        Assert.Equal(r1 != r2 || g1 != g2 || b1 != b2 || a1 != a2, color1 != color2);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2)]
+    [InlineData(1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 2)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 1, 1, 1, 1, 1.5f, 1.5f, 1.5f, 1.5f)]
+    public void Addition_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float r2, float g2, float b2,
+        float a2, float r3, float g3, float b3, float a3)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var color2 = new Color(r2, g2, b2, a2);
+        var result = color1 + color2;
+        Assert.Equal(new Color(r3, g3, b3, a3), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 2, 0, 0, 0, 0.5f)]
+    [InlineData(1, 1, 1, 1, 2, 0.5f, 0.5f, 0.5f, 0.5f)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 2, 0.25f, 0.25f, 0.25f, 0.25f)]
+    public void Division_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float divisor, float r2, float g2, float b2, float a2)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var result = color1 / divisor;
+        Assert.Equal(new Color(r2, g2, b2, a2), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1)]
+    [InlineData(1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 1, 1, 1, 0.5f, 0.5f, 0.5f, 0.5f, 0.25f)]
+    public void Multiplication_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float r2, float g2,
+        float b2, float a2, float r3, float g3, float b3, float a3)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var color2 = new Color(r2, g2, b2, a2);
+        var result = color1 * color2;
+        Assert.Equal(new Color(r3, g3, b3, a3), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 2, 0, 0, 0, 2)]
+    [InlineData(1, 1, 1, 1, 2, 2, 2, 2, 2)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 2, 1, 1, 1, 1)]
+    public void Multiplication_By_Scalar_Works_Correctly(float r1, float g1, float b1, float a1, float scalar, float r2,
+        float g2, float b2, float a2)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var result = color1 * scalar;
+        Assert.Equal(new Color(r2, g2, b2, a2), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 2, 0, 0, 0, 2)]
+    [InlineData(1, 1, 1, 1, 2, 2, 2, 2, 2)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 2, 1, 1, 1, 1)]
+    public void Multiplication_By_Scalar_From_Left_Works_Correctly(float r1, float g1, float b1, float a1, float scalar,
+        float r2, float g2, float b2, float a2)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var result = scalar * color1;
+        Assert.Equal(new Color(r2, g2, b2, a2), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0)]
+    [InlineData(1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0)]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, 1, 1, 1, 1, -0.5f, -0.5f, -0.5f, -0.5f)]
+    public void Subtraction_Operator_Works_Correctly(float r1, float g1, float b1, float a1, float r2, float g2,
+        float b2, float a2, float r3, float g3, float b3, float a3)
+    {
+        var color1 = new Color(r1, g1, b1, a1);
+        var color2 = new Color(r2, g2, b2, a2);
+        var result = color1 - color2;
+        Assert.Equal(new Color(r3, g3, b3, a3), result);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 1, "RGBA(0, 0, 0, 1)")]
+    [InlineData(1, 1, 1, 1, "RGBA(1, 1, 1, 1)")]
+    [InlineData(0.5f, 0.5f, 0.5f, 0.5f, "RGBA(0.5, 0.5, 0.5, 0.5)")]
+    public void ToString_Returns_Correct_Value(float r, float g, float b, float a, string expected)
+    {
+        var color = new Color(r, g, b, a);
+        Assert.Equal(expected, color.ToString());
+    }
+}

Prowl.Runtime.Test/Prowl.Runtime.Test.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.0" />
+    <PackageReference Include="NSubstitute" Version="5.1.0" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
+    <PackageReference Include="Serilog.Sinks.InMemory" Version="0.11.0" />
+    <PackageReference Include="Xunit" Version="2.9.0"/>
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Prowl.Runtime\Prowl.Runtime.csproj" />
+  </ItemGroup>
+
+</Project>

Prowl.Runtime.Test/Utiels/ProwlHashTests.cs

@@ -0,0 +1,122 @@
+using Xunit;
+using Prowl.Runtime.Utils;
+using System.Collections.Generic;
+
+namespace Prowl.Runtime.Test;
+
+public class ProwlHashTests
+{
+    public ProwlHashTests()
+    {
+        // Set a fixed value for the seed
+        ProwlHash.SeedManual = 0x123456789ABCDEF0UL;
+    }
+
+    [Theory]
+    [InlineData("", 13569540178974592407)]
+    [InlineData("123", 7707378966477012731)]
+    [InlineData("test", 9346148116625605736)]
+    public void Combine_Single_Value_Returns_Correct_Hash(string value1, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1);
+        var hash2 = ProwlHash.Combine(value1);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", 10873466195532498287)]
+    [InlineData("123", "456", 1945557290808424639)]
+    [InlineData("test", "test", 4673952114721371577)]
+    public void Combine_Two_Values_Returns_Correct_Hash(string value1, string value2, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2);
+        var hash2 = ProwlHash.Combine(value1, value2);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", 5681187302953179555)]
+    [InlineData("123", "456", "789", 17339108166904176167)]
+    [InlineData("test", "test", "test", 195190639239374894)]
+    public void Combine_Three_Values_Returns_Correct_Hash(string value1, string value2, string value3, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3);
+        var hash2 = ProwlHash.Combine(value1, value2, value3);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", "", 13030809851397991348)]
+    [InlineData("123", "456", "789", "0", 82805104907432925)]
+    [InlineData("test", "test", "test", "test", 14212001496189919417)]
+    public void Combine_Four_Values_Returns_Correct_Hash(string value1, string value2, string value3, string value4, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3, value4);
+        var hash2 = ProwlHash.Combine(value1, value2, value3, value4);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", "", "", 13030809851397991348)]
+    [InlineData("123", "456", "789", "0", "abc", 82805104907432925)]
+    [InlineData("test", "test", "test", "test", "test", 14212001496189919417)]
+    public void Combine_Five_Values_Returns_Correct_Hash(string value1, string value2, string value3, string value4, string value5, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3, value4, value5);
+        var hash2 = ProwlHash.Combine(value1, value2, value3, value4, value5);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", "", "", "", 13030809851397991348)]
+    [InlineData("123", "456", "789", "0", "abc", "def", 82805104907432925)]
+    [InlineData("test", "test", "test", "test", "test", "test", 14212001496189919417)]
+    public void Combine_Six_Values_Returns_Correct_Hash(string value1, string value2, string value3, string value4, string value5, string value6, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3, value4, value5, value6);
+        var hash2 = ProwlHash.Combine(value1, value2, value3, value4, value5, value6);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", "", "", "", "", 13030809851397991348)]
+    [InlineData("123", "456", "789", "0", "abc", "def", "ghi", 82805104907432925)]
+    [InlineData("test", "test", "test", "test", "test", "test", "test", 14212001496189919417)]
+    public void Combine_Seven_Values_Returns_Correct_Hash(string value1, string value2, string value3, string value4, string value5, string value6, string value7, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3, value4, value5, value6, value7);
+        var hash2 = ProwlHash.Combine(value1, value2, value3, value4, value5, value6, value7);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData("", "", "", "", "", "", "", "", 13030809851397991348)]
+    [InlineData("123", "456", "789", "0", "abc", "def", "ghi", "jkl", 82805104907432925)]
+    [InlineData("test", "test", "test", "test", "test", "test", "test", "test", 14212001496189919417)]
+    public void Combine_Eight_Values_Returns_Correct_Hash(string value1, string value2, string value3, string value4, string value5, string value6, string value7, string value8, ulong expectedHash)
+    {
+        var hash = ProwlHash.Combine(value1, value2, value3, value4, value5, value6, value7, value8);
+        var hash2 = ProwlHash.Combine(value1, value2, value3, value4, value5, value6, value7, value8);
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+
+    [Theory]
+    [InlineData(new[] { "test" }, 917506797)]
+    [InlineData(new[] { "123", "456" }, 4085393)]
+    [InlineData(new[] { "abc", "def", "ghi" }, 29313636)]
+    public void OrderlessHash_Returns_Correct_Hash(string[] values, int expectedHash)
+    {
+        var hash = ProwlHash.OrderlessHash(values);
+        var hash2 = ProwlHash.OrderlessHash(values.Reverse());
+        Assert.Equal(hash2, hash);
+        Assert.Equal(expectedHash, hash);
+    }
+}