03 Grundlagen des Testens: Boundary Analysis und LLM-Assisted Testing

import sys
import math

# Diese sind NICHT dasselbe!
print(math.inf > sys.float_info.max)  # True - Unendlich ist größer als jeder endliche Wert
print(sys.float_info.max * 2)         # inf - Overflow!
print(1 / math.inf)                   # 0.0 - Kehrwert von Unendlich
print(1 / sys.float_info.max)         # ≈ 5.6e-309 - winzig aber endlich!

import math

# Nutze math.inf (bevorzugt für Lesbarkeit)
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)
    # Kehrwert des größten endlichen → extrem klein
    assert result > 0
    assert result < sys.float_info.min  # Könnte zu subnormal underflowlen

import math

def test_reciprocal_precision_at_boundary():
    # Teste den "nächsten" darstellbaren Wert nach 1.0
    x = math.nextafter(1.0, 2.0)  # Etwas größer als 1.0
    result = reciprocal(x)
    # Sollte etwas kleiner als 1.0 sein
    assert result < 1.0

import numpy as np

# Für float64 (Python float-Äquivalent)
fi = np.finfo(np.float64)
print(fi.max)        # Größter endlicher (≈ 1.8e308)
print(fi.tiny)       # Kleinster positiver normalisierter (≈ 2.2e-308)
print(fi.eps)        # Maschinen-Epsilon (≈ 2.2e-16)

# Nutze mit nextafter
x_next_to_max = np.nextafter(fi.max, np.inf)  # → inf

# Für float32 (falls mit einfacher Präzision gearbeitet wird)
fi32 = np.finfo(np.float32)
print(fi32.max)      # ≈ 3.4e38 (viel kleiner als float64!)

import sys
import math
import pytest

# Konstanten für Lesbarkeit definieren (Best Practices folgend)
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:
    """Umfassende Boundary-Tests für die reciprocal(x) Funktion."""

    # GRUNDLEGENDE BOUNDARIES (nahe Null, typische Werte)

    def test_reciprocal_boundary_near_zero_positive(self):
        """Boundary: Sehr kleine positive Zahl"""
        result = reciprocal(1e-6)  # 0.000001
        assert result == pytest.approx(1e6, rel=1e-9)  # Sollte 1000000 sein

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

    def test_reciprocal_boundary_exactly_zero(self):
        """Boundary: Exakt Null (sollte Exception werfen)"""
        with pytest.raises(ZeroDivisionError):
            reciprocal(0.0)

    def test_reciprocal_boundary_very_large_positive(self):
        """Boundary: Sehr große positive Zahl"""
        result = reciprocal(1e10)
        assert result == pytest.approx(1e-10, rel=1e-9)

    # ENDLICHE BEREICHSGRENZEN (sys.float_info Limits)

    def test_reciprocal_boundary_max_finite_float(self):
        """Boundary: Größter endlicher Float (sys.float_info.max ≈ 1.8e308)

        Testet Overflow-Prävention an der oberen endlichen Grenze.
        Kehrwert des größten endlichen → extrem klein (kann zu subnormal underflowlen).
        """
        result = reciprocal(FMAX)
        assert result > 0, "Kehrwert des max float sollte positiv sein"
        assert result < FMIN_NORM_POS, "Ergebnis underflowt unter den normalisierten Bereich (subnormal)"
        # Ergebnis ist ca. 5.6e-309 (subnormal/denormalisiert)

    def test_reciprocal_boundary_min_normalized_float(self):
        """Boundary: Kleinster positiver normalisierter Float (sys.float_info.min ≈ 2.2e-308)

        Testet Underflow-zu-Overflow-Übergang.
        Kehrwert des min normalisierten → extrem groß (overflowt zu Unendlich).
        """
        result = reciprocal(FMIN_NORM_POS)
        assert result == INF, "Kehrwert des min normalisierten float overflowt zu Unendlich"

    def test_reciprocal_boundary_min_subnormal_float(self):
        """Boundary: Kleinster positiver subnormaler Float (math.ulp(0.0) ≈ 5e-324)

        Testet Handling denormalisierter Zahlen.
        Kehrwert des kleinsten darstellbaren → massiver Overflow zu Unendlich.
        """
        result = reciprocal(FMIN_SUB_POS)
        assert result == INF, "Kehrwert des min subnormal overflowt zu Unendlich"

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

        Testet Präzisionslimit-Verhalten.
        Epsilon ist der kleinste Wert, bei dem 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: Negativster endlicher Float (-sys.float_info.max ≈ -1.8e308)

        Testet untere endliche Grenze (es gibt kein sys.float_info.min_negative).
        """
        result = reciprocal(-FMAX)
        assert result < 0, "Kehrwert des negativsten endlichen sollte negativ sein"
        assert result > -FMIN_NORM_POS, "Ergebnis ist winzig negativ (subnormaler Bereich)"

    # NICHT-ENDLICHE BOUNDARIES (Unendlichkeiten und NaN)

    def test_reciprocal_boundary_positive_infinity(self):
        """Boundary: Positive Unendlichkeit (nicht-endlicher Wert)

        Testet Spezialwert-Handling (nicht Overflow-Prävention).
        1 / inf = 0 (mathematischer Grenzwert)
        """
        result = reciprocal(INF)
        assert result == 0.0, "Kehrwert von positiver Unendlichkeit sollte Null sein"

    def test_reciprocal_boundary_negative_infinity(self):
        """Boundary: Negative Unendlichkeit (nicht-endlicher Wert)

        1 / -inf = -0 (negative Null)
        """
        result = reciprocal(NINF)
        # Python behandelt 0.0 == -0.0 als True (IEEE 754 Verhalten)
        assert result == 0.0 or result == -0.0, "Kehrwert von -inf sollte Null sein"

    def test_reciprocal_boundary_nan(self):
        """Boundary: Not a Number (undefinierter/ungültiger Input)

        NaN propagiert durch Operationen (crasht nicht).
        Wichtig: nan == nan ist immer False! Nutze math.isnan().
        """
        result = reciprocal(NAN)
        assert math.isnan(result), "Kehrwert von NaN sollte NaN sein (propagiert)"

    # HAARSCHARF-BOUNDARIES (mit math.nextafter)

    def test_reciprocal_boundary_next_after_max_toward_inf(self):
        """Boundary: Nächster Float nach max (Richtung Unendlich)

        Nutzt math.nextafter() um den exakten Übergangspunkt zu testen.
        Nächster Float nach FMAX Richtung Unendlich IST Unendlich.
        """
        x_after_max = math.nextafter(FMAX, INF)
        assert x_after_max == INF, "Nächster Float nach max Richtung inf ist Unendlich"
        result = reciprocal(x_after_max)
        assert result == 0.0, "Kehrwert von inf ist 0"

    def test_reciprocal_boundary_next_after_one_toward_two(self):
        """Boundary: Nächster darstellbarer Float nach 1.0

        Testet ULP (Unit in Last Place) Sensitivität.
        1.0 + epsilon ist der nächste darstellbare Wert nach 1.0
        """
        x_just_above_one = math.nextafter(1.0, 2.0)
        result = reciprocal(x_just_above_one)
        # Kehrwert sollte leicht kleiner als 1.0 sein
        assert result < 1.0, f"Erwartet < 1.0, bekam {result}"
        assert result == pytest.approx(1.0, rel=1e-14), "Sollte sehr nahe an 1.0 sein"

    def test_reciprocal_boundary_ulp_sensitivity(self):
        """Boundary: Testing ULP (Unit in Last Place) um einen Wert herum

        Demonstriert Gleitkomma-Granularität.
        """
        x = 1000.0
        ulp_at_x = math.ulp(x)  # Abstand bei 1000.0

        result1 = reciprocal(x)
        result2 = reciprocal(x + ulp_at_x)  # Nächster darstellbarer Wert

        assert result1 != result2, "Benachbarte Floats sollten unterschiedliche Kehrwerte produzieren"
        assert result1 > result2, "Größerer Input → kleinerer Kehrwert"

# ❌ MÜHSAM: 6 fast-identische Tests schreiben
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 weitere ähnliche Tests ...

# ✅ SAUBER: Eine Testfunktion, mehrere 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):
    """Parametrisierter Test für alle extremen Boundaries mit Beschreibungen."""
    result = reciprocal(x)

    if "subnormal" in expected_behavior:
        assert math.isfinite(result), f"{expected_behavior}: Ergebnis sollte endlich sein"
        assert abs(result) < FMIN_NORM_POS, f"{expected_behavior}: sollte im subnormalen Bereich sein"
    elif "overflow to infinity" in expected_behavior:
        assert result == INF, f"{expected_behavior}: sollte zu Unendlich overflowlen"
    elif "exact zero" in expected_behavior:
        assert result == 0.0, f"{expected_behavior}: sollte exakt Null sein"

# Mehrere Äquivalenzklassen mit gleicher Validierung testen
@pytest.mark.parametrize("angle", [-10, -20, -30, -45])
def test_find_intersection_downward_angles_all_succeed(angle):
    """Teste, dass alle Abwärtswinkel Intersection finden"""
    x, y, dist = find_intersection(x_road, y_road, angle)
    assert x is not None
    assert dist > 0

# Boundary-Werte mit erwarteten Ergebnissen testen
@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):
    """Teste reciprocal mit normalen Werten"""
    result = reciprocal(x)
    assert result == pytest.approx(expected, rel=1e-9)

# PARAMETRISIERTER TEST (pytest-Feature für mehrere ähnliche 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):
    """Parametrisierter Test für alle extremen Boundaries mit Beschreibungen."""
    result = reciprocal(x)

    if "subnormal" in expected_behavior:
        assert math.isfinite(result), f"{expected_behavior}: Ergebnis sollte endlich sein"
        assert abs(result) < FMIN_NORM_POS, f"{expected_behavior}: sollte im subnormalen Bereich sein"
    elif "overflow to infinity" in expected_behavior:
        assert result == INF, f"{expected_behavior}: sollte zu Unendlich overflowlen"
    elif "exact zero" in expected_behavior:
        assert result == 0.0, f"{expected_behavior}: sollte exakt Null sein"

# ❌ FALSCH: Nur Unendlichkeit testen
def test_reciprocal_large_values():
    result = reciprocal(float('inf'))
    assert result == 0.0

# Problem: Dies testet nicht endlichen Overflow (sys.float_info.max)!
# Eine Funktion könnte inf korrekt handhaben, aber bei FMAX crashen.

# ✅ KORREKT: Teste SOWOHL endliche ALS AUCH nicht-endliche Boundaries
def test_reciprocal_max_finite():
    result = reciprocal(sys.float_info.max)  # Endlich
    assert result < sys.float_info.min  # Underflow-Verhalten

def test_reciprocal_infinity():
    result = reciprocal(math.inf)  # Nicht-endlich
    assert result == 0.0  # Spezialwert-Handling

def test_reciprocal_sum_boundary_sum_exactly_zero():
    """Boundary: Summe wird exakt zu Null"""
    with pytest.raises(ZeroDivisionError):
        reciprocal_sum(1.0, -0.5, -0.5)

def test_reciprocal_sum_boundary_sum_near_zero_positive():
    """Boundary: Summe ist sehr klein positiv"""
    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: Alle Parameter Null"""
    with pytest.raises(ZeroDivisionError):
        reciprocal_sum(0.0, 0.0, 0.0)

def test_reciprocal_sum_boundary_two_zeros():
    """Boundary: Zwei Parameter Null, einer nicht-Null"""
    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: Leeres Array (Länge = 0)"""
    with pytest.raises(ValueError):
        array_sum(np.array([]))

def test_array_sum_boundary_single_element():
    """Boundary: Einzelnes Element (Länge = 1)"""
    result = array_sum(np.array([5.0]))
    assert result == 5.0

def test_array_sum_boundary_two_elements():
    """Boundary: Zwei Elemente (minimal nicht-trivial)"""
    result = array_sum(np.array([3.0, 4.0]))
    assert result == 7.0

def test_array_sum_boundary_all_zeros():
    """Boundary: Alle Elemente sind Null"""
    result = array_sum(np.array([0.0, 0.0, 0.0]))
    assert result == 0.0

def test_array_sum_boundary_alternating_near_zero():
    """Boundary: Werte nahe Null mit alternierenden Vorzeichen"""
    result = array_sum(np.array([1e-10, -1e-10, 1e-10]))
    assert abs(result - 1e-10) < 1e-15  # Summe sollte nahe 1e-10 sein

# tests/test_geometry.py (Unit-Tests - SCHNELL)
def test_find_intersection_basic():
    """Unit-Test: Kleines repräsentatives Array"""
    x_road = np.array([0, 10, 20])  # Nur 3 Punkte
    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 - LANGSAM)
@pytest.mark.slow  # Markiere als langsam, damit wir während Entwicklung skippen können
def test_find_intersection_large_road():
    """Performance-Test: Realistischer großer Road-Datensatz"""
    x_road = np.linspace(0, 1000, 10_000)  # 10.000 Punkte
    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"Zu langsam: {elapsed:.3f}s für 10k Punkte"

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 sollte nie bei gültigen Float-Arrays crashen

    Hypothesis generiert automatisch hunderte Testfälle
    mit unterschiedlichen Array-Größen und -Werten.
    """
    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))

# ✅ GUT: Repräsentative Größen für Unit-Tests
def test_find_intersection_typical_road():
    """Test mit typischer Road-Größe (~100 Punkte)"""
    x_road = np.linspace(0, 80, 100)  # Realistisch: 100 Punkte über 80 Meter
    y_road = generate_road_profile(num_points=100)

    x, y, dist = find_intersection(x_road, y_road, -10.0)
    assert x is not None  # Schneller Test, läuft in ~1ms

# ❌ SCHLECHT: Unnötig groß für Unit-Test
def test_find_intersection_huge_road():
    """Dies gehört in Performance-Tests, nicht 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  # Langsamer Test, läuft in ~500ms

class TestFindIntersectionBoundaries:
    """Boundary-Value-Tests für find_intersection()"""

    # ARRAY-LÄNGEN-BOUNDARIES

    def test_boundary_empty_arrays(self):
        """Boundary: Leere 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: Einzelner Punkt (len = 1)"""
        x, y, dist = find_intersection(np.array([5.0]), np.array([2.0]), -10.0)
        assert x is None  # Kann kein Segment bilden

    def test_boundary_two_points_minimum_valid(self):
        """Boundary: Zwei Punkte (len = 2, minimal gültig)"""
        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  # Sollte funktionieren

    # WINKEL-BOUNDARIES

    def test_boundary_angle_exactly_negative_90(self):
        """Boundary: Winkel exakt -90° (vertikal abwärts)"""
        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)
        # Implementierung gibt None für vertikal zurück - verifiziere dass das beabsichtigt ist
        assert x is None

    def test_boundary_angle_near_negative_90(self):
        """Boundary: Winkel nahe -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)
        # Fast vertikal - sollte trotzdem Intersektion finden wenn eine existiert

    def test_boundary_angle_exactly_zero(self):
        """Boundary: Winkel exakt 0° (horizontal)"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([2.0, 2.0, 2.0])  # Flache Road bei 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  # Horizontaler Strahl sollte flache Road treffen

    def test_boundary_angle_near_zero(self):
        """Boundary: Winkel nahe 0° (0.1° - fast 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)
        # Sehr flacher Winkel

    def test_boundary_angle_exactly_90(self):
        """Boundary: Winkel exakt 90° (vertikal aufwärts)"""
        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  # Implementierung gibt None für vertikal zurück

    # KAMERA-POSITIONS-BOUNDARIES

    def test_boundary_camera_at_road_start(self):
        """Boundary: Kamera-x-Position am 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: Kamera-x-Position am Road-Ende"""
        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)
        # Kamera am Ende, schaut nach unten - könnte schneiden oder nicht

    def test_boundary_camera_at_road_level(self):
        """Boundary: Kamera-y-Position auf Road-Niveau"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([2.0, 2.0, 2.0])  # Flach bei y=2
        x, y, dist = find_intersection(x_road, y_road, 0.0, camera_x=5.0, camera_y=2.0)
        # Kamera AUF der Road, horizontaler Strahl - Tangenten-Fall

    def test_boundary_camera_at_minimum_y(self):
        """Boundary: Kamera am tiefsten Punkt der Road"""
        x_road = np.array([0, 10, 20, 30])
        y_road = np.array([5, 2, 3, 6])  # min bei x=10, y=2
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=15.0, camera_y=2.0)
        # Kamera auf gleicher Höhe wie tiefster Road-Punkt

    # INTERSEKTIONS-POSITIONS-BOUNDARIES

    def test_boundary_intersection_at_first_point(self):
        """Boundary: Strahl schneidet am ersten Road-Punkt"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([5, 3, 1])
        # Positioniere Kamera so dass Strahl exakt (0, 5) trifft
        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  # Sollte nahe am ersten Punkt sein

    def test_boundary_intersection_at_last_point(self):
        """Boundary: Strahl schneidet am letzten Road-Punkt"""
        x_road = np.array([0, 10, 20])
        y_road = np.array([0, 2, 4])
        # Positioniere so dass Strahl letzten Punkt trifft
        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  # Sollte nahe am letzten Punkt sein

    def test_boundary_intersection_at_segment_boundary(self):
        """Boundary: Strahl schneidet exakt wo zwei Segmente sich treffen"""
        x_road = np.array([0, 10, 20, 30])
        y_road = np.array([0, 5, 5, 10])
        # Strahl zielt auf exakt (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:
            # Könnte als Ende des ersten oder Start des zweiten Segments gemeldet werden
            assert 9.0 <= x <= 11.0

import sys
import math

# KONSTANTEN (einmal definieren, überall verwenden)
FMAX = sys.float_info.max              # Größter endlicher (≈1.8e308)
FMIN_NORM = sys.float_info.min         # Kleinster normalisierter (≈2.2e-308)
FMIN_SUB = math.ulp(0.0)               # Kleinster subnormaler (≈5e-324)
EPSILON = sys.float_info.epsilon       # Maschinen-Epsilon (≈2.2e-16)
INF = math.inf                         # Positive Unendlichkeit
NINF = -math.inf                       # Negative Unendlichkeit
NAN = math.nan                         # Not a number

# TEST-CHECKLISTE FÜR FLOAT-FUNKTIONEN

# ✅ Endliche Boundaries (teste Overflow/Underflow)
test_function(FMAX)           # Größter endlicher
test_function(-FMAX)          # Negativster endlicher
test_function(FMIN_NORM)      # Kleinster normalisierter positiver
test_function(FMIN_SUB)       # Kleinster subnormaler positiver

# ✅ Nicht-endliche Werte (teste Spezialwert-Handling)
test_function(INF)            # Positive Unendlichkeit
test_function(NINF)           # Negative Unendlichkeit
test_function(NAN)            # Not a Number

# ✅ Präzisions-Boundaries
test_function(EPSILON)        # Maschinen-Epsilon
test_function(1.0 + EPSILON)  # Nächster nach 1.0

# ✅ Haarscharf-Übergänge (mit math.nextafter)
math.nextafter(FMAX, INF)     # → inf (Overflow-Übergang)
math.nextafter(1.0, 2.0)      # Nächster darstellbarer nach 1.0
math.nextafter(1.0, 0.0)      # Vorheriger darstellbarer vor 1.0

# ✅ Ergebnisse prüfen
math.isfinite(x)              # True wenn nicht inf/nan
math.isinf(x)                 # True wenn +inf oder -inf
math.isnan(x)                 # True wenn nan (nicht x == nan verwenden!)
math.ulp(x)                   # Abstand bei x (Präzision)

def calculate_grade(score: int) -> str:
    """
    Berechne Buchstabennote basierend auf Punktzahl.

    Args:
        score: Ganzzahl zwischen 0 und 100

    Returns:
        Buchstabennote (A, B, C, D, F)

    Raises:
        ValueError: Wenn Punktzahl nicht im gültigen Bereich liegt
    """
    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"  # Knapp unter A-Schwelle
    assert calculate_grade(90) == "A"  # An A-Schwelle

def test_grade_boundary_B_C_threshold():
    """Boundary: score = 79 (C) vs 80 (B)"""
    assert calculate_grade(79) == "C"  # Knapp unter B-Schwelle
    assert calculate_grade(80) == "B"  # An B-Schwelle

def test_grade_boundary_C_D_threshold():
    """Boundary: score = 69 (D) vs 70 (C)"""
    assert calculate_grade(69) == "D"  # Knapp unter C-Schwelle
    assert calculate_grade(70) == "C"  # An C-Schwelle

def test_grade_boundary_D_F_threshold():
    """Boundary: score = 59 (F) vs 60 (D)"""
    assert calculate_grade(59) == "F"  # Knapp unter D-Schwelle
    assert calculate_grade(60) == "D"  # An D-Schwelle

def test_grade_boundary_valid_range_lower():
    """Boundary: score = 0 (gültig) vs -1 (ungültig)"""
    assert calculate_grade(0) == "F"   # Minimale gültige Punktzahl
    with pytest.raises(ValueError):
        calculate_grade(-1)             # Knapp unter gültigem Bereich

def test_grade_boundary_valid_range_upper():
    """Boundary: score = 100 (gültig) vs 101 (ungültig)"""
    assert calculate_grade(100) == "A"  # Maximale gültige Punktzahl
    with pytest.raises(ValueError):
        calculate_grade(101)             # Knapp über gültigem Bereich

def calculate_shipping_cost(weight: float, distance: float, express: bool = False) -> float:
    """
    Berechne Versandkosten basierend auf Gewicht und Entfernung.

    Args:
        weight: Gewicht in kg (0.1 bis 50)
        distance: Entfernung in km (1 bis 5000)
        express: Ob Expressversand gewünscht ist

    Returns:
        float: Versandkosten in EUR

    Raises:
        ValueError: Wenn Gewicht oder Entfernung außerhalb des Bereichs liegt
    """
    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")

    # Basiskosten-Berechnung
    if weight <= 5:
        base_cost = 5.0
    elif weight <= 20:
        base_cost = 10.0
    else:
        base_cost = 20.0

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

    cost = base_cost * distance_multiplier

    # Expressversand fügt 50% hinzu
    if express:
        cost *= 1.5

    return round(cost, 2)

import pytest

# ===== Gewichts-Boundaries (Entfernung und Express fixiert) =====

def test_shipping_weight_boundary_minimum():
    """Boundary: weight = 0.1 (gültig) vs 0.09 (ungültig)"""
    assert calculate_shipping_cost(0.1, 100, False) == 5.0  # Gültig
    with pytest.raises(ValueError, match="Weight must be between"):
        calculate_shipping_cost(0.09, 100, False)  # Ungültig

def test_shipping_weight_boundary_light_medium():
    """Boundary: weight = 5.0 (leicht) vs 5.1 (mittel)"""
    cost_light = calculate_shipping_cost(5.0, 100, False)
    cost_medium = calculate_shipping_cost(5.1, 100, False)
    assert cost_light == 5.0   # Leicht: base=5.0, dist_mult=1.0 → 5.0
    assert cost_medium == 10.0  # Mittel: base=10.0, dist_mult=1.0 → 10.0

def test_shipping_weight_boundary_medium_heavy():
    """Boundary: weight = 20.0 (mittel) vs 20.1 (schwer)"""
    cost_medium = calculate_shipping_cost(20.0, 100, False)
    cost_heavy = calculate_shipping_cost(20.1, 100, False)
    assert cost_medium == 10.0  # Mittel: base=10.0, dist_mult=1.0 → 10.0
    assert cost_heavy == 20.0   # Schwer: base=20.0, dist_mult=1.0 → 20.0

def test_shipping_weight_boundary_maximum():
    """Boundary: weight = 50 (gültig) vs 50.1 (ungültig)"""
    assert calculate_shipping_cost(50, 100, False) == 20.0  # Gültig
    with pytest.raises(ValueError, match="Weight must be between"):
        calculate_shipping_cost(50.1, 100, False)  # Ungültig

# ===== Entfernungs-Boundaries (Gewicht und Express fixiert) =====

def test_shipping_distance_boundary_minimum():
    """Boundary: distance = 1 (gültig) vs 0.9 (ungültig)"""
    assert calculate_shipping_cost(5.0, 1, False) == 5.0  # Gültig
    with pytest.raises(ValueError, match="Distance must be between"):
        calculate_shipping_cost(5.0, 0.9, False)  # Ungültig

def test_shipping_distance_boundary_local_regional():
    """Boundary: distance = 100 (lokal) 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     # Lokal: 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 (Langstrecke)"""
    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     # Lang: base=5.0, dist_mult=2.0 → 10.0

def test_shipping_distance_boundary_maximum():
    """Boundary: distance = 5000 (gültig) vs 5001 (ungültig)"""
    assert calculate_shipping_cost(5.0, 5000, False) == 10.0  # Gültig
    with pytest.raises(ValueError, match="Distance must be between"):
        calculate_shipping_cost(5.0, 5001, False)  # Ungültig

# ===== Express-Flag (Gewicht und Entfernung fixiert) =====

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: "Schreibe pytest Unit-Tests für find_intersection() die abdecken:
# - Äquivalenzklassen: Abwärtswinkel, horizontal, Aufwärtswinkel, vertikal
# - Boundary-Cases: leere Arrays, einzelner Punkt, angle=90
# - Nutze AAA-Pattern (Arrange-Act-Assert)
# - Inkludiere korrekte Type-Hints passend zum tatsächlichen Repository-Code"

def test_find_intersection_downward_angle() -> None:
    """Teste find_intersection mit normalem Abwärtswinkel."""
    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:
    """Teste find_intersection mit horizontalem Winkel."""
    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)  # Flache 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:
    """Teste find_intersection mit vertikalem Winkel (90 Grad)."""
    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  # Aktuelle Implementierung gibt None für vertikal zurück

def test_find_intersection_empty_road() -> None:
    """Teste find_intersection mit leeren 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 hat nicht getestet: Was ist wenn Kamera UNTER der Road ist?
# Füge diesen Test hinzu:
def test_find_intersection_camera_below_road() -> None:
    """Test wenn Kamera unter Road-Niveau ist."""
    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)  # Flache Road bei y=5
    x, y, dist = find_intersection(x_road, y_road, -10.0, 0.0, 0.0)  # Kamera bei y=0
    # Sollte trotzdem Intersektion finden (Strahl geht runter, kreuzt Road darüber)
    assert x is not None

# LLM schrieb:
assert x is not None  # Zu schwach!

# Bessere Assertion:
assert 0 <= x <= 30, f"Erwartete x in [0, 30], bekam {x}"
assert y >= 0, f"Erwartete y positiv, bekam {y}"

# LLM schrieb:
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)  # Flache Road bei y=0
x, y, dist = find_intersection(x_road, y_road, 0.0, 0.0, 1.0)  # Kamera bei y=1

# Problem: Horizontaler Strahl von y=1 wird Road bei y=0 nicht schneiden!
# Fix: Entweder Kamera anheben oder Road neigen
x_road = np.array([0, 10, 20], dtype=np.float64)
y_road = np.array([0, 1, 2], dtype=np.float64)  # Geneigte Road

# Sie zum LLM: "Fügen Sie Tests für Aufwärtswinkel hinzu wo Strahl nicht schneiden könnte"
# LLM generiert:
def test_find_intersection_upward_angle_no_intersection() -> None:
    """Teste dass Aufwärtswinkel mit Road darunter None zurückgibt."""
    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)  # Strahl geht hoch
    # Je nach Implementierung, könnte nicht schneiden
    # Wenn None korrektes Verhalten ist:
    assert x is None

def find_intersection(x_road, y_road, ...):
    # Bug: Prüft nicht ob Arrays leer sind bevor zugegriffen wird!
    for i in range(len(x_road) - 1):  # Crasht wenn len(x_road) = 0
        x1, y1 = x_road[i], y_road[i]
        ...

def find_intersection(x_road, y_road, ...):
    # Füge Validierung hinzu
    if len(x_road) == 0 or len(y_road) == 0:
        return None, None, None

    # ... Rest der Funktion

# LLM könnte generieren:
def test_calculate_distance():
    dist = calculate_distance(0, 0, 3, 4)
    assert dist > 0  # Zu schwach! Prüft nur ob positiv

# Mensch kennt Pythagoras:
def test_calculate_distance():
    dist = calculate_distance(0, 0, 3, 4)
    assert abs(dist - 5.0) < 0.01, f"Erwartete 5.0, bekam {dist}"  # 3-4-5 Dreieck!

# ❌ LLM könnte das generieren:
def test_find_intersection_multiple_angles():
    """Test intersection für verschiedene Winkel"""
    angles = [-10, -20, -30, -45]
    for angle in angles:  # ❌ Schleife im Test!
        x, y, dist = find_intersection(x_road, y_road, angle)
        if x is not None:  # ❌ Conditional im Test!
            assert dist > 0
        else:
            assert dist is None  # ❌ Komplexe Logik!

# ✅ Mensch refactoriert zu einfachen, klaren Tests:
def test_find_intersection_returns_positive_distance_for_minus_10_degrees():
    """Test -10° Winkel gibt positive Distanz zurück"""
    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  # Keine Conditionals, keine Schleifen!

def test_find_intersection_returns_positive_distance_for_minus_20_degrees():
    """Test -20° Winkel gibt positive Distanz zurück"""
    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

# Oder nutze pytest parametrize (sauberer für mehrere ähnliche Tests):
@pytest.mark.parametrize("angle", [-10, -20, -30, -45])
def test_find_intersection_returns_positive_distance_for_downward_angles(angle):
    """Teste dass alle Abwärtswinkel positive Distanz zurückgeben"""
    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  # Einfache Assertion, pytest führt diesen Test 4-mal mit verschiedenen Winkeln aus

# ❌ LLM-generierter Test mit exzessivem Mocking
from unittest.mock import patch

def test_find_intersection_calls_tan():
    """Teste dass find_intersection np.tan aufruft"""
    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  # Gemockte Steigung
        x, y, dist = find_intersection(x_road, y_road, -10.0)
        mock_tan.assert_called_once()  # ❌ Testet WIE, nicht WAS

# ✅ Teste das ERGEBNIS (State), nicht die METHODENAUFRUFE (Interactions)
def test_find_intersection_returns_correct_intersection():
    """Teste dass Intersektions-Position geometrisch korrekt ist"""
    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, "Sollte Intersektion für Abwärtswinkel finden"
    assert 0 <= x <= 20, f"Intersektion x sollte innerhalb Road-Grenzen sein, bekam {x}"
    assert y >= 0, f"Intersektion y sollte über Boden sein, bekam {y}"
    assert dist > 0, f"Distanz sollte positiv sein, bekam {dist}"

    # Keine Annahmen über welche numpy-Funktionen aufgerufen wurden!

# ✅ Gute Nutzung von Mocking: Externe API
from unittest.mock import patch, Mock

def test_fetch_weather_data_returns_temperature():
    """Teste Wetter-Abruf ohne echte API zu treffen"""
    # Mocke den externen HTTP-Request (langsam, braucht Netzwerk)
    with patch('requests.get') as mock_get:
        mock_response = Mock()
        mock_response.json.return_value = {'temp': 22.5}
        mock_get.return_value = mock_response

        # Jetzt testen Sie Ihre Funktion
        temp = fetch_weather_data('Berlin')

        # Assert ERGEBNIS (nicht Implementierung)
        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 für find_intersection() Funktion."""

    def test_normal_downward_angle(self) -> None:
        """Äquivalenzklasse: Normaler Abwärtswinkel (-90° < Winkel < 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:
        """Äquivalenzklasse: Horizontaler Strahl (Winkel = 0°)"""
        # Ihr Test hier (lassen Sie LLM generieren, dann reviewen)
        pass

    def test_vertical_angle_boundary(self) -> None:
        """Boundary-Fall: Vertikaler Winkel (90°)"""
        pass

    def test_empty_road_arrays(self) -> None:
        """Boundary-Fall: Leere Arrays"""
        pass

    def test_single_point_road(self) -> None:
        """Boundary-Fall: Straße mit nur einem Punkt"""
        pass

class TestCalculateRayLine:
    """Test-Suite für calculate_ray_line() Funktion."""

    def test_normal_angle(self) -> None:
        """Test mit normalem Winkel"""
        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  # Startet bei Kamera
        assert y_ray[0] == 2.0

    def test_vertical_angle(self) -> None:
        """Boundary: Vertikaler Winkel (90°)"""
        x_ray, y_ray = calculate_ray_line(90.0)
        # Sollte vertikale Linie handhaben
        assert x_ray[0] == x_ray[1]  # Vertikal bedeutet gleiches x

    def test_zero_angle(self) -> None:
        """Boundary: Horizontaler Winkel (0°)"""
        x_ray, y_ray = calculate_ray_line(0.0, camera_y=2.0)
        # Horizontale Linie bei y=2.0
        assert y_ray[0] == y_ray[1] == 2.0

# Unit-Test: Teste NUR 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

# Integrationstest: Teste geometry + road zusammen
def test_road_generation_with_intersection() -> None:
    """Teste dass Road-Generierung Daten produziert die Geometry verarbeiten kann."""
    from road_profile_viewer.road import generate_road_profile
    from road_profile_viewer.geometry import find_intersection

    # Generiere Road mittels 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)

    # Nutze geometry.py um Schnittpunkt zu finden
    x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=2.0)

    # Verifiziere dass Integration funktioniert
    assert x is not None, "Generierte Road sollte Kamera-Strahl schneiden"
    assert 0 <= x <= 80, "Schnittpunkt sollte innerhalb Road-Grenzen sein"
    assert y >= 0, "Schnittpunkt sollte über Boden sein"

# 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 zwischen road und geometry Modulen."""

    def test_generated_road_intersects_downward_ray(self) -> None:
        """Verifiziere dass generierte Roads von Geometry-Funktionen verarbeitet werden können."""
        # Nutze echte Road-Generierung
        x_road: NDArray[np.float64]
        y_road: NDArray[np.float64]
        x_road, y_road = generate_road_profile(num_points=100, x_max=80)

        # Verifiziere dass es mit Geometry-Modul funktioniert
        x, y, dist = find_intersection(x_road, y_road, -10.0, camera_x=0.0, camera_y=10.0)

        assert x is not None, "Sollte Schnittpunkt mit generierter Road finden"
        assert isinstance(x, (int, float, np.number)), "Sollte numerischen Typ returnen"
        assert isinstance(y, (int, float, np.number)), "Sollte numerischen Typ returnen"
        assert isinstance(dist, (int, float, np.number)), "Sollte numerischen Typ returnen"

    def test_road_data_format_compatible_with_geometry(self) -> None:
        """Verifiziere dass road.py Daten im Format returned das geometry.py erwartet."""
        x_road: NDArray[np.float64]
        y_road: NDArray[np.float64]
        x_road, y_road = generate_road_profile()

        # Prüfe Datentypen
        assert isinstance(x_road, np.ndarray), "x_road sollte numpy array sein"
        assert isinstance(y_road, np.ndarray), "y_road sollte numpy array sein"

        # Prüfe dass Längen matchen
        assert len(x_road) == len(y_road), "Road arrays sollten gleiche Länge haben"

        # Prüfe dass Daten sortiert sind
        assert np.all(np.diff(x_road) > 0), "x_road sollte strikt aufsteigend sein"

    def test_varying_road_parameters_work_with_geometry(self) -> None:
        """Teste dass unterschiedliche Road-Generierungs-Parameter mit Geometry funktionieren."""
        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)
                # Sollte nicht crashen, findet möglicherweise Schnittpunkt oder nicht
                assert x is None or isinstance(x, (int, float, np.number))

# ❌ BRÜCHIG: Testet WIE die Funktion intern arbeitet
from unittest.mock import patch

def test_find_intersection_uses_tan_for_slope():
    """Teste dass Funktion np.tan nutzt um Steigung zu berechnen"""
    x_road = np.array([0, 10, 20], dtype=np.float64)
    y_road = np.array([0, 2, 4], dtype=np.float64)

    # Mocke np.tan um zu verifizieren dass es aufgerufen wird
    with patch('numpy.tan') as mock_tan:
        mock_tan.return_value = 0.176  # Gemockter Steigungs-Wert
        find_intersection(x_road, y_road, -10.0)
        assert mock_tan.called  # ❌ Bricht wenn Sie Steigungs-Berechnung ändern!

# ✅ ROBUST: Testet WAS der Code tut, nicht WIE er es tut
def test_find_intersection_returns_correct_position_for_downward_angle():
    """Teste dass Schnittpunkt-Position geometrisch korrekt ist für Abwärts-Strahl"""
    # 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: Schnittpunkt sollte innerhalb Road-Grenzen sein
    assert x is not None, "Sollte Schnittpunkt für Abwärtswinkel finden"
    assert 0 <= x <= 20, f"Schnittpunkt x sollte in Road-Grenzen [0, 20] sein, bekam {x}"
    assert 0 <= y <= 4, f"Schnittpunkt y sollte in Road-Grenzen [0, 4] sein, bekam {y}"
    assert dist > 0, f"Distanz sollte positiv sein, bekam {dist}"

    # Keine Annahmen über WIE es das berechnet hat!
    # Funktioniert mit tan, atan2, Lookup-Tables, oder jeder anderen Implementierung

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):
    """Finde Schnittpunkt mittels linearer Suche"""
    angle_rad = -np.deg2rad(angle_degrees)

    # Prüfe vertikal
    if np.abs(np.cos(angle_rad)) < 1e-10:
        return None, None, None

    slope = np.tan(angle_rad)

    # Lineare Suche durch Segmente
    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]
        # ... Schnittpunkt-Berechnung

def find_intersection(x_road, y_road, angle_degrees, camera_x=0, camera_y=1.5):
    """Finde Schnittpunkt mittels binärer Suche (10x schneller!)"""
    angle_rad = -np.deg2rad(angle_degrees)

    # Andere Vertikal-Prüfung mittels Sinus
    if np.abs(np.sin(angle_rad - np.pi/2)) < 1e-10:  # Geändert!
        return None, None, None

    # Nutze atan2 statt tan (numerisch stabiler)
    direction = np.array([np.cos(angle_rad), np.sin(angle_rad)])  # Geändert!

    # Binäre Suche durch Segmente (schneller für große Roads)
    left, right = 0, len(x_road) - 1
    # ... binäre Such-Logik (komplett anders!)

def test_find_intersection_uses_tan():
    with patch('numpy.tan') as mock_tan:
        find_intersection(...)
        assert mock_tan.called  # ❌ SCHLÄGT FEHL! Wir nutzen atan2 jetzt!