142 lines
5.2 KiB
Python
142 lines
5.2 KiB
Python
import unittest
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).parent))
|
|
|
|
try:
|
|
import aufgabe
|
|
except ImportError as e:
|
|
raise ImportError(f"Konnte 'aufgabe.py' nicht importieren: {e}")
|
|
|
|
|
|
class TestKapitel08(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
Vektor2D = getattr(aufgabe, "Vektor2D", None)
|
|
Wegstrecke = getattr(aufgabe, "Wegstrecke", None)
|
|
self.assertIsNotNone(Vektor2D, "Klasse 'Vektor2D' nicht in aufgabe.py gefunden!")
|
|
self.assertIsNotNone(Wegstrecke, "Klasse 'Wegstrecke' nicht in aufgabe.py gefunden!")
|
|
self.Vektor2D = Vektor2D
|
|
self.Wegstrecke = Wegstrecke
|
|
|
|
def test_01_init_und_darstellung(self):
|
|
"""Prüft __init__, __repr__ und __str__ von Vektor2D."""
|
|
v = self.Vektor2D(3, 4)
|
|
self.assertEqual(float(v.x), 3.0)
|
|
self.assertEqual(float(v.y), 4.0)
|
|
|
|
# __repr__ soll Entwickler-Syntax liefern
|
|
self.assertEqual(repr(v), "Vektor2D(3.0, 4.0)")
|
|
|
|
# __str__ soll lesbare Klammer-Syntax liefern
|
|
self.assertEqual(str(v), "(3.0, 4.0)")
|
|
|
|
def test_02_laenge_und_abs(self):
|
|
"""Prüft laenge() und die Dunder-Methode __abs__."""
|
|
v = self.Vektor2D(3, 4)
|
|
self.assertAlmostEqual(v.laenge(), 5.0, places=4)
|
|
self.assertAlmostEqual(abs(v), 5.0, places=4)
|
|
|
|
v_null = self.Vektor2D(0, 0)
|
|
self.assertAlmostEqual(abs(v_null), 0.0, places=4)
|
|
|
|
v_neg = self.Vektor2D(-6, -8)
|
|
self.assertAlmostEqual(abs(v_neg), 10.0, places=4)
|
|
|
|
def test_03_addition_und_subtraktion(self):
|
|
"""Prüft __add__ und __sub__ zweier Vektoren."""
|
|
v1 = self.Vektor2D(3, 4)
|
|
v2 = self.Vektor2D(1, -2)
|
|
|
|
v_sum = v1 + v2
|
|
self.assertIsInstance(v_sum, self.Vektor2D, "Das Ergebnis von v1 + v2 muss ein Vektor2D sein!")
|
|
self.assertAlmostEqual(v_sum.x, 4.0)
|
|
self.assertAlmostEqual(v_sum.y, 2.0)
|
|
|
|
v_diff = v1 - v2
|
|
self.assertIsInstance(v_diff, self.Vektor2D, "Das Ergebnis von v1 - v2 muss ein Vektor2D sein!")
|
|
self.assertAlmostEqual(v_diff.x, 2.0)
|
|
self.assertAlmostEqual(v_diff.y, 6.0)
|
|
|
|
def test_04_skalarmultiplikation_und_skalarprodukt(self):
|
|
"""Prüft Multiplikation mit Zahlen (__mul__, __rmul__) und Skalarprodukt (__mul__)."""
|
|
v = self.Vektor2D(2.5, -4.0)
|
|
|
|
# Skalarmultiplikation Zahl von rechts
|
|
v_mal_2 = v * 2
|
|
self.assertIsInstance(v_mal_2, self.Vektor2D)
|
|
self.assertAlmostEqual(v_mal_2.x, 5.0)
|
|
self.assertAlmostEqual(v_mal_2.y, -8.0)
|
|
|
|
# Skalarmultiplikation Zahl von links (__rmul__)
|
|
v_links = 3 * v
|
|
self.assertIsInstance(v_links, self.Vektor2D)
|
|
self.assertAlmostEqual(v_links.x, 7.5)
|
|
self.assertAlmostEqual(v_links.y, -12.0)
|
|
|
|
# Skalarprodukt zweier Vektoren: v1 * v2 -> x1*x2 + y1*y2
|
|
v1 = self.Vektor2D(2, 3)
|
|
v2 = self.Vektor2D(4, -1)
|
|
skalarprodukt = v1 * v2
|
|
self.assertTrue(isinstance(skalarprodukt, (int, float)), "Skalarprodukt muss eine Zahl sein!")
|
|
self.assertAlmostEqual(skalarprodukt, 2 * 4 + 3 * (-1)) # 8 - 3 = 5
|
|
|
|
def test_05_vergleiche(self):
|
|
"""Prüft __eq__, __lt__ und __le__."""
|
|
v1 = self.Vektor2D(3, 4) # Länge 5.0
|
|
v2 = self.Vektor2D(3.0, 4.0) # Länge 5.0 (gleiche Werte)
|
|
v3 = self.Vektor2D(0, 5) # Länge 5.0 (andere Werte)
|
|
v4 = self.Vektor2D(1, 1) # Länge sqrt(2) ≈ 1.414
|
|
v5 = self.Vektor2D(6, 8) # Länge 10.0
|
|
|
|
# Gleichheit
|
|
self.assertEqual(v1, v2)
|
|
self.assertNotEqual(v1, v3)
|
|
self.assertNotEqual(v1, "kein vektor")
|
|
|
|
# Kleiner (<)
|
|
self.assertTrue(v4 < v1)
|
|
self.assertFalse(v1 < v4)
|
|
self.assertFalse(v1 < v3) # gleiche Länge
|
|
|
|
# Kleiner-Gleich (<=)
|
|
self.assertTrue(v4 <= v1)
|
|
self.assertTrue(v1 <= v3) # gleiche Länge -> True
|
|
self.assertTrue(v1 <= v5)
|
|
self.assertFalse(v5 <= v1)
|
|
|
|
def test_06_wegstrecke_container(self):
|
|
"""Prüft Wegstrecke Initialisierung, __len__ und __getitem__."""
|
|
p1 = self.Vektor2D(0, 0)
|
|
p2 = self.Vektor2D(2, 3)
|
|
p3 = self.Vektor2D(5, 7)
|
|
|
|
strecke = self.Wegstrecke([p1, p2])
|
|
self.assertEqual(len(strecke), 2, "len(strecke) muss 2 zurückgeben!")
|
|
self.assertEqual(strecke[0], p1, "strecke[0] muss p1 sein!")
|
|
self.assertEqual(strecke[1], p2, "strecke[1] muss p2 sein!")
|
|
|
|
strecke.punkt_hinzufuegen(p3)
|
|
self.assertEqual(len(strecke), 3)
|
|
self.assertEqual(strecke[2], p3)
|
|
|
|
def test_07_wegstrecke_gesamtlaenge(self):
|
|
"""Prüft Wegstrecke.gesamtlaenge() mit 0, 1 und 3 Wegpunkten."""
|
|
strecke_leer = self.Wegstrecke()
|
|
self.assertAlmostEqual(strecke_leer.gesamtlaenge(), 0.0)
|
|
|
|
strecke_einzeln = self.Wegstrecke([self.Vektor2D(10, 20)])
|
|
self.assertAlmostEqual(strecke_einzeln.gesamtlaenge(), 0.0)
|
|
|
|
# Route (0,0) -> (3,0) Distanz = 3; (3,0) -> (3,4) Distanz = 4; Summe = 7
|
|
route = self.Wegstrecke([
|
|
self.Vektor2D(0, 0),
|
|
self.Vektor2D(3, 0),
|
|
self.Vektor2D(3, 4)
|
|
])
|
|
self.assertAlmostEqual(route.gesamtlaenge(), 7.0, places=4)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|