TestComplexNumberLibrary.py

"""
Unit Tests for Complex Number Library

This module contains comprehensive unit tests for all functions in the
ComplexNumberLibrary module using Python's unittest framework.

Author: Andersson Programming
"""

import unittest
import math
from ComplexNumberLibrary import (
    add_complex, subtract_complex, multiply_complex, divide_complex,
    modulus_complex, conjugate_complex, phase_complex,
    cartesian_to_polar, polar_to_cartesian
)


class TestComplexNumberLibrary(unittest.TestCase):
    """Test cases for complex number operations."""
    
    def setUp(self):
        """Set up test fixtures with common complex numbers."""
        self.z1 = (3, 4)  # 3 + 4i
        self.z2 = (1, 2)  # 1 + 2i
        self.z3 = (5, 0)  # 5 + 0i (real number)
        self.z4 = (0, 3)  # 0 + 3i (imaginary number)
        self.z_zero = (0, 0)  # Zero complex number
    
    def test_add_complex(self):
        """Test complex number addition."""
        # Test case 1: Basic addition
        result = add_complex(self.z1, self.z2)
        self.assertEqual(result, (4, 6))
        
        # Test case 2: Addition with zero
        result = add_complex(self.z1, self.z_zero)
        self.assertEqual(result, self.z1)
        
        # Test case 3: Addition with real number
        result = add_complex(self.z3, self.z4)
        self.assertEqual(result, (5, 3))
    
    def test_subtract_complex(self):
        """Test complex number subtraction."""
        # Test case 1: Basic subtraction
        result = subtract_complex(self.z1, self.z2)
        self.assertEqual(result, (2, 2))
        
        # Test case 2: Subtraction resulting in zero
        result = subtract_complex(self.z1, self.z1)
        self.assertEqual(result, self.z_zero)
        
        # Test case 3: Subtraction with negative result
        result = subtract_complex(self.z2, self.z1)
        self.assertEqual(result, (-2, -2))
    
    def test_multiply_complex(self):
        """Test complex number multiplication."""
        # Test case 1: Basic multiplication
        result = multiply_complex(self.z1, self.z2)
        expected = (3*1 - 4*2, 3*2 + 4*1)  # (3-8, 6+4) = (-5, 10)
        self.assertEqual(result, expected)
        
        # Test case 2: Multiplication by zero
        result = multiply_complex(self.z1, self.z_zero)
        self.assertEqual(result, self.z_zero)
        
        # Test case 3: Multiplication by real number
        result = multiply_complex(self.z1, (2, 0))
        self.assertEqual(result, (6, 8))
    
    def test_divide_complex(self):
        """Test complex number division."""
        # Test case 1: Basic division
        result = divide_complex((8, 6), (3, 2))
        # Expected: (8*3 + 6*2)/(3²+2²), (6*3 - 8*2)/(3²+2²) = (36/13, 2/13)
        expected_real = 36/13
        expected_imag = 2/13
        self.assertAlmostEqual(result[0], expected_real, places=10)
        self.assertAlmostEqual(result[1], expected_imag, places=10)
        
        # Test case 2: Division by zero should raise exception
        with self.assertRaises(ZeroDivisionError):
            divide_complex(self.z1, self.z_zero)
        
        # Test case 3: Division by real number
        result = divide_complex((6, 8), (2, 0))
        self.assertEqual(result, (3.0, 4.0))
    
    def test_modulus_complex(self):
        """Test complex number modulus calculation."""
        # Test case 1: Classic 3-4-5 triangle
        result = modulus_complex(self.z1)
        self.assertEqual(result, 5.0)
        
        # Test case 2: Modulus of zero
        result = modulus_complex(self.z_zero)
        self.assertEqual(result, 0.0)
        
        # Test case 3: Modulus of pure imaginary number
        result = modulus_complex(self.z4)
        self.assertEqual(result, 3.0)
    
    def test_conjugate_complex(self):
        """Test complex number conjugate calculation."""
        # Test case 1: Basic conjugate
        result = conjugate_complex(self.z1)
        self.assertEqual(result, (3, -4))
        
        # Test case 2: Conjugate of real number
        result = conjugate_complex(self.z3)
        self.assertEqual(result, (5, 0))
        
        # Test case 3: Conjugate of pure imaginary number
        result = conjugate_complex(self.z4)
        self.assertEqual(result, (0, -3))
    
    def test_phase_complex(self):
        """Test complex number phase calculation."""
        # Test case 1: First quadrant
        result = phase_complex((1, 1))
        self.assertAlmostEqual(result, math.pi/4, places=10)
        
        # Test case 2: Positive real axis
        result = phase_complex((5, 0))
        self.assertAlmostEqual(result, 0.0, places=10)
        
        # Test case 3: Positive imaginary axis
        result = phase_complex((0, 3))
        self.assertAlmostEqual(result, math.pi/2, places=10)
    
    def test_cartesian_to_polar(self):
        """Test conversion from Cartesian to polar coordinates."""
        # Test case 1: Classic 3-4-5 triangle
        result = cartesian_to_polar(self.z1)
        expected_magnitude = 5.0
        expected_phase = math.atan2(4, 3)
        self.assertAlmostEqual(result[0], expected_magnitude, places=10)
        self.assertAlmostEqual(result[1], expected_phase, places=10)
        
        # Test case 2: Unit complex number on real axis
        result = cartesian_to_polar((1, 0))
        self.assertAlmostEqual(result[0], 1.0, places=10)
        self.assertAlmostEqual(result[1], 0.0, places=10)
    
    def test_polar_to_cartesian(self):
        """Test conversion from polar to Cartesian coordinates."""
        # Test case 1: Convert back from known polar form
        polar_form = (5.0, math.atan2(4, 3))
        result = polar_to_cartesian(polar_form)
        self.assertAlmostEqual(result[0], 3.0, places=10)
        self.assertAlmostEqual(result[1], 4.0, places=10)
        
        # Test case 2: Unit circle at 45 degrees
        polar_form = (1.0, math.pi/4)
        result = polar_to_cartesian(polar_form)
        expected = (math.cos(math.pi/4), math.sin(math.pi/4))
        self.assertAlmostEqual(result[0], expected[0], places=10)
        self.assertAlmostEqual(result[1], expected[1], places=10)
    
    def test_round_trip_conversions(self):
        """Test that converting to polar and back preserves the original number."""
        test_numbers = [self.z1, self.z2, self.z3, self.z4, (1, 1), (-2, 3)]
        
        for z in test_numbers:
            with self.subTest(z=z):
                polar = cartesian_to_polar(z)
                back_to_cartesian = polar_to_cartesian(polar)
                self.assertAlmostEqual(back_to_cartesian[0], z[0], places=10)
                self.assertAlmostEqual(back_to_cartesian[1], z[1], places=10)
    
    def test_mathematical_properties(self):
        """Test important mathematical properties of complex numbers."""
        # Test case 1: |z * w| = |z| * |w|
        z_mod = modulus_complex(self.z1)
        w_mod = modulus_complex(self.z2)
        product = multiply_complex(self.z1, self.z2)
        product_mod = modulus_complex(product)
        self.assertAlmostEqual(product_mod, z_mod * w_mod, places=10)
        
        # Test case 2: z * conjugate(z) = |z|²
        z_conj = conjugate_complex(self.z1)
        product = multiply_complex(self.z1, z_conj)
        z_mod_squared = modulus_complex(self.z1) ** 2
        self.assertAlmostEqual(product[0], z_mod_squared, places=10)
        self.assertAlmostEqual(product[1], 0.0, places=10)


def run_tests():
    """Function to run all tests."""
    unittest.main()


if __name__ == '__main__':
    run_tests()