03 Testing Fundamentals: Boundary Analysis and LLM-Assisted Testing

import sys
import math

# These are NOT the same!
print(math.inf > sys.float_info.max)  # True - infinity is bigger than any finite
print(sys.float_info.max * 2)         # inf - overflow!
print(1 / math.inf)                   # 0.0 - reciprocal of infinity
print(1 / sys.float_info.max)         # ≈ 5.6e-309 - tiny but finite!

import math

# Use math.inf (preferred for readability)
def test_reciprocal_handles_infinity():
    result = reciprocal(math.inf)
    assert result == 0.0  # 1/inf = 0

import sys

def test_reciprocal_handles_max_float():
    result = reciprocal(sys.float_info.max)
    # Reciprocal of largest finite → extremely small
    assert result > 0
    assert result < sys.float_info.min  # Might underflow to subnormal

import math

def test_reciprocal_precision_at_boundary():
    # Test the "next" representable value after 1.0
    x = math.nextafter(1.0, 2.0)  # Slightly larger than 1.0
    result = reciprocal(x)
    # Should be slightly less than 1.0
    assert result < 1.0

import numpy as np

# For float64 (Python float equivalent)
fi = np.finfo(np.float64)
print(fi.max)        # Largest finite (≈ 1.8e308)
print(fi.tiny)       # Smallest positive normalized (≈ 2.2e-308)
print(fi.eps)        # Machine epsilon (≈ 2.2e-16)

# Use with nextafter
x_next_to_max = np.nextafter(fi.max, np.inf)  # → inf

# For float32 (if working with single precision)
fi32 = np.finfo(np.float32)
print(fi32.max)      # ≈ 3.4e38 (much smaller than float64!)

import sys
import math
import pytest

# Define constants for readability (following best practices)
INF = math.inf
NINF = -math.inf
NAN = math.nan
FMAX = sys.float_info.max
FMIN_NORM_POS = sys.float_info.min
FMIN_SUB_POS = math.ulp(0.0)
EPSILON = sys.float_info.epsilon


class TestReciprocalBoundaries:
    """Comprehensive boundary tests for reciprocal(x) function."""

    # BASIC BOUNDARIES (near zero, typical values)

    def test_reciprocal_boundary_near_zero_positive(self):
        """Boundary: Very small positive number"""
        result = reciprocal(1e-6)  # 0.000001
        assert result == pytest.approx(1e6, rel=1e-9)  # Should be 1000000

    def test_reciprocal_boundary_near_zero_negative(self):
        """Boundary: Very small negative number"""
        result = reciprocal(-1e-6)
        assert result == pytest.approx(-1e6, rel=1e-9)

    def test_reciprocal_boundary_exactly_zero(self):
        """Boundary: Exactly zero (should raise exception)"""
        with pytest.raises(ZeroDivisionError):
            reciprocal(0.0)

    def test_reciprocal_boundary_very_large_positive(self):
        """Boundary: Very large positive number"""
        result = reciprocal(1e10)
        assert result == pytest.approx(1e-10, rel=1e-9)

    # FINITE RANGE BOUNDARIES (sys.float_info limits)

    def test_reciprocal_boundary_max_finite_float(self):
        """Boundary: Largest finite float (sys.float_info.max ≈ 1.8e308)

        Tests overflow prevention at upper finite boundary.
        Reciprocal of max finite → extremely small result (may underflow to subnormal).
        """
        result = reciprocal(FMAX)
        assert result > 0, "Reciprocal of max float should be positive"
        assert result < FMIN_NORM_POS, "Result underflows below normalized range (subnormal)"
        # Result is approximately 5.6e-309 (subnormal/denormalized)

    def test_reciprocal_boundary_min_normalized_float(self):
        """Boundary: Smallest positive normalized float (sys.float_info.min ≈ 2.2e-308)

        Tests underflow-to-overflow transition.
        Reciprocal of min normalized → extremely large result (overflows to infinity).
        """
        result = reciprocal(FMIN_NORM_POS)
        assert result == INF, "Reciprocal of min normalized float overflows to infinity"

    def test_reciprocal_boundary_min_subnormal_float(self):
        """Boundary: Smallest positive subnormal float (math.ulp(0.0) ≈ 5e-324)

        Tests denormalized number handling.
        Reciprocal of smallest representable → massive overflow to infinity.
        """
        result = reciprocal(FMIN_SUB_POS)
        assert result == INF, "Reciprocal of min subnormal overflows to infinity"

    def test_reciprocal_boundary_epsilon(self):
        """Boundary: Machine epsilon (sys.float_info.epsilon ≈ 2.2e-16)

        Tests precision limit behavior.
        Epsilon is smallest value where 1.0 + epsilon != 1.0
        """
        result = reciprocal(EPSILON)
        expected = 1.0 / EPSILON  # ≈ 4.5e15
        assert result == pytest.approx(expected, rel=1e-9)

    def test_reciprocal_boundary_most_negative_finite(self):
        """Boundary: Most negative finite float (-sys.float_info.max ≈ -1.8e308)

        Tests lower finite boundary (there is no sys.float_info.min_negative).
        """
        result = reciprocal(-FMAX)
        assert result < 0, "Reciprocal of most negative finite should be negative"
        assert result > -FMIN_NORM_POS, "Result is tiny negative (subnormal range)"

    # NON-FINITE BOUNDARIES (infinities and NaN)

    def test_reciprocal_boundary_positive_infinity(self):
        """Boundary: Positive infinity (non-finite value)

        Tests special value handling (not overflow prevention).
        1 / inf = 0 (mathematical limit)
        """
        result = reciprocal(INF)
        assert result == 0.0, "Reciprocal of positive infinity should be zero"

    def test_reciprocal_boundary_negative_infinity(self):
        """Boundary: Negative infinity (non-finite value)

        1 / -inf = -0 (negative zero)
        """
        result = reciprocal(NINF)
        # Python treats 0.0 == -0.0 as True (IEEE 754 behavior)
        assert result == 0.0 or result == -0.0, "Reciprocal of -inf should be zero"

    def test_reciprocal_boundary_nan(self):
        """Boundary: Not a Number (undefined/invalid input)

        NaN propagates through operations (doesn't crash).
        Important: nan == nan is always False! Use math.isnan().
        """
        result = reciprocal(NAN)
        assert math.isnan(result), "Reciprocal of NaN should be NaN (propagates)"

    # RAZOR-EDGE BOUNDARIES (using math.nextafter)

    def test_reciprocal_boundary_next_after_max_toward_inf(self):
        """Boundary: Next float after max (toward infinity)

        Uses math.nextafter() to test the exact transition point.
        Next float after FMAX toward infinity IS infinity.
        """
        x_after_max = math.nextafter(FMAX, INF)
        assert x_after_max == INF, "Next float after max toward inf is infinity"
        result = reciprocal(x_after_max)
        assert result == 0.0, "Reciprocal of inf is 0"

    def test_reciprocal_boundary_next_after_one_toward_two(self):
        """Boundary: Next representable float after 1.0

        Tests ULP (Unit in Last Place) sensitivity.
        1.0 + epsilon is the next representable value after 1.0
        """
        x_just_above_one = math.nextafter(1.0, 2.0)
        result = reciprocal(x_just_above_one)
        # Reciprocal should be slightly less than 1.0
        assert result < 1.0, f"Expected < 1.0, got {result}"
        assert result == pytest.approx(1.0, rel=1e-14), "Should be very close to 1.0"

    def test_reciprocal_boundary_ulp_sensitivity(self):
        """Boundary: Testing ULP (Unit in Last Place) around a value

        Demonstrates floating-point granularity.
        """
        x = 1000.0
        ulp_at_x = math.ulp(x)  # Spacing at 1000.0

        result1 = reciprocal(x)
        result2 = reciprocal(x + ulp_at_x)  # Next representable value

        assert result1 != result2, "Adjacent floats should produce different reciprocals"
        assert result1 > result2, "Larger input → smaller reciprocal"

# ❌ TEDIOUS: Writing 6 nearly-identical tests
def test_reciprocal_max_float():
    result = reciprocal(FMAX)
    assert result > 0 and result < FMIN_NORM_POS

def test_reciprocal_negative_max_float():
    result = reciprocal(-FMAX)
    assert result < 0 and result > -FMIN_NORM_POS

def test_reciprocal_min_norm_float():
    result = reciprocal(FMIN_NORM_POS)
    assert result == INF

# ... 3 more similar tests ...

# ✅ CLEAN: One test function, multiple inputs
@pytest.mark.parametrize("x, expected_behavior", [
    (FMAX, "underflow to subnormal"),
    (-FMAX, "underflow to negative subnormal"),
    (FMIN_NORM_POS, "overflow to infinity"),
    (FMIN_SUB_POS, "overflow to infinity"),
    (INF, "exact zero"),
    (NINF, "exact zero"),
])
def test_reciprocal_extreme_boundaries_summary(x, expected_behavior):
    """Parametrized test covering all extreme boundaries with descriptions."""
    result = reciprocal(x)

    if "subnormal" in expected_behavior:
        assert math.isfinite(result), f"{expected_behavior}: result should be finite"
        assert abs(result) < FMIN_NORM_POS, f"{expected_behavior}: should be in subnormal range"
    elif "overflow to infinity" in expected_behavior:
        assert result == INF, f"{expected_behavior}: should overflow to infinity"
    elif "exact zero" in expected_behavior:
        assert result == 0.0, f"{expected_behavior}: should be exactly zero"

# Testing multiple equivalence classes with same validation
@pytest.mark.parametrize("angle", [-10, -20, -30, -45])
def test_find_intersection_downward_angles_all_succeed(angle):
    """Test that all downward angles find intersection"""
    x, y, dist = find_intersection(x_road, y_road, angle)
    assert x is not None
    assert dist > 0

# Testing boundary values with expected results
@pytest.mark.parametrize("x, expected", [
    (1.0, 1.0),
    (2.0, 0.5),
    (0.5, 2.0),
    (10.0, 0.1),
])
def test_reciprocal_normal_values(x, expected):
    """Test reciprocal with normal values"""
    result = reciprocal(x)
    assert result == pytest.approx(expected, rel=1e-9)

# PARAMETRIZED TEST (pytest feature for multiple similar tests)

@pytest.mark.parametrize("x, expected_behavior", [
    (FMAX, "underflow to subnormal"),
    (-FMAX, "underflow to negative subnormal"),
    (FMIN_NORM_POS, "overflow to infinity"),
    (FMIN_SUB_POS, "overflow to infinity"),
    (INF, "exact zero"),
    (NINF, "exact zero"),
])
def test_reciprocal_extreme_boundaries_summary(x, expected_behavior):
    """Parametrized test covering all extreme boundaries with descriptions."""
    result = reciprocal(x)

    if "subnormal" in expected_behavior:
        assert math.isfinite(result), f"{expected_behavior}: result should be finite"
        assert abs(result) < FMIN_NORM_POS, f"{expected_behavior}: should be in subnormal range"
    elif "overflow to infinity" in expected_behavior:
        assert result == INF, f"{expected_behavior}: should overflow to infinity"
    elif "exact zero" in expected_behavior:
        assert result == 0.0, f"{expected_behavior}: should be exactly zero"

# ❌ WRONG: Testing only infinity
def test_reciprocal_large_values():
    result = reciprocal(float('inf'))
    assert result == 0.0

# Problem: This doesn't test finite overflow (sys.float_info.max)!
# A function could handle inf correctly but crash on FMAX.

# ✅ CORRECT: Test BOTH finite and non-finite boundaries
def test_reciprocal_max_finite():
    result = reciprocal(sys.float_info.max)  # Finite
    assert result < sys.float_info.min  # Underflow behavior

def test_reciprocal_infinity():
    result = reciprocal(math.inf)  # Non-finite
    assert result == 0.0  # Special value handling

def test_reciprocal_sum_boundary_sum_exactly_zero():
    """Boundary: Sum cancels exactly to zero"""
    with pytest.raises(ZeroDivisionError):
        reciprocal_sum(1.0, -0.5, -0.5)

def test_reciprocal_sum_boundary_sum_near_zero_positive():
    """Boundary: Sum is very small positive"""
    result = reciprocal_sum(1.0, -0.9999, 0.0)  # sum = 0.0001
    assert result == pytest.approx(10000.0, rel=1e-5)

def test_reciprocal_sum_boundary_all_zeros():
    """Boundary: All parameters zero"""
    with pytest.raises(ZeroDivisionError):
        reciprocal_sum(0.0, 0.0, 0.0)

def test_reciprocal_sum_boundary_two_zeros():
    """Boundary: Two parameters zero, one non-zero"""
    result = reciprocal_sum(0.0, 0.0, 0.5)  # sum = 0.5
    assert result == pytest.approx(2.0, rel=1e-10)

def test_array_sum_boundary_empty_array():
    """Boundary: Empty array (length = 0)"""
    with pytest.raises(ValueError):
        array_sum(np.array([]))

def test_array_sum_boundary_single_element():
    """Boundary: Single element (length = 1)"""
    result = array_sum(np.array([5.0]))
    assert result == 5.0

def test_array_sum_boundary_two_elements():
    """Boundary: Two elements (minimum non-trivial)"""
    result = array_sum(np.array([3.0, 4.0]))
    assert result == 7.0

def test_array_sum_boundary_all_zeros():
    """Boundary: All elements are zero"""
    result = array_sum(np.array([0.0, 0.0, 0.0]))
    assert result == 0.0

def test_array_sum_boundary_alternating_near_zero():
    """Boundary: Values near zero with alternating signs"""
    result = array_sum(np.array([1e-10, -1e-10, 1e-10]))
    assert abs(result - 1e-10) < 1e-15  # Sum should be close to 1e-10

# tests/test_geometry.py (unit tests - FAST)
def test_find_intersection_basic():
    """Unit test: Small representative array"""
    x_road = np.array([0, 10, 20])  # Only 3 points
    y_road = np.array([0, 2, 4])
    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is not None

# tests/test_geometry_performance.py (performance tests - SLOW)
@pytest.mark.slow  # Mark as slow so we can skip during development
def test_find_intersection_large_road():
    """Performance test: Realistic large road dataset"""
    x_road = np.linspace(0, 1000, 10_000)  # 10,000 points
    y_road = np.sin(x_road / 10) * 5

    import time
    start = time.time()
    x, y, dist = find_intersection(x_road, y_road, -10.0)
    elapsed = time.time() - start

    assert x is not None
    assert elapsed < 0.1, f"Too slow: {elapsed:.3f}s for 10k points"

from hypothesis import given, strategies as st

@given(st.lists(st.floats(allow_nan=False, allow_infinity=False),
                min_size=0, max_size=100))
def test_array_sum_any_valid_array(arr):
    """Property: array_sum should never crash on valid float arrays

    Hypothesis will automatically generate hundreds of test cases
    with different array sizes and values.
    """
    if len(arr) == 0:
        with pytest.raises(ValueError):
            array_sum(np.array(arr))
    else:
        result = array_sum(np.array(arr))
        assert isinstance(result, (int, float, np.number))

# ✅ GOOD: Representative sizes for unit tests
def test_find_intersection_typical_road():
    """Test with typical road size (~100 points)"""
    x_road = np.linspace(0, 80, 100)  # Realistic: 100 points over 80 meters
    y_road = generate_road_profile(num_points=100)

    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is not None  # Fast test, runs in ~1ms

# ❌ BAD: Unnecessarily large for a unit test
def test_find_intersection_huge_road():
    """This belongs in performance tests, not unit tests"""
    x_road = np.linspace(0, 10000, 1_000_000)  # Overkill!
    y_road = np.random.rand(1_000_000)

    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is not None  # Slow test, runs in ~500ms

class TestFindIntersectionBoundaries:
    """Boundary value tests for find_intersection()"""

    # ARRAY LENGTH BOUNDARIES

    def test_boundary_empty_arrays(self):
        """Boundary: Empty road arrays (len = 0)"""
        x, y, dist = find_intersection(np.array([]), np.array([]), -10.0)
        assert x is None

    def test_boundary_single_point(self):
        """Boundary: Single point (len = 1)"""
        x, y, dist = find_intersection(np.array([5.0]), np.array([2.0]), -10.0)
        assert x is None  # Can't form segment

    def test_boundary_two_points_minimum_valid(self):
        """Boundary: Two points (len = 2, minimum valid)"""
        x_road = np.array([0.0, 10.0])
        y_road = np.array([0.0, 2.0])
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=5.0)
        assert x is not None  # Should work

    # ANGLE BOUNDARIES

    def test_boundary_angle_exactly_negative_90(self):
        """Boundary: Angle exactly -90° (vertical downward)"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        x, y, dist = find_intersection(x_road, y_road, -90.0)
        # Implementation returns None for vertical - verify this is intentional
        assert x is None

    def test_boundary_angle_near_negative_90(self):
        """Boundary: Angle near -90° (-89.9°)"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        x, y, dist = find_intersection(x_road, y_road, -89.9, camera_x=0.0, camera_y=10.0)
        # Nearly vertical - should still find intersection if one exists

    def test_boundary_angle_exactly_zero(self):
        """Boundary: Angle exactly 0° (horizontal)"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([2.0, 2.0, 2.0])  # Flat road at y=2
        x, y, dist = find_intersection(x_road, y_road, 0.0, camera_x=-5.0, camera_y=2.0)
        assert x is not None  # Horizontal ray should hit flat road

    def test_boundary_angle_near_zero(self):
        """Boundary: Angle near 0° (0.1° - nearly horizontal)"""
        x_road = np.array([0, 10, 20, 30])
        y_road = np.array([0, 1, 2, 3])
        x, y, dist = find_intersection(x_road, y_road, 0.1, camera_x=0.0, camera_y=1.5)
        # Very shallow angle

    def test_boundary_angle_exactly_90(self):
        """Boundary: Angle exactly 90° (vertical upward)"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        x, y, dist = find_intersection(x_road, y_road, 90.0)
        assert x is None  # Implementation returns None for vertical

    # CAMERA POSITION BOUNDARIES

    def test_boundary_camera_at_road_start(self):
        """Boundary: Camera x-position at road start"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=10.0)
        assert x is not None

    def test_boundary_camera_at_road_end(self):
        """Boundary: Camera x-position at road end"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=20.0, camera_y=10.0)
        # Camera at end, looking down - might or might not intersect

    def test_boundary_camera_at_road_level(self):
        """Boundary: Camera y-position at road level"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([2.0, 2.0, 2.0])  # Flat at y=2
        x, y, dist = find_intersection(x_road, y_road, 0.0, camera_x=5.0, camera_y=2.0)
        # Camera ON the road, horizontal ray - tangent case

    def test_boundary_camera_at_minimum_y(self):
        """Boundary: Camera at lowest point of road"""
        x_road = np.array([0, 10, 20, 30])
        y_road = np.array([5, 2, 3, 6])  # min at x=10, y=2
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=15.0, camera_y=2.0)
        # Camera at same height as lowest road point

    # INTERSECTION POSITION BOUNDARIES

    def test_boundary_intersection_at_first_point(self):
        """Boundary: Ray intersects at first road point"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([5, 3, 1])
        # Position camera so ray hits exactly at (0, 5)
        x, y, dist = find_intersection(x_road, y_road, -45.0, camera_x=-5.0, camera_y=10.0)
        if x is not None:
            assert abs(x - 0.0) < 0.1  # Should be near first point

    def test_boundary_intersection_at_last_point(self):
        """Boundary: Ray intersects at last road point"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        # Position so ray hits last point
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=15.0, camera_y=10.0)
        if x is not None and x > 18:
            assert abs(x - 20.0) < 2.0  # Should be near last point

    def test_boundary_intersection_at_segment_boundary(self):
        """Boundary: Ray intersects exactly where two segments meet"""
        x_road = np.array([0, 10, 20, 30])
        y_road = np.array([0, 5, 5, 10])
        # Ray aimed to hit exactly at (10, 5)
        x, y, dist = find_intersection(x_road, y_road, -30.0, camera_x=5.0, camera_y=10.0)
        if x is not None:
            # Could be reported as end of first segment or start of second
            assert 9.0 <= x <= 11.0

import sys
import math

# CONSTANTS (define once, use everywhere)
FMAX = sys.float_info.max              # Largest finite (≈1.8e308)
FMIN_NORM = sys.float_info.min         # Smallest normalized (≈2.2e-308)
FMIN_SUB = math.ulp(0.0)               # Smallest subnormal (≈5e-324)
EPSILON = sys.float_info.epsilon       # Machine epsilon (≈2.2e-16)
INF = math.inf                         # Positive infinity
NINF = -math.inf                       # Negative infinity
NAN = math.nan                         # Not a number

# TEST CHECKLIST FOR FLOAT FUNCTIONS

# ✅ Finite boundaries (test overflow/underflow)
test_function(FMAX)           # Largest finite
test_function(-FMAX)          # Most negative finite
test_function(FMIN_NORM)      # Smallest normalized positive
test_function(FMIN_SUB)       # Smallest subnormal positive

# ✅ Non-finite values (test special value handling)
test_function(INF)            # Positive infinity
test_function(NINF)           # Negative infinity
test_function(NAN)            # Not a Number

# ✅ Precision boundaries
test_function(EPSILON)        # Machine epsilon
test_function(1.0 + EPSILON)  # Next after 1.0

# ✅ Razor-edge transitions (using math.nextafter)
math.nextafter(FMAX, INF)     # → inf (overflow transition)
math.nextafter(1.0, 2.0)      # Next representable after 1.0
math.nextafter(1.0, 0.0)      # Previous representable before 1.0

# ✅ Checking results
math.isfinite(x)              # True if not inf/nan
math.isinf(x)                 # True if +inf or -inf
math.isnan(x)                 # True if nan (don't use x == nan!)
math.ulp(x)                   # Spacing at x (precision)

def calculate_grade(score: int) -> str:
    """
    Calculate letter grade based on score.

    Args:
        score: Integer between 0 and 100

    Returns:
        Letter grade (A, B, C, D, F)

    Raises:
        ValueError: If score is not in valid range
    """
    if score < 0 or score > 100:
        raise ValueError("Score must be between 0 and 100")

    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

import pytest

def test_grade_boundary_A_B_threshold():
    """Boundary: score = 89 (B) vs 90 (A)"""
    assert calculate_grade(89) == "B"  # Just below A threshold
    assert calculate_grade(90) == "A"  # At A threshold

def test_grade_boundary_B_C_threshold():
    """Boundary: score = 79 (C) vs 80 (B)"""
    assert calculate_grade(79) == "C"  # Just below B threshold
    assert calculate_grade(80) == "B"  # At B threshold

def test_grade_boundary_C_D_threshold():
    """Boundary: score = 69 (D) vs 70 (C)"""
    assert calculate_grade(69) == "D"  # Just below C threshold
    assert calculate_grade(70) == "C"  # At C threshold

def test_grade_boundary_D_F_threshold():
    """Boundary: score = 59 (F) vs 60 (D)"""
    assert calculate_grade(59) == "F"  # Just below D threshold
    assert calculate_grade(60) == "D"  # At D threshold

def test_grade_boundary_valid_range_lower():
    """Boundary: score = 0 (valid) vs -1 (invalid)"""
    assert calculate_grade(0) == "F"   # Minimum valid score
    with pytest.raises(ValueError):
        calculate_grade(-1)             # Just below valid range

def test_grade_boundary_valid_range_upper():
    """Boundary: score = 100 (valid) vs 101 (invalid)"""
    assert calculate_grade(100) == "A"  # Maximum valid score
    with pytest.raises(ValueError):
        calculate_grade(101)             # Just above valid range

def calculate_shipping_cost(weight: float, distance: float, express: bool = False) -> float:
    """
    Calculate shipping cost based on weight and distance.

    Args:
        weight: Weight in kg (0.1 to 50)
        distance: Distance in km (1 to 5000)
        express: Whether express shipping is requested

    Returns:
        float: Shipping cost in EUR

    Raises:
        ValueError: If weight or distance is out of range
    """
    if weight < 0.1 or weight > 50:
        raise ValueError("Weight must be between 0.1 and 50 kg")

    if distance < 1 or distance > 5000:
        raise ValueError("Distance must be between 1 and 5000 km")

    # Base cost calculation
    if weight <= 5:
        base_cost = 5.0
    elif weight <= 20:
        base_cost = 10.0
    else:
        base_cost = 20.0

    # Distance multiplier
    if distance <= 100:
        distance_multiplier = 1.0
    elif distance <= 500:
        distance_multiplier = 1.5
    else:
        distance_multiplier = 2.0

    cost = base_cost * distance_multiplier

    # Express shipping adds 50%
    if express:
        cost *= 1.5

    return round(cost, 2)

import pytest

# ===== Weight boundaries (distance and express fixed) =====

def test_shipping_weight_boundary_minimum():
    """Boundary: weight = 0.1 (valid) vs 0.09 (invalid)"""
    assert calculate_shipping_cost(0.1, 100, False) == 5.0  # Valid
    with pytest.raises(ValueError, match="Weight must be between"):
        calculate_shipping_cost(0.09, 100, False)  # Invalid

def test_shipping_weight_boundary_light_medium():
    """Boundary: weight = 5.0 (light) vs 5.1 (medium)"""
    cost_light = calculate_shipping_cost(5.0, 100, False)
    cost_medium = calculate_shipping_cost(5.1, 100, False)
    assert cost_light == 5.0   # Light: base=5.0, dist_mult=1.0 → 5.0
    assert cost_medium == 10.0  # Medium: base=10.0, dist_mult=1.0 → 10.0

def test_shipping_weight_boundary_medium_heavy():
    """Boundary: weight = 20.0 (medium) vs 20.1 (heavy)"""
    cost_medium = calculate_shipping_cost(20.0, 100, False)
    cost_heavy = calculate_shipping_cost(20.1, 100, False)
    assert cost_medium == 10.0  # Medium: base=10.0, dist_mult=1.0 → 10.0
    assert cost_heavy == 20.0   # Heavy: base=20.0, dist_mult=1.0 → 20.0

def test_shipping_weight_boundary_maximum():
    """Boundary: weight = 50 (valid) vs 50.1 (invalid)"""
    assert calculate_shipping_cost(50, 100, False) == 20.0  # Valid
    with pytest.raises(ValueError, match="Weight must be between"):
        calculate_shipping_cost(50.1, 100, False)  # Invalid

# ===== Distance boundaries (weight and express fixed) =====

def test_shipping_distance_boundary_minimum():
    """Boundary: distance = 1 (valid) vs 0.9 (invalid)"""
    assert calculate_shipping_cost(5.0, 1, False) == 5.0  # Valid
    with pytest.raises(ValueError, match="Distance must be between"):
        calculate_shipping_cost(5.0, 0.9, False)  # Invalid

def test_shipping_distance_boundary_local_regional():
    """Boundary: distance = 100 (local) vs 101 (regional)"""
    cost_local = calculate_shipping_cost(5.0, 100, False)
    cost_regional = calculate_shipping_cost(5.0, 101, False)
    assert cost_local == 5.0     # Local: base=5.0, dist_mult=1.0 → 5.0
    assert cost_regional == 7.5  # Regional: base=5.0, dist_mult=1.5 → 7.5

def test_shipping_distance_boundary_regional_long():
    """Boundary: distance = 500 (regional) vs 501 (long-distance)"""
    cost_regional = calculate_shipping_cost(5.0, 500, False)
    cost_long = calculate_shipping_cost(5.0, 501, False)
    assert cost_regional == 7.5  # Regional: base=5.0, dist_mult=1.5 → 7.5
    assert cost_long == 10.0     # Long: base=5.0, dist_mult=2.0 → 10.0

def test_shipping_distance_boundary_maximum():
    """Boundary: distance = 5000 (valid) vs 5001 (invalid)"""
    assert calculate_shipping_cost(5.0, 5000, False) == 10.0  # Valid
    with pytest.raises(ValueError, match="Distance must be between"):
        calculate_shipping_cost(5.0, 5001, False)  # Invalid

# ===== Express flag (weight and distance fixed) =====

def test_shipping_express_flag():
    """Dimension: express = False vs True"""
    cost_standard = calculate_shipping_cost(5.0, 100, False)
    cost_express = calculate_shipping_cost(5.0, 100, True)
    assert cost_standard == 5.0   # Standard: base=5.0, dist=1.0, express=1.0 → 5.0
    assert cost_express == 7.5    # Express: base=5.0, dist=1.0, express=1.5 → 7.5

# tests/test_geometry.py
import numpy as np
from numpy.typing import NDArray
import pytest
from road_profile_viewer.geometry import find_intersection

# Prompt: "Write pytest unit tests for find_intersection() covering:
# - Equivalence classes: downward angles, horizontal, upward angles, vertical
# - Boundary cases: empty arrays, single point, angle=90
# - Use AAA pattern (Arrange-Act-Assert)
# - Include proper type hints matching the actual repository code"

def test_find_intersection_downward_angle() -> None:
    """Test find_intersection with normal downward angle."""
    x_road: NDArray[np.float64] = np.array([0, 10, 20, 30], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([0, 2, 4, 6], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 10.0)
    assert x is not None
    assert y is not None
    assert dist is not None and dist > 0

def test_find_intersection_horizontal() -> None:
    """Test find_intersection with horizontal angle."""
    x_road: NDArray[np.float64] = np.array([0, 10, 20], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([0, 0, 0], dtype=np.float64)  # Flat road
    x, y, dist = find_intersection(x_road, y_road, 0.0, 0.0, 1.0)
    assert x is not None

def test_find_intersection_vertical() -> None:
    """Test find_intersection with vertical angle (90 degrees)."""
    x_road: NDArray[np.float64] = np.array([0, 10, 20], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([0, 2, 4], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, 90.0)
    assert x is None  # Current implementation returns None for vertical

def test_find_intersection_empty_road() -> None:
    """Test find_intersection with empty road arrays."""
    x_road: NDArray[np.float64] = np.array([], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is None

# LLM didn't test: What if camera is BELOW the road?
# Add this test:
def test_find_intersection_camera_below_road() -> None:
    """Test when camera is below road level."""
    x_road: NDArray[np.float64] = np.array([0, 10, 20], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([5, 5, 5], dtype=np.float64)  # Flat road at y=5
    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 0.0)  # Camera at y=0
    # Should still find intersection (ray goes down, crosses road above)
    assert x is not None

# LLM wrote:
assert x is not None  # Too weak!

# Better assertion:
assert 0 <= x <= 30, f"Expected x in [0, 30], got {x}"
assert y >= 0, f"Expected y positive, got {y}"

# LLM wrote:
x_road: NDArray[np.float64] = np.array([0, 10, 20], dtype=np.float64)
y_road: NDArray[np.float64] = np.array([0, 0, 0], dtype=np.float64)  # Flat road at y=0
x, y, dist = find_intersection(x_road, y_road, 0.0, 0.0, 1.0)  # Camera at y=1

# Problem: Horizontal ray from y=1 won't intersect road at y=0!
# Fix: Either raise camera or tilt road
x_road = np.array([0, 10, 20], dtype=np.float64)
y_road = np.array([0, 1, 2], dtype=np.float64)  # Sloped road

# You to LLM: "Add tests for upward angles where ray might not intersect"
# LLM generates:
def test_find_intersection_upward_angle_no_intersection() -> None:
    """Test that upward angle with road below returns None."""
    x_road: NDArray[np.float64] = np.array([0, 10, 20], dtype=np.float64)
    y_road: NDArray[np.float64] = np.array([0, 1, 2], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, 45.0, 0.0, 0.0)  # Ray goes up
    # Depending on implementation, might not intersect
    # If None is correct behavior:
    assert x is None

def find_intersection(x_road, y_road, ...):
    # Bug: Doesn't check if arrays are empty before accessing!
    for i in range(len(x_road) - 1):  # Crashes if len(x_road) = 0
        x1, y1 = x_road[i], y_road[i]
        ...

def find_intersection(x_road, y_road, ...):
    # Add validation
    if len(x_road) == 0 or len(y_road) == 0:
        return None, None, None

    # ... rest of function

# LLM might generate:
def test_calculate_distance():
    dist = calculate_distance(0, 0, 3, 4)
    assert dist > 0  # Too weak! Just checks it's positive

# Human knows Pythagorean theorem:
def test_calculate_distance():
    dist = calculate_distance(0, 0, 3, 4)
    assert abs(dist - 5.0) < 0.01, f"Expected 5.0, got {dist}"  # 3-4-5 triangle!

# ❌ LLM might generate this:
def test_find_intersection_multiple_angles():
    """Test intersection for various angles"""
    angles = [-10, -20, -30, -45]
    for angle in angles:  # ❌ Loop in test!
        x, y, dist = find_intersection(x_road, y_road, angle)
        if x is not None:  # ❌ Conditional in test!
            assert dist > 0
        else:
            assert dist is None  # ❌ Complex logic!

# ✅ Human refactors to simple, clear tests:
def test_find_intersection_returns_positive_distance_for_minus_10_degrees():
    """Test -10° angle returns positive distance"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 10.0)
    assert dist > 0  # No conditionals, no loops!

def test_find_intersection_returns_positive_distance_for_minus_20_degrees():
    """Test -20° angle returns positive distance"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, -20.0, 0.0, 10.0)
    assert dist > 0

# Or use pytest parametrize (cleaner for multiple similar tests):
@pytest.mark.parametrize("angle", [-10, -20, -30, -45])
def test_find_intersection_returns_positive_distance_for_downward_angles(angle):
    """Test that all downward angles return positive distance"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)
    x, y, dist = find_intersection(x_road, y_road, angle, 0.0, 10.0)
    assert dist > 0  # Simple assertion, pytest runs this test 4 times with different angles

# ❌ LLM-generated test with excessive mocking
from unittest.mock import patch

def test_find_intersection_calls_tan():
    """Test that find_intersection calls np.tan"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)

    with patch('numpy.tan') as mock_tan:
        mock_tan.return_value = 0.176  # Mocked slope
        x, y, dist = find_intersection(x_road, y_road, -10.0)
        mock_tan.assert_called_once()  # ❌ Tests HOW, not WHAT

# ✅ Test the RESULT (state), not the METHOD CALLS (interactions)
def test_find_intersection_returns_correct_intersection():
    """Test that intersection position is geometrically correct"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)

    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 10.0)

    # Assert FINAL STATE (outcomes)
    assert x is not None, "Should find intersection for downward angle"
    assert 0 <= x <= 20, f"Intersection x should be within road bounds, got {x}"
    assert y >= 0, f"Intersection y should be above ground, got {y}"
    assert dist > 0, f"Distance should be positive, got {dist}"

    # No assumptions about which numpy functions were called!

# ✅ Good use of mocking: External API
from unittest.mock import patch, Mock

def test_fetch_weather_data_returns_temperature():
    """Test weather fetching without hitting real API"""
    # Mock the external HTTP request (slow, requires network)
    with patch('requests.get') as mock_get:
        mock_response = Mock()
        mock_response.json.return_value = {'temp': 22.5}
        mock_get.return_value = mock_response

        # Now test your function
        temp = fetch_weather_data('Berlin')

        # Assert RESULT (not implementation)
        assert temp == 22.5

# tests/test_geometry.py
import numpy as np
from numpy.typing import NDArray
import pytest
from road_profile_viewer.geometry import find_intersection, calculate_ray_line


class TestFindIntersection:
    """Test suite for find_intersection() function."""

    def test_normal_downward_angle(self) -> None:
        """Equivalence class: Normal downward angle (-90° < angle < 0°)"""
        x_road: NDArray[np.float64] = np.array([0, 10, 20, 30], dtype=np.float64)
        y_road: NDArray[np.float64] = np.array([0, 2, 4, 6], dtype=np.float64)
        x, y, dist = find_intersection(x_road, y_road, -45.0, 0.0, 10.0)
        assert x is not None and y is not None and dist is not None

    def test_horizontal_angle(self) -> None:
        """Equivalence class: Horizontal ray (angle = 0°)"""
        # Your test here (let LLM generate, then review)
        pass

    def test_vertical_angle_boundary(self) -> None:
        """Boundary case: Vertical angle (90°)"""
        pass

    def test_empty_road_arrays(self) -> None:
        """Boundary case: Empty arrays"""
        pass

    def test_single_point_road(self) -> None:
        """Boundary case: Road with only one point"""
        pass

class TestCalculateRayLine:
    """Test suite for calculate_ray_line() function."""

    def test_normal_angle(self) -> None:
        """Test with normal angle"""
        x_ray: NDArray[np.float64]
        y_ray: NDArray[np.float64]
        x_ray, y_ray = calculate_ray_line(-10.0, camera_x=0.0, camera_y=2.0)
        assert len(x_ray) == 2
        assert len(y_ray) == 2
        assert x_ray[0] == 0.0  # Starts at camera
        assert y_ray[0] == 2.0

    def test_vertical_angle(self) -> None:
        """Boundary: Vertical angle (90°)"""
        x_ray, y_ray = calculate_ray_line(90.0)
        # Should handle vertical line
        assert x_ray[0] == x_ray[1]  # Vertical means same x

    def test_zero_angle(self) -> None:
        """Boundary: Horizontal angle (0°)"""
        x_ray, y_ray = calculate_ray_line(0.0, camera_y=2.0)
        # Horizontal line at y=2.0
        assert y_ray[0] == y_ray[1] == 2.0

# Unit test: Test ONLY geometry.find_intersection()
def test_find_intersection():
    x_road = np.array([0, 10])
    y_road = np.array([0, 2])
    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is not None

# Integration test: Test geometry + road together
def test_road_generation_with_intersection() -> None:
    """Test that road generation produces data that geometry can process."""
    from road_profile_viewer.road import generate_road_profile
    from road_profile_viewer.geometry import find_intersection

    # Generate road using road.py
    x_road: NDArray[np.float64]
    y_road: NDArray[np.float64]
    x_road, y_road = generate_road_profile(num_points=100, x_max=80)

    # Use geometry.py to find intersection
    x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=2.0)

    # Verify integration works
    assert x is not None, "Generated road should intersect camera ray"
    assert 0 <= x <= 80, "Intersection should be within road bounds"
    assert y >= 0, "Intersection should be above ground"

# tests/test_integration.py
import numpy as np
from numpy.typing import NDArray
import pytest
from road_profile_viewer.road import generate_road_profile
from road_profile_viewer.geometry import find_intersection, calculate_ray_line


class TestRoadGeometryIntegration:
    """Test integration between road and geometry modules."""

    def test_generated_road_intersects_downward_ray(self) -> None:
        """Verify that generated roads can be processed by geometry functions."""
        # Use real road generation
        x_road: NDArray[np.float64]
        y_road: NDArray[np.float64]
        x_road, y_road = generate_road_profile(num_points=100, x_max=80)

        # Verify it works with geometry module
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=10.0)

        assert x is not None, "Should find intersection with generated road"
        assert isinstance(x, (int, float, np.number)), "Should return numeric type"
        assert isinstance(y, (int, float, np.number)), "Should return numeric type"
        assert isinstance(dist, (int, float, np.number)), "Should return numeric type"

    def test_road_data_format_compatible_with_geometry(self) -> None:
        """Verify road.py returns data in format geometry.py expects."""
        x_road: NDArray[np.float64]
        y_road: NDArray[np.float64]
        x_road, y_road = generate_road_profile()

        # Check data types
        assert isinstance(x_road, np.ndarray), "x_road should be numpy array"
        assert isinstance(y_road, np.ndarray), "y_road should be numpy array"

        # Check lengths match
        assert len(x_road) == len(y_road), "Road arrays should have same length"

        # Check data is sorted
        assert np.all(np.diff(x_road) > 0), "x_road should be strictly increasing"

    def test_varying_road_parameters_work_with_geometry(self) -> None:
        """Test that different road generation parameters work with geometry."""
        for num_points in [10, 50, 100, 200]:
            for x_max in [40, 80, 120]:
                x_road, y_road = generate_road_profile(num_points, x_max)
                x, y, dist = find_intersection(x_road, y_road, -10.0)
                # Should not crash, might or might not find intersection
                assert x is None or isinstance(x, (int, float, np.number))

# ❌ BRITTLE: Tests HOW the function works internally
from unittest.mock import patch

def test_find_intersection_uses_tan_for_slope():
    """Test that function uses np.tan to calculate slope"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)

    # Mock np.tan to verify it's called
    with patch('numpy.tan') as mock_tan:
        mock_tan.return_value = 0.176  # Mocked slope value
        find_intersection(x_road, y_road, -10.0)
        assert mock_tan.called  # ❌ Breaks if you change slope calculation!

# ✅ ROBUST: Tests WHAT the code does, not HOW it does it
def test_find_intersection_returns_correct_position_for_downward_angle():
    """Test that intersection position is geometrically correct for downward ray"""
    # Arrange
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)

    # Act
    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 10.0)

    # Assert behavior: intersection should be within road bounds
    assert x is not None, "Should find intersection for downward angle"
    assert 0 <= x <= 20, f"Intersection x should be in road bounds [0, 20], got {x}"
    assert 0 <= y <= 4, f"Intersection y should be in road bounds [0, 4], got {y}"
    assert dist > 0, f"Distance should be positive, got {dist}"

    # No assumptions about HOW it calculated this!
    # Works with tan, atan2, lookup tables, or any other implementation

x, y, dist = find_intersection(x_road, y_road, angle_degrees, camera_x, camera_y)

def find_intersection(x_road, y_road, angle_degrees, camera_x=0, camera_y=1.5):
    """Find intersection using linear search"""
    angle_rad = -np.deg2rad(angle_degrees)

    # Check vertical
    if np.abs(np.cos(angle_rad)) < 1e-10:
        return None, None, None

    slope = np.tan(angle_rad)

    # Linear search through segments
    for i in range(len(x_road) - 1):
        x1, y1 = x_road[i], y_road[i]
        x2, y2 = x_road[i + 1], y_road[i + 1]
        # ... intersection calculation

def find_intersection(x_road, y_road, angle_degrees, camera_x=0, camera_y=1.5):
    """Find intersection using binary search (10x faster!)"""
    angle_rad = -np.deg2rad(angle_degrees)

    # Different vertical check using sine
    if np.abs(np.sin(angle_rad - np.pi/2)) < 1e-10:  # Changed!
        return None, None, None

    # Use atan2 instead of tan (more numerically stable)
    direction = np.array([np.cos(angle_rad), np.sin(angle_rad)])  # Changed!

    # Binary search through segments (faster for large roads)
    left, right = 0, len(x_road) - 1
    # ... binary search logic (completely different!)

def test_find_intersection_uses_tan():
    with patch('numpy.tan') as mock_tan:
        find_intersection(...)
        assert mock_tan.called  # ❌ FAILS! We use atan2 now!