|
# retoor <retoor@molodetz.nl>
|
|
|
|
import math
|
|
import unittest
|
|
|
|
from typosaurus_sandbox.domain.calculator import add, average, clamp, clamp_to_byte, median, subtract, variance
|
|
|
|
|
|
class TestAddFunction(unittest.TestCase):
|
|
|
|
def test_add_positive_integers(self) -> None:
|
|
self.assertEqual(add(3, 5), 8)
|
|
|
|
def test_add_negative_integers(self) -> None:
|
|
self.assertEqual(add(-3, -5), -8)
|
|
|
|
def test_add_mixed_sign(self) -> None:
|
|
self.assertEqual(add(-3, 5), 2)
|
|
|
|
|
|
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)
|
|
|
|
|
|
class TestSubtractFunction(unittest.TestCase):
|
|
|
|
def test_subtract_positive(self) -> None:
|
|
self.assertEqual(subtract(10, 3), 7)
|
|
|
|
def test_subtract_negative_result(self) -> None:
|
|
self.assertEqual(subtract(3, 10), -7)
|
|
|
|
def test_subtract_negative_numbers(self) -> None:
|
|
self.assertEqual(subtract(-5, -3), -2)
|
|
|
|
|
|
class TestClampToByteFunction(unittest.TestCase):
|
|
|
|
def test_clamp_to_byte_within_range(self) -> None:
|
|
self.assertEqual(clamp_to_byte(128), 128)
|
|
|
|
def test_clamp_to_byte_below_zero(self) -> None:
|
|
self.assertEqual(clamp_to_byte(-10), 0)
|
|
|
|
def test_clamp_to_byte_above_255(self) -> None:
|
|
self.assertEqual(clamp_to_byte(300), 255)
|
|
|
|
def test_clamp_to_byte_boundaries(self) -> None:
|
|
self.assertEqual(clamp_to_byte(0), 0)
|
|
self.assertEqual(clamp_to_byte(255), 255)
|
|
|
|
|
|
class TestClampFunction(unittest.TestCase):
|
|
|
|
def test_value_below_low_returns_low(self) -> None:
|
|
self.assertEqual(clamp(-5, 0, 10), 0)
|
|
|
|
def test_value_above_high_returns_high(self) -> None:
|
|
self.assertEqual(clamp(15, 0, 10), 10)
|
|
|
|
def test_value_in_range_returns_value(self) -> None:
|
|
self.assertEqual(clamp(5, 0, 10), 5)
|
|
|
|
def test_value_equals_low_returns_low(self) -> None:
|
|
self.assertEqual(clamp(0, 0, 10), 0)
|
|
|
|
def test_value_equals_high_returns_high(self) -> None:
|
|
self.assertEqual(clamp(10, 0, 10), 10)
|
|
|
|
def test_low_greater_than_high_raises_value_error(self) -> None:
|
|
with self.assertRaises(ValueError):
|
|
clamp(5, 10, 0)
|
|
|
|
def test_all_negative_values(self) -> None:
|
|
self.assertEqual(clamp(-10, -5, -1), -5)
|
|
|
|
def test_float_value_below_low_returns_low_as_int(self) -> None:
|
|
self.assertEqual(clamp(-1.0, 0, 10), 0)
|
|
|
|
def test_float_value_above_high_returns_high_as_int(self) -> None:
|
|
self.assertEqual(clamp(15.0, 0, 10), 10)
|
|
|
|
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_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_float_low_greater_than_float_high_raises_value_error(self) -> None:
|
|
with self.assertRaises(ValueError):
|
|
clamp(5.0, 10.0, 0.0)
|
|
|
|
def test_large_values(self) -> None:
|
|
self.assertEqual(clamp(10**9, 0, 10**6), 10**6)
|
|
|
|
def test_negative_infinity_not_clamped_by_default(self) -> None:
|
|
self.assertEqual(clamp(-math.inf, 0, 10), 0)
|
|
|
|
def test_positive_infinity_not_clamped_by_default(self) -> None:
|
|
self.assertEqual(clamp(math.inf, 0, 10), 10)
|
|
|
|
def test_nan_returns_nan(self) -> None:
|
|
result = clamp(math.nan, 0, 10)
|
|
self.assertTrue(math.isnan(result))
|
|
|
|
|
|
class TestMedianFunction(unittest.TestCase):
|
|
|
|
def test_odd_length_returns_middle_element(self) -> None:
|
|
self.assertEqual(median([1, 3, 5]), 3)
|
|
|
|
def test_even_length_returns_float_average_of_two_middle_values(self) -> None:
|
|
result = median([1, 2, 3, 4])
|
|
self.assertIsInstance(result, float)
|
|
self.assertEqual(result, 2.5)
|
|
|
|
def test_single_element_returns_that_element(self) -> None:
|
|
self.assertEqual(median([7]), 7)
|
|
|
|
def test_empty_list_raises_value_error(self) -> None:
|
|
with self.assertRaises(ValueError):
|
|
median([])
|
|
|
|
def test_unsorted_input_sorts_correctly(self) -> None:
|
|
self.assertEqual(median([3, 1, 2]), 2)
|
|
|
|
def test_unsorted_even_length_returns_float_average(self) -> None:
|
|
result = median([10, 30, 20, 40])
|
|
self.assertIsInstance(result, float)
|
|
self.assertEqual(result, 25.0)
|
|
|
|
|
|
class TestVarianceFunction(unittest.TestCase):
|
|
|
|
def test_empty_list_raises_value_error(self) -> None:
|
|
with self.assertRaises(ValueError):
|
|
variance([])
|
|
|
|
def test_empty_tuple_raises_value_error(self) -> None:
|
|
with self.assertRaises(ValueError):
|
|
variance(())
|
|
|
|
def test_single_element_returns_zero(self) -> None:
|
|
self.assertEqual(variance([42.0]), 0.0)
|
|
|
|
def test_constant_values_return_zero_variance(self) -> None:
|
|
self.assertEqual(variance([1.0, 1.0, 1.0]), 0.0)
|
|
|
|
def test_population_variance_of_known_set(self) -> None:
|
|
self.assertEqual(variance([1, 2, 3, 4, 5]), 2.0)
|
|
|
|
def test_two_element_variance(self) -> None:
|
|
self.assertEqual(variance([0, 2]), 1.0)
|
|
|
|
def test_integer_inputs_return_float(self) -> None:
|
|
result = variance([10, 20, 30])
|
|
self.assertIsInstance(result, float)
|
|
self.assertEqual(result, 200.0 / 3.0)
|
|
|
|
def test_tuple_input_returns_variance(self) -> None:
|
|
self.assertEqual(variance((1, 2, 3, 4, 5)), 2.0)
|
|
|