Fixed Enumerator bugs.

Author: JunaMeinhold

Hexa.NET.Utilities.Tests/UnsafeDictionaryTests.cs

@@ -5,6 +5,73 @@
     [TestFixture]
     public class UnsafeDictionaryTests
     {
+        [Test]
+        public void TestEnumerator()
+        {
+            UnsafeDictionary<uint, int> dict = default;
+            dict[1] = 10;
+            dict[2] = 20;
+            dict[3] = 30;
+
+            IEnumerator<KeyValuePair<uint, int>> enumerator = dict.GetEnumerator();
+
+            // Act
+            var result = new List<KeyValuePair<uint, int>>();
+            while (enumerator.MoveNext())
+            {
+                result.Add(enumerator.Current);
+            }
+
+            // Assert
+            var expected = new List<KeyValuePair<uint, int>>
+            {
+                new KeyValuePair<uint, int>(1, 10),
+                new KeyValuePair<uint, int>(2, 20),
+                new KeyValuePair<uint, int>(3, 30)
+            };
+
+            Assert.That(result, Is.EquivalentTo(expected));
+
+            dict.Release();
+        }
+
+        [Test]
+        public void TestKeyValueEnumerator()
+        {
+            // Arrange
+            UnsafeDictionary<uint, int> dict = new UnsafeDictionary<uint, int>();
+
+            // Populate the dictionary with data
+            dict[1] = 10;
+            dict[2] = 20;
+            dict[3] = 30;
+
+            // Act & Assert for Key Enumerator
+            IEnumerator<uint> keyEnumerator = dict.Keys.GetEnumerator();
+            var keyResult = new List<uint>();
+            while (keyEnumerator.MoveNext())
+            {
+                keyResult.Add(keyEnumerator.Current);
+            }
+
+            var expectedKeys = new List<uint> { 1, 2, 3 };
+            Assert.That(keyResult, Is.EquivalentTo(expectedKeys));
+
+            // Act & Assert for Value Enumerator
+            IEnumerator<int> valueEnumerator = dict.Values.GetEnumerator();
+            var valueResult = new List<int>();
+            while (valueEnumerator.MoveNext())
+            {
+                valueResult.Add(valueEnumerator.Current);
+            }
+
+            var expectedValues = new List<int> { 10, 20, 30 };
+            Assert.That(valueResult, Is.EquivalentTo(expectedValues));
+
+            // Clean up
+            dict.Release();
+        }
+
         [Test]
         public void TestInitialAdd()
         {
@@ -64,7 +131,7 @@ public void TestRemoveKey()
 
             dict.Remove(1);
 
-            Assert.IsFalse(dict.ContainsKey(1));
+            Assert.That(dict.ContainsKey(1), Is.False);
             Assert.That(dict[2], Is.EqualTo(3));
 
             foreach (var item in dict)
@@ -83,7 +150,7 @@ public void TestRemoveNonExistentKey()
             Assert.DoesNotThrow(() => dict.Remove(2));
 
             Assert.That(dict[1], Is.EqualTo(2));
-            Assert.IsFalse(dict.ContainsKey(2));
+            Assert.That(dict.ContainsKey(2), Is.False);
 
             foreach (var item in dict)
             {
@@ -96,7 +163,7 @@ public void TestRemoveNonExistentKey()
         public void TestEmptyDictionary()
         {
             UnsafeDictionary<uint, int> dict = default;
-            Assert.IsEmpty(dict);
+            Assert.That(dict, Is.Empty);
 
             foreach (var item in dict)
             {
@@ -120,7 +187,7 @@ public void TestReleaseResources()
             dict[2] = 3;
 
             // Since dictionary is reallocated, previous values should not exist
-            Assert.IsFalse(dict.ContainsKey(1));
+            Assert.That(dict.ContainsKey(1), Is.False);
             Assert.That(dict[2], Is.EqualTo(3));
 
             foreach (var item in dict)
@@ -129,7 +196,7 @@ public void TestReleaseResources()
             }
 
             // Verify that the dictionary's capacity and size have been updated correctly
-            Assert.Greater(dict.Capacity, 0);
+            Assert.That(dict.Capacity, Is.EqualTo(3));
             Assert.That(dict.Size, Is.EqualTo(1));
 
             // Release the dictionary again

Hexa.NET.Utilities.Tests/UnsafeHashSetTests.cs

@@ -5,6 +5,36 @@
     [TestFixture]
     public class UnsafeHashSetTests
     {
+        [Test]
+        public void TestEnumerator()
+        {
+            UnsafeHashSet<int> dict = default;
+            dict.Add(10);
+            dict.Add(20);
+            dict.Add(30);
+
+            IEnumerator<int> enumerator = dict.GetEnumerator();
+
+            // Act
+            var result = new List<int>();
+            while (enumerator.MoveNext())
+            {
+                result.Add(enumerator.Current);
+            }
+
+            // Assert
+            var expected = new List<int>
+            {
+                10,
+                20,
+                30
+            };
+
+            Assert.That(result, Is.EquivalentTo(expected));
+
+            dict.Release();
+        }
+
         [Test]
         public void TestAdd()
         {
@@ -205,7 +235,7 @@ public void Contains_ShouldReturnTrueIfItemExists()
             bool contains = list.Contains(42);
 
             // Assert
-            Assert.IsTrue(contains);
+            Assert.That(contains, Is.True);
 
             list.Release();
         }
@@ -239,7 +269,7 @@ public void Remove_ShouldRemoveItemIfExists()
             bool removed = list.Remove(42);
 
             // Assert
-            Assert.IsTrue(removed);
+            Assert.That(removed, Is.True);
             Assert.That(list.Count, Is.EqualTo(1));
             Assert.That(list[0], Is.EqualTo(24));
 

Hexa.NET.Utilities/Hexa.NET.Utilities.csproj

@@ -19,7 +19,7 @@
 	<PropertyGroup>
 		<PackageId>Hexa.NET.Utilities</PackageId>
 		<AssemblyVersion>1.0.0</AssemblyVersion>
-		<PackageVersion>2.1.13</PackageVersion>
+		<PackageVersion>2.1.14</PackageVersion>
 		<Authors>Juna</Authors>
 		<AssemblyName>Hexa.NET.Utilities</AssemblyName>
 		<PackageProjectUrl>https://github.com/HexaEngine/Hexa.NET.Utilities</PackageProjectUrl>

Hexa.NET.Utilities/UnsafeDictionary.cs

@@ -13,14 +13,14 @@ public unsafe struct UnsafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>,
 
         private const float loadFactor = 0.75f;
 
-        internal enum EntryFlags : byte
+        public enum EntryFlags : byte
         {
             Empty = 0,
             Tombstone = 1,
             Filled = 2
         }
 
-        internal struct Entry
+        public struct Entry
         {
             public uint HashCode;
             public TKey Key;
@@ -118,6 +118,14 @@ public UnsafeDictionary(IEnumerable<KeyValuePair<TKey, TValue>> keyValuePairs, d
             TrimExcess();
         }
 
+        public UnsafeDictionary(Entry* buckets, int capacity, int size, delegate*<TKey, TKey, bool>* comparer)
+        {
+            this.buckets = buckets;
+            this.capacity = capacity;
+            this.size = size;
+            this.comparer = comparer;
+        }
+
         public void Release()
         {
             if (buckets != null)
@@ -470,7 +478,7 @@ public readonly void Dispose()
 
             public bool MoveNext()
             {
-                if (itemIndex >= dictionary.size - 1)
+                if (itemIndex >= dictionary.size)
                 {
                     return false;
                 }
@@ -544,7 +552,7 @@ readonly IEnumerator IEnumerable.GetEnumerator()
 
             public bool MoveNext()
             {
-                if (itemIndex >= dictionary.size - 1)
+                if (itemIndex >= dictionary.size)
                 {
                     return false;
                 }
@@ -618,7 +626,7 @@ readonly IEnumerator IEnumerable.GetEnumerator()
 
             public bool MoveNext()
             {
-                if (itemIndex >= dictionary.size - 1)
+                if (itemIndex >= dictionary.size)
                 {
                     return false;
                 }

Hexa.NET.Utilities/UnsafeHashSet.cs

@@ -369,12 +369,12 @@ public void CopyTo(T[] array, int arrayIndex, int count)
 
         public readonly IEnumerator<T> GetEnumerator()
         {
-            return new Enumerator();
+            return new Enumerator(this);
         }
 
         readonly IEnumerator IEnumerable.GetEnumerator()
         {
-            return new Enumerator();
+            return new Enumerator(this);
         }
 
         public void UnionWith(IEnumerable<T> other)
@@ -758,24 +758,19 @@ private struct Enumerator : IEnumerable<T>, IEnumerator<T>
             private UnsafeHashSet<T> hashSet;
             private int index;
             private int itemIndex;
-            private Entry* current;
+            private T current;
 
             public Enumerator(UnsafeHashSet<T> hashSet)
             {
                 this.hashSet = hashSet;
                 index = 0;
-                current = null;
             }
 
             public T Current
             {
                 get
                 {
-                    if (current == null)
-                    {
-                        throw new InvalidOperationException("The enumerator is positioned before the first element or after the last element.");
-                    }
-                    return current->Value;
+                    return current;
                 }
             }
 
@@ -810,20 +805,20 @@ public bool MoveNext()
                         continue;
                     }
 
-                    current = entry;
+                    current = entry->Value;
                     index = i + 1;
                     itemIndex++;
                     return true;
                 }
-                current = null;
+                current = default;
                 return false;
             }
 
             public void Reset()
             {
                 index = 0;
                 itemIndex = 0;
-                current = null;
+                current = default;
             }
         }