102 lines
3.3 KiB
Python
102 lines
3.3 KiB
Python
"""
|
|
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()
|
|
|