Add last change tests and fixes

Author: LoneWandererProductions

CommonExtendedObjectsTests/ImmutableLookupMapAllTests.cs

@@ -139,8 +139,6 @@ public void TestReadOnlyDictionaryLookup()
             Trace.WriteLine($"ReadOnlyDictionary Lookup Time: {stopwatch.ElapsedMilliseconds} ms");
         }
 
-        // ------------ UNMANAGED MAP TESTS ----------------
-
         /// <summary>
         ///     Tests the unmanaged map initialization.
         /// </summary>
@@ -277,5 +275,93 @@ public void TestInitializationAndLookupPerformanceComparison()
             Assert.AreEqual(iterations, stringMap.ToList().Count);
             Assert.AreEqual(iterations, readOnlyMap.Count);
         }
+
+        /// <summary>
+        /// Tests the collision robustness.
+        /// </summary>
+        [TestMethod]
+        public void TestCollisionRobustness()
+        {
+            var data = new Dictionary<int, string>();
+            // Using multiples of large numbers often creates hash clusters
+            for (int i = 0; i < 100; i++)
+            {
+                data[i * 1024] = $"CollisionValue_{i}";
+            }
+
+            var map = new ImmutableLookupMap<int, string>(data);
+
+            foreach (var key in data.Keys)
+            {
+                Assert.AreEqual(data[key], map.Get(key), $"Failed to find key {key} after potential collision.");
+            }
+        }
+
+        /// <summary>
+        /// Tests the minimum capacity.
+        /// </summary>
+        [TestMethod]
+        public void TestMinimumCapacity()
+        {
+            var data = new Dictionary<int, int> { { 1, 100 } };
+            var map = new ImmutableLookupMap<int, int>(data);
+
+            Assert.AreEqual(100, map.Get(1));
+            Assert.IsFalse(map.TryGetValue(2, out _));
+        }
+
+        /// <summary>
+        /// Tests the key not found throws correctly.
+        /// </summary>
+        [TestMethod]
+        [ExpectedException(typeof(KeyNotFoundException))]
+        public void TestKeyNotFoundThrowsCorrectly()
+        {
+            var data = new Dictionary<int, string> { { 10, "Ten" }, { 20, "Twenty" } };
+            var map = new ImmutableLookupMap<int, string>(data);
+
+            // This should trigger the break in the probe loop and throw
+            map.Get(99);
+        }
+
+        /// <summary>
+        /// Tests the negative keys.
+        /// </summary>
+        [TestMethod]
+        public void TestNegativeKeys()
+        {
+            var data = new Dictionary<int, float>
+            {
+                { -1, 1.1f },
+                { -500, 5.5f },
+                { int.MinValue, 0.0f }
+            };
+
+            using var map = new ImmutableLookupMapUnmanaged<int, float>(data);
+
+            foreach (var kvp in data)
+            {
+                Assert.AreEqual(kvp.Value, map.Get(kvp.Key), $"Failed for negative key: {kvp.Key}");
+            }
+        }
+
+        /// <summary>
+        /// Tests the sparse key spread.
+        /// </summary>
+        [TestMethod]
+        public void TestSparseKeySpread()
+        {
+            var data = new Dictionary<int, string>
+            {
+                { 1, "First" },
+                { 1_000_000, "Million" },
+                { int.MaxValue, "Max" }
+            };
+
+            var map = new ImmutableLookupMap<int, string>(data);
+
+            Assert.AreEqual("Million", map.Get(1_000_000));
+            Assert.AreEqual("Max", map.Get(int.MaxValue));
+        }
     }
 }

ExtendedSystemObjects/ImmutableLookupMap.cs

@@ -14,6 +14,7 @@
 using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 using ExtendedSystemObjects.Helper;
 
 namespace ExtendedSystemObjects
@@ -76,7 +77,7 @@ public ImmutableLookupMap(IDictionary<TKey, TValue> data)
                 for (int i = 0; i < capacity; i++)
                 {
                     // Linear probe: check the next slot
-                    int index = (hash + i) & mask;
+                    int index = (int)((uint)(hash + i) & (uint)mask);
 
                     if (!_keyPresence[index])
                     {
@@ -193,16 +194,17 @@ public bool TryGetValue(TKey key, out TValue value)
         // Helper Methods
 
         /// <summary>
-        ///     Gets the hash.
+        /// Gets the hash.
         /// </summary>
         /// <param name="key">The key.</param>
-        /// <param name="capacity">The capacity.</param>
-        /// <returns>Hash Value</returns>
+        /// <returns>
+        /// Hash Value
+        /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int GetHash(TKey key)
         {
-            // Math.Abs is good to ensure we don't get negative indices before masking
-            return Math.Abs(key.GetHashCode());
+            // Return the raw hash code. Do NOT use Math.Abs.
+            return key.GetHashCode();
         }
     }
 }

ExtendedSystemObjects/ImmutableLookupMapUnmanaged.cs

@@ -83,7 +83,7 @@ public ImmutableLookupMapUnmanaged(IDictionary<TKey, TValue> data)
                 // 2. Linear Probing for cache line efficiency
                 for (var i = 0; i < _capacity; i++)
                 {
-                    int index = (hash + i) & _mask;
+                    int index = (int)((uint)(hash + i) & (uint)_mask);
                     Entry* entry = entriesPtr + index;
 
                     if (entry->IsPresent == 0)
@@ -221,7 +221,7 @@ public bool TryGetValue(TKey key, out TValue value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int GetHash(TKey key)
         {
-            return Math.Abs(key.GetHashCode());
+            return key.GetHashCode();
         }
     }
 }