239 lines
8.5 KiB
Python
239 lines
8.5 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
Unit-Tests für Gefaellestrecke (Refactored)
|
|
"""
|
|
import unittest
|
|
import math
|
|
|
|
from .Gefaellestrecke import (
|
|
Gefaellestrecke,
|
|
ROTATION_MAP,
|
|
_bestimme_position,
|
|
_bestimme_gefaelle,
|
|
_tausche_drehungen_und_hoehe,
|
|
_bestimme_tefkurve,
|
|
_ist_umlenk_position,
|
|
_pruefe_motor_umlenk_an_kurve,
|
|
)
|
|
|
|
|
|
class TestGefaellestreckeModell(unittest.TestCase):
|
|
"""Tests für das Gefaellestrecke Pydantic-Modell."""
|
|
|
|
def test_from_merkmale(self):
|
|
merkmale = {
|
|
"Höhe unten": "1.5",
|
|
"Höhe oben": "2.0",
|
|
"Länge in Meter": "5.0",
|
|
"Drehung": "-90",
|
|
"Anzahl der Scanner": "2",
|
|
"Anzahl der Separatoren": "1",
|
|
}
|
|
obj = Gefaellestrecke.from_merkmale("TEST-001", 100.0, 200.0, merkmale)
|
|
self.assertEqual(obj.teileid, "TEST-001")
|
|
self.assertEqual(obj.h0, 1500.0)
|
|
self.assertEqual(obj.h1, 2000.0)
|
|
self.assertEqual(obj.laenge, 5000.0)
|
|
self.assertEqual(obj.drehung, -90.0)
|
|
self.assertEqual(obj.anzahl_scanner, 2)
|
|
self.assertEqual(obj.anzahl_separatoren, 1)
|
|
|
|
def test_hight_zwischen(self):
|
|
obj = Gefaellestrecke(teileid="T", x=0, y=0, laenge=1000, h0=1000, h1=3000)
|
|
self.assertEqual(obj.hight_zwischen, 2000.0)
|
|
|
|
|
|
class TestBestimmePosition(unittest.TestCase):
|
|
"""Tests für _bestimme_position Hilfsfunktion."""
|
|
|
|
def test_vertikal_links(self):
|
|
# x0 < x1 → "_links"
|
|
result = _bestimme_position("Vertikal", 100, 200, 0, 0, "higher")
|
|
self.assertEqual(result, "higher_links")
|
|
|
|
def test_vertikal_rechts(self):
|
|
# x0 > x1 → "_rechts"
|
|
result = _bestimme_position("Vertikal", 300, 200, 0, 0, "lower")
|
|
self.assertEqual(result, "lower_rechts")
|
|
|
|
def test_horizontal_higher(self):
|
|
# y0 > y1 → "_higher"
|
|
result = _bestimme_position("Horizontal", 0, 0, 500, 100, "higher")
|
|
self.assertEqual(result, "higher_higher")
|
|
|
|
def test_horizontal_lower(self):
|
|
# y0 < y1 → "_lower"
|
|
result = _bestimme_position("Horizontal", 0, 0, 50, 500, "lower")
|
|
self.assertEqual(result, "lower_lower")
|
|
|
|
|
|
class TestBestimmeGefaelle(unittest.TestCase):
|
|
"""Tests für _bestimme_gefaelle Hilfsfunktion."""
|
|
|
|
def test_vertikal_links(self):
|
|
self.assertEqual(_bestimme_gefaelle("Vertikal", "lower_rechts"), "links")
|
|
self.assertEqual(_bestimme_gefaelle("Vertikal", "higher_links"), "links")
|
|
|
|
def test_vertikal_rechts(self):
|
|
self.assertEqual(_bestimme_gefaelle("Vertikal", "higher_rechts"), "rechts")
|
|
self.assertEqual(_bestimme_gefaelle("Vertikal", "lower_links"), "rechts")
|
|
|
|
def test_horizontal_oben(self):
|
|
self.assertEqual(_bestimme_gefaelle("Horizontal", "lower_lower"), "oben")
|
|
self.assertEqual(_bestimme_gefaelle("Horizontal", "higher_higher"), "oben")
|
|
|
|
def test_horizontal_unten(self):
|
|
self.assertEqual(_bestimme_gefaelle("Horizontal", "higher_lower"), "unten")
|
|
self.assertEqual(_bestimme_gefaelle("Horizontal", "lower_higher"), "unten")
|
|
|
|
|
|
class TestTauscheDrehungen(unittest.TestCase):
|
|
"""Tests für _tausche_drehungen_und_hoehe."""
|
|
|
|
def test_tausch_drehungen(self):
|
|
d0, d1, h = _tausche_drehungen_und_hoehe(10, 20, "higher")
|
|
self.assertEqual(d0, 20)
|
|
self.assertEqual(d1, 10)
|
|
self.assertEqual(h, "lower")
|
|
|
|
def test_tausch_invert_hoehe(self):
|
|
_, _, h = _tausche_drehungen_und_hoehe(0, 0, "lower")
|
|
self.assertEqual(h, "higher")
|
|
|
|
|
|
class TestBestimmeeTefkurve(unittest.TestCase):
|
|
"""Tests für _bestimme_tefkurve."""
|
|
|
|
def test_links_aussen_ist_rechts(self):
|
|
self.assertEqual(_bestimme_tefkurve("links", "außen"), "rechts")
|
|
|
|
def test_rechts_innen_ist_rechts(self):
|
|
self.assertEqual(_bestimme_tefkurve("rechts", "innen"), "rechts")
|
|
|
|
def test_links_innen_ist_links(self):
|
|
self.assertEqual(_bestimme_tefkurve("links", "innen"), "links")
|
|
|
|
def test_rechts_aussen_ist_links(self):
|
|
self.assertEqual(_bestimme_tefkurve("rechts", "außen"), "links")
|
|
|
|
|
|
class TestIstUmlenkPosition(unittest.TestCase):
|
|
"""Tests für _ist_umlenk_position."""
|
|
|
|
def test_rotation_minus90_x_kleiner(self):
|
|
# rotation == -90 und x < x_angetrieben → True (Umlenk)
|
|
self.assertTrue(_ist_umlenk_position(-90.0, 50, 100, 200, 100))
|
|
|
|
def test_rotation_minus90_x_groesser(self):
|
|
# rotation == -90 und x >= x_angetrieben → False (Motor)
|
|
self.assertFalse(_ist_umlenk_position(-90.0, 300, 100, 200, 100))
|
|
|
|
def test_rotation_0_wird_minus360(self):
|
|
# rotation == 0 → rotation_zwischen = -360
|
|
# -360 <= -360 < -270 und y > y_angetrieben → True
|
|
self.assertTrue(_ist_umlenk_position(0.0, 100, 500, 100, 100))
|
|
|
|
|
|
class TestPruefeMotorUmlenkAnKurve(unittest.TestCase):
|
|
"""Tests für _pruefe_motor_umlenk_an_kurve."""
|
|
|
|
def test_upper_hoeher_motor_passend(self):
|
|
# upper > lower, vario_hoehe_0 == upper → Motor
|
|
hat_motor, hat_umlenk, ist_gerade = _pruefe_motor_umlenk_an_kurve(
|
|
2000, 1000, 2000, 1500, 0, 0, 0, 0, 0
|
|
)
|
|
self.assertTrue(hat_motor)
|
|
self.assertFalse(hat_umlenk)
|
|
self.assertFalse(ist_gerade)
|
|
|
|
def test_upper_hoeher_umlenk(self):
|
|
# upper > lower, keine Höhe passt → Umlenk
|
|
hat_motor, hat_umlenk, ist_gerade = _pruefe_motor_umlenk_an_kurve(
|
|
2000, 1000, 1500, 1200, 0, 0, 0, 0, 0
|
|
)
|
|
self.assertFalse(hat_motor)
|
|
self.assertTrue(hat_umlenk)
|
|
self.assertFalse(ist_gerade)
|
|
|
|
def test_lower_hoeher_motor(self):
|
|
# upper < lower, vario_hoehe_1 == lower → Motor
|
|
hat_motor, hat_umlenk, ist_gerade = _pruefe_motor_umlenk_an_kurve(
|
|
1000, 2000, 1500, 2000, 0, 0, 0, 0, 0
|
|
)
|
|
self.assertTrue(hat_motor)
|
|
self.assertFalse(hat_umlenk)
|
|
|
|
def test_gleiche_hoehe_umlenk_position(self):
|
|
# gleiche Höhe, Umlenkposition → Umlenk gerade
|
|
hat_motor, hat_umlenk, ist_gerade = _pruefe_motor_umlenk_an_kurve(
|
|
1000, 1000, 800, 900, -90.0, 50, 100, 200, 100
|
|
)
|
|
self.assertFalse(hat_motor)
|
|
self.assertTrue(hat_umlenk)
|
|
self.assertTrue(ist_gerade)
|
|
|
|
def test_gleiche_hoehe_motor_position(self):
|
|
# gleiche Höhe, keine Umlenkposition → Motor gerade
|
|
hat_motor, hat_umlenk, ist_gerade = _pruefe_motor_umlenk_an_kurve(
|
|
1000, 1000, 800, 900, -90.0, 300, 100, 200, 100
|
|
)
|
|
self.assertTrue(hat_motor)
|
|
self.assertFalse(hat_umlenk)
|
|
self.assertTrue(ist_gerade)
|
|
|
|
|
|
class TestRotationMap(unittest.TestCase):
|
|
"""Tests für ROTATION_MAP Konstante."""
|
|
|
|
def test_alle_richtungen(self):
|
|
self.assertEqual(ROTATION_MAP["oben"], 0)
|
|
self.assertEqual(ROTATION_MAP["unten"], 180)
|
|
self.assertEqual(ROTATION_MAP["links"], 90)
|
|
self.assertEqual(ROTATION_MAP["rechts"], 270)
|
|
|
|
|
|
class TestRotationMitZweiVerbunden(unittest.TestCase):
|
|
"""Tests für rotation_mit_zwei_verbunden (Bug-Fix Zeile 112 getestet)."""
|
|
|
|
def _nachbarn(self):
|
|
return {
|
|
"Drehung0": 90, "Drehung1": 180,
|
|
"x0": "100", "y0": "200", "x1": "300", "y1": "400",
|
|
}
|
|
|
|
def test_default_richtung_vertikal(self):
|
|
# richtung2 == "DEFAULT", richtung0 == "Vertikal"
|
|
# x0(100) < x1(300) → "_links", position="higher_links"
|
|
# gefaelle="links" → rotation=90
|
|
rotation, d0, d1, hp = Gefaellestrecke.rotation_mit_zwei_verbunden(
|
|
self._nachbarn(), "DEFAULT", "Vertikal", 0, 0, "higher"
|
|
)
|
|
self.assertEqual(rotation, 90)
|
|
|
|
def test_nicht_default_richtung_horizontal(self):
|
|
# richtung2 != "DEFAULT", richtung2 == "Horizontal"
|
|
# y0(200) < y1(400) → "_lower", position="higher_lower"
|
|
# gefaelle="unten" → rotation=180
|
|
rotation, _, _, _ = Gefaellestrecke.rotation_mit_zwei_verbunden(
|
|
self._nachbarn(), "Horizontal", "Vertikal", 0, 0, "higher"
|
|
)
|
|
self.assertEqual(rotation, 180)
|
|
|
|
def test_bug_fix_am_kreisel_zuweisung(self):
|
|
# kreisel_verbunden=1, am_kreisel=2 → muss tauschen (Bug fix: war ==)
|
|
nachbarn = self._nachbarn()
|
|
# Drehungen verschieden damit Tausch sichtbar
|
|
nachbarn["Drehung0"] = 45
|
|
nachbarn["Drehung1"] = 135
|
|
rotation, d0, d1, hp = Gefaellestrecke.rotation_mit_zwei_verbunden(
|
|
nachbarn, "DEFAULT", "Vertikal", 2, 1, "higher"
|
|
)
|
|
# Drehungen sollten getauscht sein
|
|
self.assertEqual(d0, 135)
|
|
self.assertEqual(d1, 45)
|
|
self.assertEqual(hp, "lower")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|