Initial commit

tests/test_comparison.py

@@ -0,0 +1,101 @@
+"""
+Test cases for comparison utilities.
+"""
+
+import unittest
+from src.comparison import (
+    generate_random_array,
+    generate_sorted_array,
+    generate_reverse_sorted_array,
+    generate_nearly_sorted_array,
+    generate_array_with_duplicates,
+    benchmark_sorting_algorithm
+)
+from src.quicksort import quicksort, randomized_quicksort
+
+
+class TestArrayGenerators(unittest.TestCase):
+    """Test array generator functions."""
+    
+    def test_generate_random_array(self):
+        """Test random array generation."""
+        arr = generate_random_array(100, 0, 100)
+        self.assertEqual(len(arr), 100)
+        self.assertTrue(all(0 <= x <= 100 for x in arr))
+    
+    def test_generate_sorted_array(self):
+        """Test sorted array generation."""
+        arr = generate_sorted_array(10, 0, 1)
+        self.assertEqual(arr, list(range(10)))
+        
+        arr = generate_sorted_array(5, 10, 2)
+        self.assertEqual(arr, [10, 12, 14, 16, 18])
+    
+    def test_generate_reverse_sorted_array(self):
+        """Test reverse-sorted array generation."""
+        arr = generate_reverse_sorted_array(10, 0, 1)
+        self.assertEqual(arr, list(range(9, -1, -1)))
+    
+    def test_generate_nearly_sorted_array(self):
+        """Test nearly sorted array generation."""
+        arr = generate_nearly_sorted_array(100, 5)
+        self.assertEqual(len(arr), 100)
+        # Should be mostly sorted
+        sorted_arr = sorted(arr)
+        # Count inversions (should be small)
+        inversions = sum(1 for i in range(len(arr)-1) if arr[i] > arr[i+1])
+        self.assertLess(inversions, 20)  # Should have few inversions
+    
+    def test_generate_array_with_duplicates(self):
+        """Test array with duplicates generation."""
+        arr = generate_array_with_duplicates(100, 5)
+        self.assertEqual(len(arr), 100)
+        unique_values = set(arr)
+        self.assertLessEqual(len(unique_values), 5)
+
+
+class TestBenchmarking(unittest.TestCase):
+    """Test benchmarking utilities."""
+    
+    def test_benchmark_quicksort(self):
+        """Test benchmarking quicksort."""
+        arr = generate_random_array(100)
+        stats = benchmark_sorting_algorithm(quicksort, arr, iterations=3)
+        
+        self.assertIn('mean', stats)
+        self.assertIn('median', stats)
+        self.assertIn('min', stats)
+        self.assertIn('max', stats)
+        self.assertIn('stdev', stats)
+        
+        self.assertGreater(stats['mean'], 0)
+        self.assertGreaterEqual(stats['min'], 0)
+        self.assertGreaterEqual(stats['max'], stats['min'])
+    
+    def test_benchmark_randomized_quicksort(self):
+        """Test benchmarking randomized quicksort."""
+        arr = generate_random_array(100)
+        stats = benchmark_sorting_algorithm(
+            lambda a: randomized_quicksort(a, seed=42),
+            arr,
+            iterations=3
+        )
+        
+        self.assertIn('mean', stats)
+        self.assertGreater(stats['mean'], 0)
+    
+    def test_benchmark_verifies_sorting(self):
+        """Test that benchmarking verifies correct sorting."""
+        def bad_sort(arr):
+            # Intentionally bad sort that doesn't actually sort
+            return arr
+        
+        arr = generate_random_array(10)
+        
+        with self.assertRaises(ValueError):
+            benchmark_sorting_algorithm(bad_sort, arr)
+
+
+if __name__ == '__main__':
+    unittest.main()
+