Added more TimSorterTests tests and changed method names for clarity.

Added tests in HashTableTests for collision handling and resizing behavior.
Improved null handling in HashTable methods and adjusted resizing logic.

Author: kamikkels

Algorithms.Tests/Sorters/Comparison/TimSorterTests.cs

@@ -9,8 +9,8 @@ public static class TimSorterTests
     private static readonly TimSorterSettings Settings = new();
 
     [Test]
-    public static void ArraySorted(
-        [Random(0, 10_000, 2000)] int n)
+    public static void Sort_ShouldBeEquivalentToSuccessfulBasicSort(
+        [Random(0, 10_000, 5000)] int n)
     {
         // Arrange
         var sorter = new TimSorter<int>(Settings, IntComparer);
@@ -25,7 +25,7 @@ public static void ArraySorted(
     }
 
     [Test]
-    public static void TinyArray()
+    public static void Sort_TinyArray_ShouldSortCorrectly()
     {
         // Arrange
         var sorter = new TimSorter<int>(Settings, IntComparer);
@@ -40,7 +40,7 @@ public static void TinyArray()
     }
 
     [Test]
-    public static void SmallChunks()
+    public static void Sort_SmallChunks_ShouldSortCorrectly()
     {
         // Arrange
         var sorter = new TimSorter<int>(Settings, IntComparer);
@@ -63,4 +63,74 @@ public static void SmallChunks()
         // Assert
         Assert.That(correctArray, Is.EqualTo(testArray));
     }
+
+    [Test]
+    public static void Sort_ThrowsArgumentNullException_WhenArrayIsNull()
+    {
+        // Arrange
+        var sorter = new TimSorter<int>(Settings, IntComparer);
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => sorter.Sort(null!, IntComparer));
+    }
+
+    [Test]
+    public static void Sort_UsesDefaultComparer_WhenComparerIsNull()
+    {
+        // Arrange
+        var sorter = new TimSorter<int>(Settings, null!);
+        var (correctArray, testArray) = RandomHelper.GetArrays(20);
+
+        // Act
+        sorter.Sort(testArray, IntComparer);
+        Array.Sort(correctArray, IntComparer);
+
+        // Assert
+        Assert.That(correctArray, Is.EqualTo(testArray));
+    }
+
+    [Test]
+    public static void Sort_AlreadySortedArray_RemainsUnchanged()
+    {
+        // Arrange
+        var sorter = new TimSorter<int>(Settings, IntComparer);
+        var array = new[] { 1, 2, 3, 4, 5 };
+        var expected = new[] { 1, 2, 3, 4, 5 };
+
+        // Act
+        sorter.Sort(array, IntComparer);
+
+        // Assert
+        Assert.That(array, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public static void MergeAt_ShouldReturnEarly_WhenLenAIsZero()
+    {
+        // Arrange: left run is all less than right run's first element
+        var array = Enumerable.Range(1, 25).Concat(Enumerable.Range(100, 25)).ToArray();
+        var sortedArray = Enumerable.Range(1, 25).Concat(Enumerable.Range(100, 25)).ToArray();
+        var sorter = new TimSorter<int>(new TimSorterSettings(), Comparer<int>.Default);
+
+        // Act
+        sorter.Sort(array, Comparer<int>.Default);
+
+        // Assert: Array order will not have changed, and the lenA <= 0 branch should be hit
+        Assert.That(sortedArray, Is.EqualTo(array));
+    }
+
+    [Test]
+    public static void MergeAt_ShouldReturnEarly_WhenLenBIsZero()
+    {
+        // Arrange: right run is all less than left run's last element
+        var array = Enumerable.Range(100, 25).Concat(Enumerable.Range(1, 25)).ToArray();
+        var sortedArray = Enumerable.Range(1, 25).Concat(Enumerable.Range(100, 25)).ToArray();
+        var sorter = new TimSorter<int>(new TimSorterSettings(), Comparer<int>.Default);
+
+        // Act
+        sorter.Sort(array, Comparer<int>.Default);
+
+        // Assert: The left and right sides of the array should have swapped places, and the lenB <= 0 branch should be hit
+        Assert.That(sortedArray, Is.EqualTo(array));
+    }
 }

Algorithms/Sorters/Comparison/TimSorter.cs

@@ -8,7 +8,7 @@ namespace Algorithms.Sorters.Comparison;
 ///
 ///     This class is based on a Java interpretation of Tim Peter's original work.
 ///     Java class is viewable here:
-///     http://cr.openjdk.java.net/~martin/webrevs/openjdk7/timsort/raw_files/new/src/share/classes/java/util/TimSort.java
+///     https://web.archive.org/web/20190119032242/http://cr.openjdk.java.net:80/~martin/webrevs/openjdk7/timsort/raw_files/new/src/share/classes/java/util/TimSort.java
 ///
 ///     Tim Peters's list sort for Python, is described in detail here:
 ///     http://svn.python.org/projects/python/trunk/Objects/listsort.txt
@@ -27,9 +27,6 @@ public class TimSorter<T> : IComparisonSorter<T>
     private readonly int minMerge;
     private readonly int initMinGallop;
 
-    // Pool of reusable TimChunk objects for memory efficiency.
-    private readonly TimChunk<T>[] chunkPool = new TimChunk<T>[2];
-
     private readonly int[] runBase;
     private readonly int[] runLengths;
 
@@ -56,6 +53,11 @@ private class TimChunk<Tc>
     public TimSorter(TimSorterSettings settings, IComparer<T> comparer)
     {
         initMinGallop = minGallop;
+
+        // Using the worst case stack size from the C implementation.
+        // Based on the findings in the original listsort.txt:
+        // ... the stack can never grow larger than about log_base_phi(N) entries, where phi = (1 + sqrt(5)) / 2 ~= 1.618.
+        // Thus a small # of stack slots suffice for very large arrays ...
         runBase = new int[85];
         runLengths = new int[85];
 
@@ -77,7 +79,9 @@ public TimSorter(TimSorterSettings settings, IComparer<T> comparer)
     /// <param name="comparer">Compares elements.</param>
     public void Sort(T[] array, IComparer<T> comparer)
     {
-        this.comparer = comparer;
+        ArgumentNullException.ThrowIfNull(array);
+        this.comparer = comparer ?? Comparer<T>.Default;
+
         var start = 0;
         var remaining = array.Length;
 

Algorithms/Sorters/Comparison/TimSorterSettings.cs

@@ -1,14 +1,8 @@
 namespace Algorithms.Sorters.Comparison;
 
-public class TimSorterSettings
+public class TimSorterSettings(int minMerge = 32, int minGallop = 7)
 {
-    public int MinMerge { get; }
+    public int MinMerge { get; } = minMerge;
 
-    public int MinGallop { get; }
-
-    public TimSorterSettings(int minMerge = 32, int minGallop = 7)
-    {
-        MinMerge = minMerge;
-        MinGallop = minGallop;
-    }
+    public int MinGallop { get; } = minGallop;
 }

DataStructures.Tests/Hashing/HashTableTests.cs

@@ -117,6 +117,18 @@ public void Add_IncreasesCount_WhenValueAlreadyExists()
         Assert.That(hashTable.Count, Is.EqualTo(2));
     }
 
+    [Test]
+    public void Add_ThrowsException_OnCollision()
+    {
+        // Arrange
+        var hashTable = new HashTable<Collider, int>();
+        hashTable.Add(new Collider(1), 1);
+
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => hashTable.Add(new Collider(1), 2));
+    }
+
     [Test]
     public void Remove_ThrowsException_WhenKeyIsNull()
     {
@@ -158,12 +170,28 @@ public void Remove_DecreasesCount_WhenKeyExists()
     public void Remove_DoesNotDecreaseCount_WhenKeyDoesNotExist()
     {
         var hashTable = new HashTable<string, int>();
-
         hashTable.Remove("a");
 
         Assert.That(hashTable.Count, Is.EqualTo(0));
     }
 
+    [Test]
+    public void Remove_TriggersResizeDown()
+    {
+        var hashTable = new HashTable<int, string>(4);
+        for (var i = 1; i <= 50; i++)
+        {
+            hashTable.Add(i, $"Value{i}");
+        }
+
+        for (var i = 1; i <= 40; i++)
+        {
+            hashTable.Remove(i);
+        }
+
+        Assert.That(hashTable.Capacity, Is.EqualTo(40));
+    }
+
     [Test]
     public void ContainsValue_ReturnsFalse_WhenValueDoesNotExist()
     {
@@ -238,6 +266,17 @@ public void Clear_RemovesAllElements()
         Assert.That(hashTable.ContainsKey("a"), Is.False);
     }
 
+    [Test]
+    public void Clear_ResetsTable()
+    {
+        var hashTable = new HashTable<int, string>();
+        hashTable.Add(1, "A");
+        hashTable.Clear();
+        hashTable.Add(2, "B");
+        Assert.That(hashTable.Count, Is.EqualTo(1));
+        Assert.That(hashTable[2], Is.EqualTo("B"));
+    }
+
     [Test]
     public void Resize_IncreasesCapacity()
     {
@@ -317,6 +356,13 @@ public void Constructor_ThrowsException_WhenLoadFactorIsGreaterThanOne()
         Assert.Throws<ArgumentOutOfRangeException>(() => new HashTable<string, int>(4, 2));
     }
 
+    [Test]
+    public void Constructor_RoundsCapacityToPrime()
+    {
+        var hashTable = new HashTable<int, string>(17);
+        Assert.That(hashTable.Capacity, Is.EqualTo(19));
+    }
+
     [Test]
     public void GetIndex_ThrowsException_WhenKeyIsNull()
     {
@@ -399,7 +445,7 @@ public void Add_ShouldTriggerResize_WhenThresholdExceeded()
         var hashTable = new HashTable<int, string>(initialCapacity);
 
         // Act
-        for (int i = 1; i <= 4; i++) // Start keys from 1 to avoid default(TKey) = 0 issue
+        for (var i = 1; i <= 4; i++) // Start keys from 1 to avoid default(TKey) = 0 issue
         {
             hashTable.Add(i, $"Value{i}");
         }
@@ -476,23 +522,28 @@ public void Capacity_Increases_WhenResizeOccurs()
         var initialCapacity = 4;
         var hashTable = new HashTable<int, string>(initialCapacity);
 
-        for (int i = 1; i <= 5; i++)
+        for (var i = 1; i <= 5; i++)
         {
             hashTable.Add(i, $"Value{i}");
         }
 
         hashTable.Capacity.Should().BeGreaterThan(initialCapacity);
     }
-}
-
-public class NegativeHashKey
-{
-    private readonly int id;
 
-    public NegativeHashKey(int id)
+    [Test]
+    public void IndexerSet_Throws_KeyNotFound()
     {
-        this.id = id;
+        // Arrange
+        var hashTable = new HashTable<int, string>();
+
+        // Act & Assert
+        Assert.Throws<KeyNotFoundException>(() => hashTable[1] = "A");
     }
+}
+
+public class NegativeHashKey(int id)
+{
+    private readonly int id = id;
 
     public override int GetHashCode()
     {
@@ -509,3 +560,14 @@ public override bool Equals(object? obj)
         return false;
     }
 }
+
+/// <summary>
+/// Class to simulate hash collisions
+/// </summary>
+/// <param name="id">Id of this object</param>
+public class Collider(int id)
+{
+    private readonly int id = id;
+    public override int GetHashCode() => 42; // Force all instances to collide
+    public override bool Equals(object? obj) => obj is Collider other && other.id == id;
+}