Add support for querying for non-existing values

Genbox · Genbox · commit 97fdc4b055ac · 2025-07-28T23:09:24.000+02:00
diff --git a/Src/FastData.Generator.CPlusPlus.Tests/VectorTests.cs b/Src/FastData.Generator.CPlusPlus.Tests/VectorTests.cs
@@ -41,6 +41,11 @@ int main()
                                                                   return 0;
                                                           """, "\n")}}
 
+                          {{FormatList(vector.NotPresent, x => $"""
+                                                                    if ({spec.Identifier}::contains({map.ToValueLabel(x)}))
+                                                                        return 0;
+                                                                """, "\n")}}
+
                               return 1;
                           }
                           """;
diff --git a/Src/FastData.Generator.CPlusPlus.Tests/Vectors/SingleValueStructure_String_1.verified.txt b/Src/FastData.Generator.CPlusPlus.Tests/Vectors/SingleValueStructure_String_1.verified.txt
@@ -10,10 +10,10 @@ class SingleValueStructure_String_1 final {
 public:
     [[nodiscard]]
     static constexpr bool contains(const std::string_view key) noexcept {
-        return key == "value]";
+        return key == "value";
     }
 
     static constexpr size_t item_count = 1;
-    static constexpr size_t min_key_length = 6;
-    static constexpr size_t max_key_length = 6;
+    static constexpr size_t min_key_length = 5;
+    static constexpr size_t max_key_length = 5;
 };
diff --git a/Src/FastData.Generator.CSharp.Tests/VectorTests.cs b/Src/FastData.Generator.CSharp.Tests/VectorTests.cs
@@ -41,6 +41,11 @@ public static bool Run()
                                                                    return false;
                                                            """, "\n")}}
 
+                           {{FormatList(vector.NotPresent, x => $"""
+                                                                     if ({spec.Identifier}.Contains({map.ToValueLabel(x)}))
+                                                                         return false;
+                                                                 """, "\n")}}
+
                                    return true;
                                }
                            }
diff --git a/Src/FastData.Generator.CSharp.Tests/Vectors/SingleValueStructure_String_1.verified.txt b/Src/FastData.Generator.CSharp.Tests/Vectors/SingleValueStructure_String_1.verified.txt
@@ -11,10 +11,10 @@ internal static class SingleValueStructure_String_1
     
     public static bool Contains(string key)
     {
-        return StringComparer.Ordinal.Equals(key, "value]");
+        return StringComparer.Ordinal.Equals(key, "value");
     }
 
     public const uint ItemCount = 1;
-    public const uint MinKeyLength = 6;
-    public const uint MaxKeyLength = 6;
+    public const uint MinKeyLength = 5;
+    public const uint MaxKeyLength = 5;
 }
diff --git a/Src/FastData.Generator.Rust.Tests/VectorTests.cs b/Src/FastData.Generator.Rust.Tests/VectorTests.cs
@@ -40,6 +40,12 @@ fn main() {
                                                }
                                                """, "\n")}}
 
+              {{FormatList(vector.NotPresent, x => $$"""
+                                                         if {{spec.Identifier}}::contains({{map.ToValueLabel(x)}}) {
+                                                             std::process::exit(0);
+                                                     }
+                                                     """, "\n")}}
+
                   std::process::exit(1);
               }
               """);
diff --git a/Src/FastData.Generator.Rust.Tests/Vectors/SingleValueStructure_String_1.verified.txt b/Src/FastData.Generator.Rust.Tests/Vectors/SingleValueStructure_String_1.verified.txt
@@ -11,10 +11,10 @@ pub struct SingleValueStructure_String_1;
 impl SingleValueStructure_String_1 {
     #[must_use]
     pub fn contains(key: &'static str) -> bool {
-        key == "value]"
+        key == "value"
     }
 
     pub const ITEM_COUNT: usize = 1;
-    pub const MIN_KEY_LENGTH: usize = 6;
-    pub const MAX_KEY_LENGTH: usize = 6;
+    pub const MIN_KEY_LENGTH: usize = 5;
+    pub const MAX_KEY_LENGTH: usize = 5;
 }
diff --git a/Src/FastData.Generator/Helpers/FormatHelper.cs b/Src/FastData.Generator/Helpers/FormatHelper.cs
@@ -22,6 +22,9 @@ public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<T, string> Ren
 
     public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<int, T, string> Render, int indent = 8, int columns = 10)
     {
+        if (items.Length == 0)
+            return string.Empty;
+
         StringBuilder sb = new StringBuilder();
         int count = 0;
 
@@ -49,16 +52,19 @@ public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<int, T, string
         return sb.ToString();
     }
 
-    public static string FormatList<T>(T[] data, Func<T, string> render, string delim = ", ")
+    public static string FormatList<T>(T[] items, Func<T, string> render, string delim = ", ")
     {
-        return FormatList(data.AsReadOnlySpan(), render, delim);
+        return FormatList(items.AsReadOnlySpan(), render, delim);
     }
 
-    public static string FormatList<T>(ReadOnlySpan<T> data, Func<T, string> render, string delim = ", ")
+    public static string FormatList<T>(ReadOnlySpan<T> items, Func<T, string> render, string delim = ", ")
     {
+        if (items.Length == 0)
+            return string.Empty;
+
         StringBuilder sb = new StringBuilder();
 
-        foreach (T item in data)
+        foreach (T item in items)
         {
             sb.Append(render(item));
             sb.Append(delim);
diff --git a/Src/FastData.InternalShared/Helpers/TestVectorHelper.cs b/Src/FastData.InternalShared/Helpers/TestVectorHelper.cs
@@ -105,9 +105,9 @@ public static IEnumerable<ITestData> GetBenchmarkData()
         }
     }
 
-    private static IEnumerable<ITestVector> GenerateTestVectors(IEnumerable<(Type, object[])> data, string? postfix = null, params Type[] dataStructs)
+    private static IEnumerable<ITestVector> GenerateTestVectors(IEnumerable<(Type, object[], object[])> data, string? postfix = null, params Type[] dataStructs)
     {
-        foreach ((Type vt, object[] values) in data)
+        foreach ((Type vt, object[] values, object[] notValues) in data)
         {
             foreach (Type st in dataStructs)
             {
@@ -118,9 +118,15 @@ private static IEnumerable<ITestVector> GenerateTestVectors(IEnumerable<(Type, o
                     arr.SetValue(values[i], i);
                 }
 
+                Array arr2 = Array.CreateInstance(vt, notValues.Length);
+                for (int i = 0; i < notValues.Length; i++)
+                {
+                    arr2.SetValue(notValues[i], i);
+                }
+
                 //Create an instance of TestVector<T> and give it the type of the structure
                 Type vector = typeof(TestVector<>).MakeGenericType(vt);
-                yield return (ITestVector)Activator.CreateInstance(vector, st, arr, postfix)!;
+                yield return (ITestVector)Activator.CreateInstance(vector, st, arr, arr2, postfix)!;
             }
         }
     }
@@ -129,57 +135,57 @@ private static IEnumerable<ITestVector> GenerateTestVectors(IEnumerable<(Type, o
     private static IEnumerable<ITestVector> GenerateTestVectors<T>(IEnumerable<T[]> data, params Type[] dataStructs)
     {
         Type type = typeof(T);
-        return GenerateTestVectors(data.Select(x => (type, x.Cast<object>().ToArray())), null, dataStructs);
+        return GenerateTestVectors(data.Select(x => (type, x.Cast<object>().ToArray(), Array.Empty<object>())), null, dataStructs);
     }
 
-    private static IEnumerable<(Type type, object[] value)> GetEdgeCaseValues() =>
+    private static IEnumerable<(Type type, object[] value, object[] notValue)> GetEdgeCaseValues() =>
     [
 
         // We want to test edge values
-        (typeof(sbyte), [sbyte.MinValue, (sbyte)-1, (sbyte)0, (sbyte)1, sbyte.MaxValue]),
-        (typeof(byte), [(byte)0, (byte)1, byte.MaxValue]),
+        (typeof(sbyte), [sbyte.MinValue, (sbyte)-1, (sbyte)0, (sbyte)1, sbyte.MaxValue], [(sbyte)-2, (sbyte)2]),
+        (typeof(byte), [(byte)0, (byte)1, byte.MaxValue], [(byte)2, (byte)3]),
 
         //We keep it within ASCII range as C#'s char does not translate to other languages
-        (typeof(char), ['\0', 'a', (char)127]),
-        (typeof(double), [double.MinValue, 0.0, 1.0, double.MaxValue]),
-        (typeof(float), [float.MinValue, -1f, 0f, 1f, float.MaxValue]),
-        (typeof(short), [short.MinValue, (short)-1, (short)0, (short)1, short.MaxValue]),
-        (typeof(ushort), [(ushort)0, (ushort)1, (ushort)2, ushort.MaxValue]),
-        (typeof(int), [int.MinValue, -1, 0, 1, int.MaxValue]),
-        (typeof(uint), [0U, 1U, 2U, uint.MaxValue]),
-        (typeof(long), [long.MinValue, -1L, 0L, 1L, long.MaxValue]),
-        (typeof(ulong), [0UL, 1UL, 2UL, ulong.MaxValue]),
-        (typeof(string), ["a", "item", new string('a', 255)])
+        (typeof(char), ['\0', 'a', (char)127], [(char)1, 'b']),
+        (typeof(double), [double.MinValue, 0.0, 1.0, double.MaxValue], [1.1, 2.0]),
+        (typeof(float), [float.MinValue, -1f, 0f, 1f, float.MaxValue], [1.1f, 2.0f]),
+        (typeof(short), [short.MinValue, (short)-1, (short)0, (short)1, short.MaxValue], [(short)-2, (short)2]),
+        (typeof(ushort), [(ushort)0, (ushort)1, (ushort)2, ushort.MaxValue], [(ushort)3, (ushort)4]),
+        (typeof(int), [int.MinValue, -1, 0, 1, int.MaxValue], [-2, 2]),
+        (typeof(uint), [0U, 1U, 2U, uint.MaxValue], [3U, 4U]),
+        (typeof(long), [long.MinValue, -1L, 0L, 1L, long.MaxValue], [-2L, 2L]),
+        (typeof(ulong), [0UL, 1UL, 2UL, ulong.MaxValue], [3UL, 4UL]),
+        (typeof(string), ["a", "item", new string('a', 255)], ["b", "item2"])
     ];
 
-    private static IEnumerable<(Type type, object[] value)> GetFloatSpecialCases() =>
+    private static IEnumerable<(Type type, object[] value, object[] notValue)> GetFloatSpecialCases() =>
     [
 
         //If we don't have zero or NaN, we can use a simple hash
-        (typeof(float), [1, 2, 3, 4, 5]),
-        (typeof(double), [1, 2, 3, 4, 5]),
+        (typeof(float), [1, 2, 3, 4, 5], []),
+        (typeof(double), [1, 2, 3, 4, 5], []),
     ];
 
-    private static IEnumerable<(Type type, object[] value)> GetDataOfSize(int size) =>
+    private static IEnumerable<(Type type, object[] value, object[] notValue)> GetDataOfSize(int size) =>
     [
-        (typeof(int), Enumerable.Range(0, size).Select(x => x).Cast<object>().ToArray()),
-        (typeof(float), Enumerable.Range(0, size).Select(x => (float)x).Cast<object>().ToArray()),
-        (typeof(string), Enumerable.Range(0, size).Select(x => x.ToString(NumberFormatInfo.InvariantInfo)).Cast<object>().ToArray())
+        (typeof(int), Enumerable.Range(0, size).Select(x => x).Cast<object>().ToArray(), Enumerable.Range(size, size * 2).Select(x => x).Cast<object>().ToArray()),
+        (typeof(float), Enumerable.Range(0, size).Select(x => (float)x).Cast<object>().ToArray(), Enumerable.Range(size, size * 2).Select(x => (float)x).Cast<object>().ToArray()),
+        (typeof(string), Enumerable.Range(0, size).Select(x => x.ToString(NumberFormatInfo.InvariantInfo)).Cast<object>().ToArray(), Enumerable.Range(size, size * 2).Select(x => x.ToString(NumberFormatInfo.InvariantInfo)).Cast<object>().ToArray())
     ];
 
-    private static IEnumerable<(Type type, object[] value)> GetSingleValues() =>
+    private static IEnumerable<(Type type, object[] value, object[] notValue)> GetSingleValues() =>
     [
-        (typeof(sbyte), [(sbyte)1]),
-        (typeof(byte), [(byte)1]),
-        (typeof(char), ['a']),
-        (typeof(double), [1.0]),
-        (typeof(float), [1f]),
-        (typeof(short), [(short)1]),
-        (typeof(ushort), [(ushort)1]),
-        (typeof(int), [1]),
-        (typeof(uint), [1U]),
-        (typeof(long), [1L]),
-        (typeof(ulong), [1UL]),
-        (typeof(string), ["value]"])
+        (typeof(sbyte), [(sbyte)1], [(sbyte)2]),
+        (typeof(byte), [(byte)1], [(byte)2]),
+        (typeof(char), ['a'], ['b']),
+        (typeof(double), [1.0], [2.0]),
+        (typeof(float), [1f], [2f]),
+        (typeof(short), [(short)1], [(short)2]),
+        (typeof(ushort), [(ushort)1], [(ushort)2]),
+        (typeof(int), [1], [2]),
+        (typeof(uint), [1U], [2U]),
+        (typeof(long), [1L], [2L]),
+        (typeof(ulong), [1UL], [2UL]),
+        (typeof(string), ["value"], ["eulav"])
     ];
 }
diff --git a/Src/FastData.InternalShared/TestClasses/TestVector.cs b/Src/FastData.InternalShared/TestClasses/TestVector.cs
@@ -3,11 +3,12 @@
 
 namespace Genbox.FastData.InternalShared.TestClasses;
 
-public class TestVector<TKey>(Type type, TKey[] keys, string? postfix = null) : ITestVector, IXunitSerializable
+public class TestVector<TKey>(Type type, TKey[] keys, TKey[] notPresent, string? postfix = null) : ITestVector, IXunitSerializable
 {
     private readonly DataType _dataType = Enum.Parse<DataType>(typeof(TKey).Name);
 
     public TKey[] Keys { get; private set; } = keys;
+    public TKey[] NotPresent { get; } = notPresent;
     public Type Type { get; private set; } = type;
 
     public string Identifier => $"{Type.Name.Replace("`1", "", StringComparison.Ordinal).Replace("`2", "", StringComparison.Ordinal)}_{_dataType}_{Keys.Length}" + (postfix != null ? $"_{postfix}" : "");

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,11 @@ public static bool Run()`
`41`	`41`	`return false;`
`42`	`42`	`""", "\n")}}`
`43`	`43`
	`44`	`+ {{FormatList(vector.NotPresent, x => $"""`
	`45`	`+ if ({spec.Identifier}.Contains({map.ToValueLabel(x)}))`
	`46`	`+ return false;`
	`47`	`+ """, "\n")}}`
	`48`	`+`
`44`	`49`	`return true;`
`45`	`50`	`}`
`46`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ internal static class SingleValueStructure_String_1`
`11`	`11`
`12`	`12`	`public static bool Contains(string key)`
`13`	`13`	`{`
`14`		`- return StringComparer.Ordinal.Equals(key, "value]");`
	`14`	`+ return StringComparer.Ordinal.Equals(key, "value");`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public const uint ItemCount = 1;`
`18`		`- public const uint MinKeyLength = 6;`
`19`		`- public const uint MaxKeyLength = 6;`
	`18`	`+ public const uint MinKeyLength = 5;`
	`19`	`+ public const uint MaxKeyLength = 5;`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,12 @@ fn main() {`
`40`	`40`	`}`
`41`	`41`	`""", "\n")}}`
`42`	`42`
	`43`	`+ {{FormatList(vector.NotPresent, x => $$"""`
	`44`	`+ if {{spec.Identifier}}::contains({{map.ToValueLabel(x)}}) {`
	`45`	`+ std::process::exit(0);`
	`46`	`+ }`
	`47`	`+ """, "\n")}}`
	`48`	`+`
`43`	`49`	`std::process::exit(1);`
`44`	`50`	`}`
`45`	`51`	`""");`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ pub struct SingleValueStructure_String_1;`
`11`	`11`	`impl SingleValueStructure_String_1 {`
`12`	`12`	`#[must_use]`
`13`	`13`	`pub fn contains(key: &'static str) -> bool {`
`14`		`- key == "value]"`
	`14`	`+ key == "value"`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`pub const ITEM_COUNT: usize = 1;`
`18`		`- pub const MIN_KEY_LENGTH: usize = 6;`
`19`		`- pub const MAX_KEY_LENGTH: usize = 6;`
	`18`	`+ pub const MIN_KEY_LENGTH: usize = 5;`
	`19`	`+ pub const MAX_KEY_LENGTH: usize = 5;`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,9 @@ public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<T, string> Ren`
`22`	`22`
`23`	`23`	`public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<int, T, string> Render, int indent = 8, int columns = 10)`
`24`	`24`	`{`
	`25`	`+ if (items.Length == 0)`
	`26`	`+ return string.Empty;`
	`27`	`+`
`25`	`28`	`StringBuilder sb = new StringBuilder();`
`26`	`29`	`int count = 0;`
`27`	`30`
`@@ -49,16 +52,19 @@ public static string FormatColumns<T>(ReadOnlySpan<T> items, Func<int, T, string`
`49`	`52`	`return sb.ToString();`
`50`	`53`	`}`
`51`	`54`
`52`		`- public static string FormatList<T>(T[] data, Func<T, string> render, string delim = ", ")`
	`55`	`+ public static string FormatList<T>(T[] items, Func<T, string> render, string delim = ", ")`
`53`	`56`	`{`
`54`		`- return FormatList(data.AsReadOnlySpan(), render, delim);`
	`57`	`+ return FormatList(items.AsReadOnlySpan(), render, delim);`
`55`	`58`	`}`
`56`	`59`
`57`		`- public static string FormatList<T>(ReadOnlySpan<T> data, Func<T, string> render, string delim = ", ")`
	`60`	`+ public static string FormatList<T>(ReadOnlySpan<T> items, Func<T, string> render, string delim = ", ")`
`58`	`61`	`{`
	`62`	`+ if (items.Length == 0)`
	`63`	`+ return string.Empty;`
	`64`	`+`
`59`	`65`	`StringBuilder sb = new StringBuilder();`
`60`	`66`
`61`		`- foreach (T item in data)`
	`67`	`+ foreach (T item in items)`
`62`	`68`	`{`
`63`	`69`	`sb.Append(render(item));`
`64`	`70`	`sb.Append(delim);`