fix: resolve all xUnit analyzer warnings and implement ChainedHashTable enumerator

Ahmad Alhour · Ahmad Alhour · commit 3e008c0509f7 · 2026-01-08T23:59:28.000+01:00
- Replace Assert.Equal(0/1, x.Count) with Assert.Empty/Assert.Single
- Replace Assert.True/False(x.Contains()) with Assert.Contains/DoesNotContain
- Implement ChainedHashTable.GetEnumerator() (was NotImplementedException)
- Remove xUnit warning suppression from UnitTest.csproj

All 623 tests pass with zero warnings.
diff --git a/DataStructures/Dictionaries/ChainedHashTable.cs b/DataStructures/Dictionaries/ChainedHashTable.cs
@@ -620,12 +620,24 @@ public void Clear()
 
         public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
         {
-            throw new NotImplementedException();
+            for (int i = 0; i < _hashTableStore.Length; i++)
+            {
+                var chain = _hashTableStore[i];
+                if (chain != null && chain.Count > 0)
+                {
+                    var node = chain.Head;
+                    while (node != null)
+                    {
+                        yield return new KeyValuePair<TKey, TValue>(node.Key, node.Value);
+                        node = node.Next;
+                    }
+                }
+            }
         }
 
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
         {
-            throw new NotImplementedException();
+            return GetEnumerator();
         }
 
     }
diff --git a/UnitTest/DataStructuresTests/GraphsDirectedDenseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsDirectedDenseGraphTest.cs
@@ -23,12 +23,12 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             var graph = CreateTestGraph();
 
             Assert.Equal(2, graph.OutgoingEdges("a").Count());
-            Assert.Equal(1, graph.OutgoingEdges("s").Count());
+            Assert.Single(graph.OutgoingEdges("s"));
             Assert.Equal(3, graph.OutgoingEdges("d").Count());
             Assert.Equal(3, graph.OutgoingEdges("x").Count());
             Assert.Equal(3, graph.OutgoingEdges("c").Count());
-            Assert.Equal(1, graph.OutgoingEdges("v").Count());
-            Assert.Equal(1, graph.OutgoingEdges("f").Count());
+            Assert.Single(graph.OutgoingEdges("v"));
+            Assert.Single(graph.OutgoingEdges("f"));
             Assert.Empty(graph.OutgoingEdges("z"));
         }
 
@@ -37,14 +37,14 @@ public static void IncomingEdges_ReturnsCorrectCounts()
         {
             var graph = CreateTestGraph();
 
-            Assert.Equal(1, graph.IncomingEdges("a").Count());
+            Assert.Single(graph.IncomingEdges("a"));
             Assert.Equal(2, graph.IncomingEdges("s").Count());
             Assert.Equal(2, graph.IncomingEdges("d").Count());
-            Assert.Equal(1, graph.IncomingEdges("x").Count());
+            Assert.Single(graph.IncomingEdges("x"));
             Assert.Equal(3, graph.IncomingEdges("c").Count());
-            Assert.Equal(1, graph.IncomingEdges("v").Count());
+            Assert.Single(graph.IncomingEdges("v"));
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsDirectedSparseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsDirectedSparseGraphTest.cs
@@ -23,12 +23,12 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             var graph = CreateTestGraph();
 
             Assert.Equal(2, graph.OutgoingEdges("a").Count());
-            Assert.Equal(1, graph.OutgoingEdges("s").Count());
+            Assert.Single(graph.OutgoingEdges("s"));
             Assert.Equal(3, graph.OutgoingEdges("d").Count());
             Assert.Equal(3, graph.OutgoingEdges("x").Count());
             Assert.Equal(3, graph.OutgoingEdges("c").Count());
-            Assert.Equal(1, graph.OutgoingEdges("v").Count());
-            Assert.Equal(1, graph.OutgoingEdges("f").Count());
+            Assert.Single(graph.OutgoingEdges("v"));
+            Assert.Single(graph.OutgoingEdges("f"));
             Assert.Empty(graph.OutgoingEdges("z"));
         }
 
@@ -37,14 +37,14 @@ public static void IncomingEdges_ReturnsCorrectCounts()
         {
             var graph = CreateTestGraph();
 
-            Assert.Equal(1, graph.IncomingEdges("a").Count());
+            Assert.Single(graph.IncomingEdges("a"));
             Assert.Equal(2, graph.IncomingEdges("s").Count());
             Assert.Equal(2, graph.IncomingEdges("d").Count());
-            Assert.Equal(1, graph.IncomingEdges("x").Count());
+            Assert.Single(graph.IncomingEdges("x"));
             Assert.Equal(3, graph.IncomingEdges("c").Count());
-            Assert.Equal(1, graph.IncomingEdges("v").Count());
+            Assert.Single(graph.IncomingEdges("v"));
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsDirectedWeightedDenseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsDirectedWeightedDenseGraphTest.cs
@@ -41,12 +41,12 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             var graph = CreateTestGraph();
 
             Assert.Equal(2, graph.OutgoingEdges("a").Count());
-            Assert.Equal(1, graph.OutgoingEdges("s").Count());
+            Assert.Single(graph.OutgoingEdges("s"));
             Assert.Equal(3, graph.OutgoingEdges("d").Count());
             Assert.Equal(3, graph.OutgoingEdges("x").Count());
             Assert.Equal(3, graph.OutgoingEdges("c").Count());
-            Assert.Equal(1, graph.OutgoingEdges("v").Count());
-            Assert.Equal(1, graph.OutgoingEdges("f").Count());
+            Assert.Single(graph.OutgoingEdges("v"));
+            Assert.Single(graph.OutgoingEdges("f"));
             Assert.Empty(graph.OutgoingEdges("z"));
         }
 
@@ -55,14 +55,14 @@ public static void IncomingEdges_ReturnsCorrectCounts()
         {
             var graph = CreateTestGraph();
 
-            Assert.Equal(1, graph.IncomingEdges("a").Count());
+            Assert.Single(graph.IncomingEdges("a"));
             Assert.Equal(2, graph.IncomingEdges("s").Count());
             Assert.Equal(2, graph.IncomingEdges("d").Count());
-            Assert.Equal(1, graph.IncomingEdges("x").Count());
+            Assert.Single(graph.IncomingEdges("x"));
             Assert.Equal(3, graph.IncomingEdges("c").Count());
-            Assert.Equal(1, graph.IncomingEdges("v").Count());
+            Assert.Single(graph.IncomingEdges("v"));
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsDirectedWeightedSparseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsDirectedWeightedSparseGraphTest.cs
@@ -23,12 +23,12 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             var graph = CreateTestGraph();
 
             Assert.Equal(2, graph.OutgoingEdges("a").Count());
-            Assert.Equal(1, graph.OutgoingEdges("s").Count());
+            Assert.Single(graph.OutgoingEdges("s"));
             Assert.Equal(3, graph.OutgoingEdges("d").Count());
             Assert.Equal(3, graph.OutgoingEdges("x").Count());
             Assert.Equal(3, graph.OutgoingEdges("c").Count());
-            Assert.Equal(1, graph.OutgoingEdges("v").Count());
-            Assert.Equal(1, graph.OutgoingEdges("f").Count());
+            Assert.Single(graph.OutgoingEdges("v"));
+            Assert.Single(graph.OutgoingEdges("f"));
             Assert.Empty(graph.OutgoingEdges("z"));
         }
 
@@ -37,14 +37,14 @@ public static void IncomingEdges_ReturnsCorrectCounts()
         {
             var graph = CreateTestGraph();
 
-            Assert.Equal(1, graph.IncomingEdges("a").Count());
+            Assert.Single(graph.IncomingEdges("a"));
             Assert.Equal(2, graph.IncomingEdges("s").Count());
             Assert.Equal(2, graph.IncomingEdges("d").Count());
-            Assert.Equal(1, graph.IncomingEdges("x").Count());
+            Assert.Single(graph.IncomingEdges("x"));
             Assert.Equal(3, graph.IncomingEdges("c").Count());
-            Assert.Equal(1, graph.IncomingEdges("v").Count());
+            Assert.Single(graph.IncomingEdges("v"));
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsUndirectedDenseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsUndirectedDenseGraphTest.cs
@@ -29,7 +29,7 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             Assert.Equal(4, graph.OutgoingEdges("c").Count());
             Assert.Equal(2, graph.OutgoingEdges("v").Count());
             Assert.Equal(3, graph.OutgoingEdges("f").Count());
-            Assert.Equal(1, graph.OutgoingEdges("z").Count());
+            Assert.Single(graph.OutgoingEdges("z"));
         }
 
         [Fact]
@@ -44,7 +44,7 @@ public static void IncomingEdges_EqualsOutgoingEdges_ForUndirectedGraph()
             Assert.Equal(4, graph.IncomingEdges("c").Count());
             Assert.Equal(2, graph.IncomingEdges("v").Count());
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsUndirectedSparseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsUndirectedSparseGraphTest.cs
@@ -29,7 +29,7 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             Assert.Equal(4, graph.OutgoingEdges("c").Count());
             Assert.Equal(2, graph.OutgoingEdges("v").Count());
             Assert.Equal(3, graph.OutgoingEdges("f").Count());
-            Assert.Equal(1, graph.OutgoingEdges("z").Count());
+            Assert.Single(graph.OutgoingEdges("z"));
         }
 
         [Fact]
@@ -45,7 +45,7 @@ public static void IncomingEdges_EqualsOutgoingEdges_ForUndirectedGraph()
             Assert.Equal(4, graph.IncomingEdges("c").Count());
             Assert.Equal(2, graph.IncomingEdges("v").Count());
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/GraphsUndirectedWeightedSparseGraphTest.cs b/UnitTest/DataStructuresTests/GraphsUndirectedWeightedSparseGraphTest.cs
@@ -29,7 +29,7 @@ public static void OutgoingEdges_ReturnsCorrectCounts()
             Assert.Equal(4, graph.OutgoingEdges("c").Count());
             Assert.Equal(2, graph.OutgoingEdges("v").Count());
             Assert.Equal(3, graph.OutgoingEdges("f").Count());
-            Assert.Equal(1, graph.OutgoingEdges("z").Count());
+            Assert.Single(graph.OutgoingEdges("z"));
         }
 
         [Fact]
@@ -44,7 +44,7 @@ public static void IncomingEdges_EqualsOutgoingEdges_ForUndirectedGraph()
             Assert.Equal(4, graph.IncomingEdges("c").Count());
             Assert.Equal(2, graph.IncomingEdges("v").Count());
             Assert.Equal(3, graph.IncomingEdges("f").Count());
-            Assert.Equal(1, graph.IncomingEdges("z").Count());
+            Assert.Single(graph.IncomingEdges("z"));
         }
 
         [Fact]
diff --git a/UnitTest/DataStructuresTests/HashTableSeparateChainingTest.cs b/UnitTest/DataStructuresTests/HashTableSeparateChainingTest.cs
@@ -86,7 +86,7 @@ public static void Remove_AllKeys_EmptiesTable()
             table.Remove("Name1");
             table.Remove("Name3");
 
-            Assert.Equal(0, table.Count);
+            Assert.Empty(table);
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public static void CopyTo_EmptyTable_CopiesNothing()
             table.Remove("Name1");
             table.Remove("Name3");
 
-            Assert.Equal(0, table.Count);
+            Assert.Empty(table);
             var array = new KeyValuePair<string, int>[table.Count];
             table.CopyTo(array, 0);
             
diff --git a/UnitTest/DataStructuresTests/OpenScatterHashTableTest.cs b/UnitTest/DataStructuresTests/OpenScatterHashTableTest.cs
@@ -15,7 +15,6 @@ public static void Constructor_Default_CreatesEmptyTable()
         {
             var hashTable = new OpenScatterHashTable<int, string>();
 
-            Assert.Equal(0, hashTable.Count);
             Assert.Empty(hashTable);
         }
 
@@ -24,7 +23,6 @@ public static void Constructor_WithCapacity_CreatesEmptyTable()
         {
             var hashTable = new OpenScatterHashTable<int, string>(100);
 
-            Assert.Equal(0, hashTable.Count);
             Assert.Empty(hashTable);
         }
 
@@ -45,7 +43,7 @@ public static void Add_SingleItem_IncreasesCount()
 
             hashTable.Add(1, "one");
 
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.True(hashTable.ContainsKey(1));
         }
 
@@ -105,7 +103,7 @@ public static void Add_KeyValuePair_Works()
 
             hashTable.Add(new KeyValuePair<int, string>(1, "one"));
 
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.Equal("one", hashTable[1]);
         }
 
@@ -137,7 +135,7 @@ public static void Indexer_Set_NewKey_AddsItem()
 
             hashTable[1] = "one";
 
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.Equal("one", hashTable[1]);
         }
 
@@ -149,7 +147,7 @@ public static void Indexer_Set_ExistingKey_UpdatesValue()
 
             hashTable[1] = "ONE";
 
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.Equal("ONE", hashTable[1]);
         }
 
@@ -224,7 +222,7 @@ public static void Remove_ExistingKey_ReturnsTrueAndDecreasesCount()
             bool removed = hashTable.Remove(1);
 
             Assert.True(removed);
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.False(hashTable.ContainsKey(1));
             Assert.True(hashTable.ContainsKey(2));
         }
@@ -238,7 +236,7 @@ public static void Remove_NonExistingKey_ReturnsFalse()
             bool removed = hashTable.Remove(99);
 
             Assert.False(removed);
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
         }
 
         [Fact]
@@ -250,12 +248,12 @@ public static void Remove_KeyValuePair_OnlyRemovesIfBothMatch()
             // Wrong value - should not remove
             bool removed1 = hashTable.Remove(new KeyValuePair<int, string>(1, "wrong"));
             Assert.False(removed1);
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
 
             // Correct key and value - should remove
             bool removed2 = hashTable.Remove(new KeyValuePair<int, string>(1, "one"));
             Assert.True(removed2);
-            Assert.Equal(0, hashTable.Count);
+            Assert.Empty(hashTable);
         }
 
         [Fact]
@@ -267,7 +265,7 @@ public static void Remove_ThenAddSameKey_Works()
 
             hashTable.Add(1, "new one");
 
-            Assert.Equal(1, hashTable.Count);
+            Assert.Single(hashTable);
             Assert.Equal("new one", hashTable[1]);
         }
 
@@ -285,7 +283,6 @@ public static void Clear_RemovesAllItems()
 
             hashTable.Clear();
 
-            Assert.Equal(0, hashTable.Count);
             Assert.Empty(hashTable);
             Assert.False(hashTable.ContainsKey(1));
         }
@@ -336,7 +333,7 @@ public static void Contains_ExistingPair_ReturnsTrue()
             var hashTable = new OpenScatterHashTable<int, string>();
             hashTable.Add(1, "one");
 
-            Assert.True(hashTable.Contains(new KeyValuePair<int, string>(1, "one")));
+            Assert.Contains(new KeyValuePair<int, string>(1, "one"), hashTable);
         }
 
         [Fact]
@@ -345,7 +342,7 @@ public static void Contains_WrongValue_ReturnsFalse()
             var hashTable = new OpenScatterHashTable<int, string>();
             hashTable.Add(1, "one");
 
-            Assert.False(hashTable.Contains(new KeyValuePair<int, string>(1, "wrong")));
+            Assert.DoesNotContain(new KeyValuePair<int, string>(1, "wrong"), hashTable);
         }
 
         [Fact]
@@ -354,7 +351,7 @@ public static void Contains_NonExistingKey_ReturnsFalse()
             var hashTable = new OpenScatterHashTable<int, string>();
             hashTable.Add(1, "one");
 
-            Assert.False(hashTable.Contains(new KeyValuePair<int, string>(99, "whatever")));
+            Assert.DoesNotContain(new KeyValuePair<int, string>(99, "whatever"), hashTable);
         }
 
         #endregion
diff --git a/UnitTest/DataStructuresTests/SkipListTest.cs b/UnitTest/DataStructuresTests/SkipListTest.cs
diff --git a/UnitTest/DataStructuresTests/SortedDictionaryTests.cs b/UnitTest/DataStructuresTests/SortedDictionaryTests.cs
diff --git a/UnitTest/DataStructuresTests/SortedListTests.cs b/UnitTest/DataStructuresTests/SortedListTests.cs
diff --git a/UnitTest/DataStructuresTests/TrieMapTest.cs b/UnitTest/DataStructuresTests/TrieMapTest.cs
diff --git a/UnitTest/UnitTest.csproj b/UnitTest/UnitTest.csproj

Original file line number	Diff line number	Diff line change
`@@ -620,12 +620,24 @@ public void Clear()`
`620`	`620`
`621`	`621`	`public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()`
`622`	`622`	`{`
`623`		`- throw new NotImplementedException();`
	`623`	`+ for (int i = 0; i < _hashTableStore.Length; i++)`
	`624`	`+ {`
	`625`	`+ var chain = _hashTableStore[i];`
	`626`	`+ if (chain != null && chain.Count > 0)`
	`627`	`+ {`
	`628`	`+ var node = chain.Head;`
	`629`	`+ while (node != null)`
	`630`	`+ {`
	`631`	`+ yield return new KeyValuePair<TKey, TValue>(node.Key, node.Value);`
	`632`	`+ node = node.Next;`
	`633`	`+ }`
	`634`	`+ }`
	`635`	`+ }`
`624`	`636`	`}`
`625`	`637`
`626`	`638`	`System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()`
`627`	`639`	`{`
`628`		`- throw new NotImplementedException();`
	`640`	`+ return GetEnumerator();`
`629`	`641`	`}`
`630`	`642`
`631`	`643`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@ public static void Constructor_Default_CreatesEmptyTable()`
`15`	`15`	`{`
`16`	`16`	`var hashTable = new OpenScatterHashTable<int, string>();`
`17`	`17`
`18`		`- Assert.Equal(0, hashTable.Count);`
`19`	`18`	`Assert.Empty(hashTable);`
`20`	`19`	`}`
`21`	`20`
`@@ -24,7 +23,6 @@ public static void Constructor_WithCapacity_CreatesEmptyTable()`
`24`	`23`	`{`
`25`	`24`	`var hashTable = new OpenScatterHashTable<int, string>(100);`
`26`	`25`
`27`		`- Assert.Equal(0, hashTable.Count);`
`28`	`26`	`Assert.Empty(hashTable);`
`29`	`27`	`}`
`30`	`28`
`@@ -45,7 +43,7 @@ public static void Add_SingleItem_IncreasesCount()`
`45`	`43`
`46`	`44`	`hashTable.Add(1, "one");`
`47`	`45`
`48`		`- Assert.Equal(1, hashTable.Count);`
	`46`	`+ Assert.Single(hashTable);`
`49`	`47`	`Assert.True(hashTable.ContainsKey(1));`
`50`	`48`	`}`
`51`	`49`
`@@ -105,7 +103,7 @@ public static void Add_KeyValuePair_Works()`
`105`	`103`
`106`	`104`	`hashTable.Add(new KeyValuePair<int, string>(1, "one"));`
`107`	`105`
`108`		`- Assert.Equal(1, hashTable.Count);`
	`106`	`+ Assert.Single(hashTable);`
`109`	`107`	`Assert.Equal("one", hashTable[1]);`
`110`	`108`	`}`
`111`	`109`
`@@ -137,7 +135,7 @@ public static void Indexer_Set_NewKey_AddsItem()`
`137`	`135`
`138`	`136`	`hashTable[1] = "one";`
`139`	`137`
`140`		`- Assert.Equal(1, hashTable.Count);`
	`138`	`+ Assert.Single(hashTable);`
`141`	`139`	`Assert.Equal("one", hashTable[1]);`
`142`	`140`	`}`
`143`	`141`
`@@ -149,7 +147,7 @@ public static void Indexer_Set_ExistingKey_UpdatesValue()`
`149`	`147`
`150`	`148`	`hashTable[1] = "ONE";`
`151`	`149`
`152`		`- Assert.Equal(1, hashTable.Count);`
	`150`	`+ Assert.Single(hashTable);`
`153`	`151`	`Assert.Equal("ONE", hashTable[1]);`
`154`	`152`	`}`
`155`	`153`
`@@ -224,7 +222,7 @@ public static void Remove_ExistingKey_ReturnsTrueAndDecreasesCount()`
`224`	`222`	`bool removed = hashTable.Remove(1);`
`225`	`223`
`226`	`224`	`Assert.True(removed);`
`227`		`- Assert.Equal(1, hashTable.Count);`
	`225`	`+ Assert.Single(hashTable);`
`228`	`226`	`Assert.False(hashTable.ContainsKey(1));`
`229`	`227`	`Assert.True(hashTable.ContainsKey(2));`
`230`	`228`	`}`
`@@ -238,7 +236,7 @@ public static void Remove_NonExistingKey_ReturnsFalse()`
`238`	`236`	`bool removed = hashTable.Remove(99);`
`239`	`237`
`240`	`238`	`Assert.False(removed);`
`241`		`- Assert.Equal(1, hashTable.Count);`
	`239`	`+ Assert.Single(hashTable);`
`242`	`240`	`}`
`243`	`241`
`244`	`242`	`[Fact]`
`@@ -250,12 +248,12 @@ public static void Remove_KeyValuePair_OnlyRemovesIfBothMatch()`
`250`	`248`	`// Wrong value - should not remove`
`251`	`249`	`bool removed1 = hashTable.Remove(new KeyValuePair<int, string>(1, "wrong"));`
`252`	`250`	`Assert.False(removed1);`
`253`		`- Assert.Equal(1, hashTable.Count);`
	`251`	`+ Assert.Single(hashTable);`
`254`	`252`
`255`	`253`	`// Correct key and value - should remove`
`256`	`254`	`bool removed2 = hashTable.Remove(new KeyValuePair<int, string>(1, "one"));`
`257`	`255`	`Assert.True(removed2);`
`258`		`- Assert.Equal(0, hashTable.Count);`
	`256`	`+ Assert.Empty(hashTable);`
`259`	`257`	`}`
`260`	`258`
`261`	`259`	`[Fact]`
`@@ -267,7 +265,7 @@ public static void Remove_ThenAddSameKey_Works()`
`267`	`265`
`268`	`266`	`hashTable.Add(1, "new one");`
`269`	`267`
`270`		`- Assert.Equal(1, hashTable.Count);`
	`268`	`+ Assert.Single(hashTable);`
`271`	`269`	`Assert.Equal("new one", hashTable[1]);`
`272`	`270`	`}`
`273`	`271`
`@@ -285,7 +283,6 @@ public static void Clear_RemovesAllItems()`
`285`	`283`
`286`	`284`	`hashTable.Clear();`
`287`	`285`
`288`		`- Assert.Equal(0, hashTable.Count);`
`289`	`286`	`Assert.Empty(hashTable);`
`290`	`287`	`Assert.False(hashTable.ContainsKey(1));`
`291`	`288`	`}`
`@@ -336,7 +333,7 @@ public static void Contains_ExistingPair_ReturnsTrue()`
`336`	`333`	`var hashTable = new OpenScatterHashTable<int, string>();`
`337`	`334`	`hashTable.Add(1, "one");`
`338`	`335`
`339`		`- Assert.True(hashTable.Contains(new KeyValuePair<int, string>(1, "one")));`
	`336`	`+ Assert.Contains(new KeyValuePair<int, string>(1, "one"), hashTable);`
`340`	`337`	`}`
`341`	`338`
`342`	`339`	`[Fact]`
`@@ -345,7 +342,7 @@ public static void Contains_WrongValue_ReturnsFalse()`
`345`	`342`	`var hashTable = new OpenScatterHashTable<int, string>();`
`346`	`343`	`hashTable.Add(1, "one");`
`347`	`344`
`348`		`- Assert.False(hashTable.Contains(new KeyValuePair<int, string>(1, "wrong")));`
	`345`	`+ Assert.DoesNotContain(new KeyValuePair<int, string>(1, "wrong"), hashTable);`
`349`	`346`	`}`
`350`	`347`
`351`	`348`	`[Fact]`
`@@ -354,7 +351,7 @@ public static void Contains_NonExistingKey_ReturnsFalse()`
`354`	`351`	`var hashTable = new OpenScatterHashTable<int, string>();`
`355`	`352`	`hashTable.Add(1, "one");`
`356`	`353`
`357`		`- Assert.False(hashTable.Contains(new KeyValuePair<int, string>(99, "whatever")));`
	`354`	`+ Assert.DoesNotContain(new KeyValuePair<int, string>(99, "whatever"), hashTable);`
`358`	`355`	`}`
`359`	`356`
`360`	`357`	`#endregion`