Convert sourcegen tests to verify

Author: Genbox

Src/FastData.SourceGenerator.Tests/SourceGeneratorTests.cs

@@ -29,33 +29,12 @@ public void GenericTest()
         Assert.False(func("dontexist"));
     }
 
-    [Theory]
-    [InlineData(StructureType.SingleValue)]
-    public void DataStructureSingleTest(StructureType ds)
-    {
-        string source = $"""
-                         using Genbox.FastData.SourceGenerator;
-                         using Genbox.FastData.Enums;
-
-                         [assembly: FastData<string>("StaticData", ["item1"], StructureType = StructureType.{ds})]
-                         """;
-
-        string output = RunGenerator(source);
-
-        Assert.Contains("Structure: " + ds, output, StringComparison.Ordinal);
-    }
-
     [Theory]
     [InlineData(StructureType.Array)]
     [InlineData(StructureType.Conditional)]
     [InlineData(StructureType.BinarySearch)]
-    [InlineData(StructureType.EytzingerSearch)]
-    [InlineData(StructureType.PerfectHashGPerf)]
-    [InlineData(StructureType.HashSetPerfect)]
-    [InlineData(StructureType.HashSetChain)]
-    [InlineData(StructureType.HashSetLinear)]
-    [InlineData(StructureType.KeyLength)]
-    public void DataStructureTest(StructureType ds)
+    [InlineData(StructureType.HashSet)]
+    public async Task DataStructureTest(StructureType ds)
     {
         string source = $"""
                          using Genbox.FastData.SourceGenerator;
@@ -65,12 +44,14 @@ public void DataStructureTest(StructureType ds)
                          """;
 
         string output = RunGenerator(source);
-
-        Assert.Contains("Structure: " + ds, output, StringComparison.Ordinal);
+        await Verify(output)
+              .UseFileName(ds.ToString())
+              .UseDirectory("Verify")
+              .DisableDiff();
     }
 
     [Fact]
-    public void NamespaceTest()
+    public async Task NamespaceTest()
     {
         const string source = """
                               using Genbox.FastData.SourceGenerator;
@@ -79,13 +60,16 @@ public void NamespaceTest()
                               """;
 
         string output = RunGenerator(source);
-        Assert.Contains("namespace MyNamespace;", output, StringComparison.Ordinal);
+        await Verify(output)
+              .UseFileName("namespace")
+              .UseDirectory("Verify")
+              .DisableDiff();
     }
 
     [Theory]
     [InlineData(ClassVisibility.Internal)]
     [InlineData(ClassVisibility.Public)]
-    public void ClassVisibilityTest(ClassVisibility visibility)
+    public async Task ClassVisibilityTest(ClassVisibility visibility)
     {
         string source = $"""
                          using Genbox.FastData.SourceGenerator;
@@ -96,25 +80,17 @@ public void ClassVisibilityTest(ClassVisibility visibility)
 
         string output = RunGenerator(source);
 
-        switch (visibility)
-        {
-            case ClassVisibility.Internal:
-                Assert.Contains("internal static class StaticData", output, StringComparison.Ordinal);
-                break;
-            case ClassVisibility.Public:
-                Assert.Contains("public static class StaticData", output, StringComparison.Ordinal);
-                break;
-            case ClassVisibility.Unknown:
-            default:
-                throw new ArgumentOutOfRangeException(nameof(visibility), visibility, null);
-        }
+        await Verify(output)
+              .UseFileName(visibility.ToString())
+              .UseDirectory("Verify")
+              .DisableDiff();
     }
 
     [Theory]
     [InlineData(ClassType.Static)]
     [InlineData(ClassType.Instance)]
     [InlineData(ClassType.Struct)]
-    public void ClassTypeTest(ClassType type)
+    public async Task ClassTypeTest(ClassType type)
     {
         string source = $"""
                          using Genbox.FastData.SourceGenerator;
@@ -125,21 +101,10 @@ public void ClassTypeTest(ClassType type)
 
         string output = RunGenerator(source);
 
-        switch (type)
-        {
-            case ClassType.Static:
-                Assert.Contains("static class StaticData", output, StringComparison.Ordinal);
-                break;
-            case ClassType.Instance:
-                Assert.Contains("partial class StaticData", output, StringComparison.Ordinal);
-                break;
-            case ClassType.Struct:
-                Assert.Contains("partial struct StaticData", output, StringComparison.Ordinal);
-                break;
-            case ClassType.Unknown:
-            default:
-                throw new ArgumentOutOfRangeException(nameof(type), type, null);
-        }
+        await Verify(output)
+              .UseFileName(type.ToString())
+              .UseDirectory("Verify")
+              .DisableDiff();
     }
 
     //TODO: Test StorageOptions
@@ -149,7 +114,7 @@ private static string RunGenerator(string source)
         string output = SourceGenHelper.RunSourceGenerator<Internal.FastDataSourceGenerator>(source, false, out var compilerDiagnostics, out var codeGenDiagnostics);
         Assert.Empty(compilerDiagnostics);
         Assert.Empty(codeGenDiagnostics);
-        Assert.NotEmpty(output); //We test source later in order to show diagnostics first
+        Assert.NotEmpty(output); //We test the source later to show diagnostics first
 
         return output;
     }

Src/FastData.SourceGenerator.Tests/Verify/Array.verified.txt

@@ -0,0 +1,33 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: Array
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal static class StaticData
+{
+    private static readonly string[] _entries = new string[] {
+        "item1", "item2", "item3"
+    };
+
+    
+    public static bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        for (int i = 0; i < 3; i++)
+        {
+            if (StringComparer.Ordinal.Equals(value, _entries[i]))
+               return true;
+        }
+        return false;
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}

Src/FastData.SourceGenerator.Tests/Verify/BinarySearch.verified.txt

@@ -0,0 +1,43 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: BinarySearch
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal static class StaticData
+{
+    private static readonly string[] _entries = new string[] {
+        "item1", "item2", "item3"
+    };
+
+    
+    public static bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        int lo = 0;
+        int hi = 2;
+        while (lo <= hi)
+        {
+            int i = lo + ((hi - lo) >> 1);
+            int order = StringComparer.Ordinal.Compare(_entries[i], value);
+
+            if (order == 0)
+                return true;
+            if (order < 0)
+                lo = i + 1;
+            else
+                hi = i - 1;
+        }
+
+        return ~lo >= 0;
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}

Src/FastData.SourceGenerator.Tests/Verify/Conditional.verified.txt

@@ -0,0 +1,32 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: Conditional
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal static class StaticData
+{
+    
+    public static bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        switch (value)
+        {
+            case "item1":
+            case "item2":
+            case "item3":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}

Src/FastData.SourceGenerator.Tests/Verify/HashSet.verified.txt

@@ -0,0 +1,78 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashSet
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal static class StaticData
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        1, 3, 2
+     };
+
+    private static readonly E[] _entries = {
+        new E(17825845005562073391, -1, "item1"), new E(17825845003995989450, -1, "item2"), new E(17825845002429905509, -1, "item3")
+    };
+
+    
+    public static bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        ulong hash = Hash(value);
+        uint index = (uint)(hash % 3);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (entry.HashCode == hash && StringComparer.Ordinal.Equals(value, entry.Value))
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(string value)
+    {
+        ulong hash = 352654597;
+
+        ref char ptr = ref MemoryMarshal.GetReference(value.AsSpan());
+        int len = value.Length;
+
+        while (len-- > 0)
+        {
+            hash = (((hash << 5) | (hash >> 27)) + hash) ^ ptr;
+            ptr = ref Unsafe.Add(ref ptr, 1);
+        }
+
+        return 352654597 + (hash * 1566083941);
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        internal readonly ulong HashCode;
+        internal readonly sbyte Next;
+        internal readonly string Value;
+
+        internal E(ulong hashCode, sbyte next, string value)
+        {
+            HashCode = hashCode;
+            Next = next;
+            Value = value;
+        }
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}

Src/FastData.SourceGenerator.Tests/Verify/Instance.verified.txt

@@ -0,0 +1,32 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal partial class StaticData
+{
+    
+    public bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        switch (value)
+        {
+            case "item1":
+            case "item2":
+            case "item3":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}

Src/FastData.SourceGenerator.Tests/Verify/Internal.verified.txt

@@ -0,0 +1,32 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+internal static class StaticData
+{
+    
+    public static bool Contains(string value)
+    {
+        if (value.Length != 5u)
+            return false;
+
+        switch (value)
+        {
+            case "item1":
+            case "item2":
+            case "item3":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public const uint ItemCount = 3;
+    public const uint MinLength = 5;
+    public const uint MaxLength = 5;
+}