"""
Test Suite for Calculator Module

Tests all mathematical operations including the average function.
"""

import unittest
from calculator import add, subtract, multiply, divide, average


class TestBasicOperations(unittest.TestCase):
    """Test basic arithmetic operations."""
    
    def test_add_positive_numbers(self):
        """Test addition of positive numbers."""
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(10, 20), 30)
    
    def test_add_negative_numbers(self):
        """Test addition with negative numbers."""
        self.assertEqual(add(-5, -3), -8)
        self.assertEqual(add(-5, 3), -2)
    
    def test_add_zero(self):
        """Test addition with zero."""
        self.assertEqual(add(0, 5), 5)
        self.assertEqual(add(5, 0), 5)
    
    def test_subtract_positive_numbers(self):
        """Test subtraction of positive numbers."""
        self.assertEqual(subtract(10, 5), 5)
        self.assertEqual(subtract(20, 8), 12)
    
    def test_subtract_negative_numbers(self):
        """Test subtraction with negative numbers."""
        self.assertEqual(subtract(-5, -3), -2)
        self.assertEqual(subtract(5, -3), 8)
    
    def test_multiply_positive_numbers(self):
        """Test multiplication of positive numbers."""
        self.assertEqual(multiply(3, 4), 12)
        self.assertEqual(multiply(5, 6), 30)
    
    def test_multiply_by_zero(self):
        """Test multiplication by zero."""
        self.assertEqual(multiply(5, 0), 0)
        self.assertEqual(multiply(0, 5), 0)
    
    def test_multiply_negative_numbers(self):
        """Test multiplication with negative numbers."""
        self.assertEqual(multiply(-3, 4), -12)
        self.assertEqual(multiply(-3, -4), 12)
    
    def test_divide_positive_numbers(self):
        """Test division of positive numbers."""
        self.assertEqual(divide(10, 2), 5)
        self.assertEqual(divide(15, 3), 5)
    
    def test_divide_with_float_result(self):
        """Test division resulting in float."""
        self.assertAlmostEqual(divide(10, 3), 3.333333, places=5)
        self.assertEqual(divide(7, 2), 3.5)
    
    def test_divide_by_zero(self):
        """Test division by zero raises ValueError."""
        with self.assertRaises(ValueError) as context:
            divide(10, 0)
        self.assertEqual(str(context.exception), "Cannot divide by zero")


class TestAverageFunction(unittest.TestCase):
    """Test the average calculation function."""
    
    def test_average_positive_numbers(self):
        """Test average of positive numbers."""
        self.assertEqual(average(1, 2, 3, 4, 5), 3.0)
        self.assertEqual(average(10, 20, 30), 20.0)
    
    def test_average_single_number(self):
        """Test average of a single number."""
        self.assertEqual(average(5), 5.0)
        self.assertEqual(average(42), 42.0)
    
    def test_average_negative_numbers(self):
        """Test average with negative numbers."""
        self.assertEqual(average(-5, -10, -15), -10.0)
        self.assertEqual(average(-2, 2), 0.0)
    
    def test_average_mixed_numbers(self):
        """Test average with mixed positive and negative numbers."""
        self.assertEqual(average(-10, 0, 10), 0.0)
        self.assertEqual(average(1, 2, 3, -6), 0.0)
    
    def test_average_float_numbers(self):
        """Test average with float numbers."""
        self.assertAlmostEqual(average(1.5, 2.5, 3.5), 2.5)
        self.assertAlmostEqual(average(0.1, 0.2, 0.3), 0.2, places=5)
    
    def test_average_empty_list(self):
        """Test average with no arguments raises ValueError."""
        with self.assertRaises(ValueError) as context:
            average()
        self.assertEqual(str(context.exception), "Cannot calculate average of empty list")
    
    def test_average_large_dataset(self):
        """Test average with a large number of values."""
        numbers = list(range(1, 101))  # 1 to 100
        self.assertEqual(average(*numbers), 50.5)


class TestEdgeCases(unittest.TestCase):
    """Test edge cases and special scenarios."""
    
    def test_operations_with_floats(self):
        """Test operations with floating point numbers."""
        self.assertAlmostEqual(add(0.1, 0.2), 0.3, places=5)
        self.assertAlmostEqual(multiply(0.1, 0.2), 0.02, places=5)
    
    def test_operations_with_large_numbers(self):
        """Test operations with large numbers."""
        self.assertEqual(add(1000000, 2000000), 3000000)
        self.assertEqual(multiply(1000, 1000), 1000000)


if __name__ == '__main__':
    # Run unittest tests
    unittest.main()