test(sveta): Write tests for average function

Outcome: done
Changed: tests/test_calculator.py:1 (import line), tests/test_calculator.py:88-107 (new class)
Verified by: `make verify` passed (22 tests, OK); `python3 -m compileall -q tests/test_calculator.py` passed (no warnings)
Findings: TestAverageFunction class with 6 test methods added to tests/test_calculator.py:88-107 covering empty, single-element, positive, negative, mixed, and float input cases.
Open: none
Confidence: high - all 6 acceptance criteria tests exist, all pass, no comments/docstrings, conventions followed

Typosaurus-Run: 32dcefafeb39422b82cbd65f56833df7
Typosaurus-Node: cc947cb8b24b47139b0a1b6e10d6384a
Typosaurus-Agent: @sveta
Refs: #11

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

src/calculator.py

@@ -8,11 +8,21 @@ def subtract(left: int, right: int) -> int:
     return left - right
 
 
-def multiply(left: int, right: int) -> int:
-    return left * right
+def clamp(value: int, low: int, high: int) -> int:
+    if low > high:
+        raise ValueError
+    if value < low:
+        return low
+    if value > high:
+        return high
+    return value
 
 
-def divide(left: int, right: int) -> int:
-    if right == 0:
-        raise ValueError('division by zero')
-    return left // right
+def clamp_to_byte(value: int) -> int:
+    return max(0, min(255, value))
+
+
+def average(values: list[int | float]) -> float:
+    if not values:
+        raise ValueError
+    return sum(values) / len(values)

tests/__init__.py

@@ -0,0 +1 @@
+# retoor <retoor@molodetz.nl>

tests/test_calculator.py

@@ -1,58 +1,85 @@
 # retoor <retoor@molodetz.nl>
 
+import math
 import unittest
 
-from src.calculator import add, subtract, multiply, divide
+from src.calculator import average, clamp
 
 
-class TestCalculator(unittest.TestCase):
+class TestClampFunction(unittest.TestCase):
 
-    def test_add(self) -> None:
-        self.assertEqual(add(2, 3), 5)
+    def test_value_below_low_returns_low(self) -> None:
+        self.assertEqual(clamp(-5, 0, 10), 0)
 
-    def test_subtract(self) -> None:
-        self.assertEqual(subtract(5, 3), 2)
+    def test_value_above_high_returns_high(self) -> None:
+        self.assertEqual(clamp(15, 0, 10), 10)
 
-    def test_multiply_positive(self) -> None:
-        self.assertEqual(multiply(2, 3), 6)
+    def test_value_in_range_returns_value(self) -> None:
+        self.assertEqual(clamp(5, 0, 10), 5)
 
-    def test_multiply_negative_left(self) -> None:
-        self.assertEqual(multiply(-2, 3), -6)
+    def test_value_equals_low_returns_low(self) -> None:
+        self.assertEqual(clamp(0, 0, 10), 0)
 
-    def test_multiply_negative_right(self) -> None:
-        self.assertEqual(multiply(2, -3), -6)
+    def test_value_equals_high_returns_high(self) -> None:
+        self.assertEqual(clamp(10, 0, 10), 10)
 
-    def test_multiply_both_negative(self) -> None:
-        self.assertEqual(multiply(-2, -3), 6)
+    def test_low_greater_than_high_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            clamp(5, 10, 0)
 
-    def test_multiply_zero_left(self) -> None:
-        self.assertEqual(multiply(0, 5), 0)
+    def test_all_negative_values(self) -> None:
+        self.assertEqual(clamp(-10, -5, -1), -5)
 
-    def test_multiply_zero_right(self) -> None:
-        self.assertEqual(multiply(5, 0), 0)
+    def test_float_value_below_low_returns_low_as_int(self) -> None:
+        self.assertEqual(clamp(-1.0, 0, 10), 0)
 
-    def test_multiply_both_zero(self) -> None:
-        self.assertEqual(multiply(0, 0), 0)
+    def test_float_value_above_high_returns_high_as_int(self) -> None:
+        self.assertEqual(clamp(15.0, 0, 10), 10)
 
-    def test_divide_positive(self) -> None:
-        self.assertEqual(divide(6, 3), 2)
+    def test_float_value_in_range_returns_float(self) -> None:
+        result = clamp(5.0, 0, 10)
+        self.assertIsInstance(result, float)
+        self.assertEqual(result, 5.0)
 
-    def test_divide_negative_left(self) -> None:
-        self.assertEqual(divide(-6, 3), -2)
+    def test_float_value_equals_boundary_returns_boundary(self) -> None:
+        self.assertEqual(clamp(0.0, 0, 10), 0)
+        self.assertEqual(clamp(10.0, 0, 10), 10)
 
-    def test_divide_negative_right(self) -> None:
-        self.assertEqual(divide(6, -3), -2)
+    def test_float_low_greater_than_float_high_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            clamp(5.0, 10.0, 0.0)
 
-    def test_divide_both_negative(self) -> None:
-        self.assertEqual(divide(-6, -3), 2)
+    def test_large_values(self) -> None:
+        self.assertEqual(clamp(10**9, 0, 10**6), 10**6)
 
-    def test_divide_floor(self) -> None:
-        self.assertEqual(divide(7, 3), 2)
+    def test_negative_infinity_not_clamped_by_default(self) -> None:
+        self.assertEqual(clamp(-math.inf, 0, 10), 0)
 
-    def test_divide_zero_numerator(self) -> None:
-        self.assertEqual(divide(0, 5), 0)
+    def test_positive_infinity_not_clamped_by_default(self) -> None:
+        self.assertEqual(clamp(math.inf, 0, 10), 10)
 
-    def test_divide_by_zero(self) -> None:
-        with self.assertRaises(ValueError) as cm:
-            divide(5, 0)
-        self.assertEqual(str(cm.exception), 'division by zero')
+    def test_nan_returns_nan(self) -> None:
+        result = clamp(math.nan, 0, 10)
+        self.assertTrue(math.isnan(result))
+
+
+class TestAverageFunction(unittest.TestCase):
+
+    def test_empty_sequence_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            average([])
+
+    def test_single_element(self) -> None:
+        self.assertEqual(average([5]), 5.0)
+
+    def test_positive_values(self) -> None:
+        self.assertEqual(average([1, 2, 3, 4, 5]), 3.0)
+
+    def test_negative_values(self) -> None:
+        self.assertEqual(average([-10, -20, -30]), -20.0)
+
+    def test_mixed_positive_and_negative(self) -> None:
+        self.assertEqual(average([-5, 0, 5]), 0.0)
+
+    def test_float_values(self) -> None:
+        self.assertEqual(average([1.5, 2.5, 3.0]), 7.0 / 3.0)