diff --git a/UnitTestExample/calculator.py b/UnitTestExample/calculator.py new file mode 100644 index 0000000..2d947f9 --- /dev/null +++ b/UnitTestExample/calculator.py @@ -0,0 +1,58 @@ +def add(a, b): + """Add two numbers""" + return a + b + + +def subtract(a, b): + """Subtract second number from first""" + return a - b + + +def multiply(a, b): + """Multiply two numbers""" + return a * b + + +def divide(a, b): + """Divide first number by second""" + if b == 0: + raise ValueError("Cannot divide by zero") + return a / b + + +def power(base, exponent): + """Calculate base raised to the power of exponent""" + return base ** exponent + + +def factorial(n): + """Calculate factorial of a number""" + if n < 0: + raise ValueError("Factorial is not defined for negative numbers") + if n == 0 or n == 1: + return 1 + result = 1 + for i in range(2, n + 1): + result *= i + return result + + +def is_prime(n): + """Check if a number is prime""" + if n < 2: + return False + if n == 2: + return True + if n % 2 == 0: + return False + for i in range(3, int(n**0.5) + 1, 2): + if n % i == 0: + return False + return True + + +def average(numbers): + """Calculate average of a list of numbers""" + if not numbers: + raise ValueError("Cannot calculate average of empty list") + return sum(numbers) / len(numbers) diff --git a/UnitTestExample/test_calculator.py b/UnitTestExample/test_calculator.py new file mode 100644 index 0000000..5937bf4 --- /dev/null +++ b/UnitTestExample/test_calculator.py @@ -0,0 +1,150 @@ +import unittest +import calculator + + +class TestCalculator(unittest.TestCase): + + def test_add_positive_numbers(self): + """Test addition of positive numbers""" + result = calculator.add(5, 3) + self.assertEqual(result, 8) + + def test_add_negative_numbers(self): + """Test addition with negative numbers""" + result = calculator.add(-5, -3) + self.assertEqual(result, -8) + + def test_add_mixed_numbers(self): + """Test addition of positive and negative numbers""" + result = calculator.add(10, -3) + self.assertEqual(result, 7) + + def test_subtract_positive_numbers(self): + """Test subtraction of positive numbers""" + result = calculator.subtract(10, 3) + self.assertEqual(result, 7) + + def test_subtract_negative_result(self): + """Test subtraction resulting in negative number""" + result = calculator.subtract(3, 10) + self.assertEqual(result, -7) + + def test_multiply_positive_numbers(self): + """Test multiplication of positive numbers""" + result = calculator.multiply(4, 5) + self.assertEqual(result, 20) + + def test_multiply_by_zero(self): + """Test multiplication by zero""" + result = calculator.multiply(5, 0) + self.assertEqual(result, 0) + + def test_multiply_negative_numbers(self): + """Test multiplication with negative numbers""" + result = calculator.multiply(-3, 4) + self.assertEqual(result, -12) + + def test_divide_positive_numbers(self): + """Test division of positive numbers""" + result = calculator.divide(15, 3) + self.assertEqual(result, 5.0) + + def test_divide_with_float_result(self): + """Test division resulting in float""" + result = calculator.divide(10, 3) + self.assertAlmostEqual(result, 3.333333333333333, places=10) + + def test_divide_by_zero_raises_exception(self): + """Test that division by zero raises ValueError""" + with self.assertRaises(ValueError) as context: + calculator.divide(5, 0) + self.assertEqual(str(context.exception), "Cannot divide by zero") + + def test_power_positive_numbers(self): + """Test power calculation with positive numbers""" + result = calculator.power(2, 3) + self.assertEqual(result, 8) + + def test_power_with_zero_exponent(self): + """Test power calculation with zero exponent""" + result = calculator.power(5, 0) + self.assertEqual(result, 1) + + def test_power_with_negative_exponent(self): + """Test power calculation with negative exponent""" + result = calculator.power(2, -2) + self.assertEqual(result, 0.25) + + def test_factorial_positive_numbers(self): + """Test factorial of positive numbers""" + self.assertEqual(calculator.factorial(0), 1) + self.assertEqual(calculator.factorial(1), 1) + self.assertEqual(calculator.factorial(5), 120) + + def test_factorial_negative_number_raises_exception(self): + """Test that factorial of negative number raises ValueError""" + with self.assertRaises(ValueError) as context: + calculator.factorial(-1) + self.assertEqual(str(context.exception), "Factorial is not defined for negative numbers") + + def test_is_prime_small_numbers(self): + """Test prime checking for small numbers""" + self.assertFalse(calculator.is_prime(0)) + self.assertFalse(calculator.is_prime(1)) + self.assertTrue(calculator.is_prime(2)) + self.assertTrue(calculator.is_prime(3)) + self.assertFalse(calculator.is_prime(4)) + self.assertTrue(calculator.is_prime(5)) + + def test_is_prime_larger_numbers(self): + """Test prime checking for larger numbers""" + self.assertTrue(calculator.is_prime(17)) + self.assertTrue(calculator.is_prime(23)) + self.assertFalse(calculator.is_prime(25)) + self.assertFalse(calculator.is_prime(100)) + + def test_average_positive_numbers(self): + """Test average calculation with positive numbers""" + numbers = [1, 2, 3, 4, 5] + result = calculator.average(numbers) + self.assertEqual(result, 3.0) + + def test_average_mixed_numbers(self): + """Test average calculation with mixed positive/negative numbers""" + numbers = [-2, -1, 0, 1, 2] + result = calculator.average(numbers) + self.assertEqual(result, 0.0) + + def test_average_single_number(self): + """Test average calculation with single number""" + numbers = [42] + result = calculator.average(numbers) + self.assertEqual(result, 42.0) + + def test_average_empty_list_raises_exception(self): + """Test that average of empty list raises ValueError""" + with self.assertRaises(ValueError) as context: + calculator.average([]) + self.assertEqual(str(context.exception), "Cannot calculate average of empty list") + + def test_floating_point_operations(self): + """Test operations with floating point numbers""" + result = calculator.add(1.5, 2.3) + self.assertAlmostEqual(result, 3.8, places=1) + + result = calculator.multiply(2.5, 4.0) + self.assertEqual(result, 10.0) + + def setUp(self): + """Set up test fixtures before each test method""" + self.test_numbers = [1, 2, 3, 4, 5] + self.negative_numbers = [-5, -3, -1] + + def tearDown(self): + """Clean up after each test method""" + pass # No cleanup needed for this example + + +if __name__ == '__main__': + # Run tests with more verbose output + unittest.main(verbosity=2)