Verschlafene Kilometer am Fahrtanfang zurueckholen

Der Dongle wacht nach dem Motorstart erst nach 28 s bis 19,5 min auf; was in
der Zeit gefahren wird, zeichnet er nicht auf. Die Kilometer holt das
Screening jetzt aus dem Endkilometerstand der Vorgaengerin zurueck und haelt
in luecke_km fest, wie viel davon betroffen ist.

Keine Sperre der GNSS-Verfeinerung, sondern eine Zerlegung: verschlafener
Anfang in ganzen Kilometern, aufgezeichneter Rest metergenau. Sonst waere die
feine Zahl systematisch zu klein und wuerde bei kleinen Luecken die Korrektur
stillschweigend wieder kassieren.

Zwei Schutzgitter, beide am Bestand gelernt: LUECKE_MAX_KM = 50 gegen
Differenzen, die keine Weckverzoegerung mehr sein koennen, und ein Rueckfall,
wenn _vollstaendig() die Werte daraufhin verwerfen wuerde.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/verlauf/test_aufzeichnungsluecke.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Die Kilometer, die der Dongle am Anfang einer Fahrt verschlaeft.
+
+Der FMM003 kommt aus dem Deep Sleep nur ueber seinen Beschleunigungssensor
+hoch: die eingestellte Zuendungsquelle ist die Motordrehzahl, die liegt am CAN,
+und CAN ist im Schlaf abgeschaltet. Gemessene Weckzeiten am 31.08. bis
+05.09.2026: 28 s, 144 s, 182 s, 484 s, 543 s, 632 s, 1131 s, 1170 s.
+
+Die Zahlen hier sind gemessen, nicht erfunden - Rueckfahrt Eichstaett -
+Adelschlag am 05.09.2026: Motorstart 23:04:16 (aus der Motorlaufzeit 543 s im
+ersten Datensatz), erster Datensatz aber erst 23:13:19. Der Tacho stand vorher
+auf 21347 und im ersten Datensatz danach bereits auf 21353.
+
+Aufruf: python3 tests/verlauf/test_aufzeichnungsluecke.py
+"""
+
+import os
+import sys
+import unittest
+
+_HIER = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.dirname(os.path.dirname(_HIER)))
+
+from custom_components.audi_dashboard import verlauf as v  # noqa: E402
+
+
+class Luecke(unittest.TestCase):
+    def test_echter_fall_vom_05_09(self):
+        """21347 am Ende der Hinfahrt, 21353 im ersten Datensatz der Rueckfahrt."""
+        self.assertEqual(v.aufzeichnungsluecke_km(21347.0, 21353.0), 6.0)
+
+    def test_keine_luecke_ist_none(self):
+        """Der Normalfall: die Rueckfahrt beginnt, wo die Hinfahrt endete."""
+        self.assertIsNone(v.aufzeichnungsluecke_km(21347.0, 21347.0))
+
+    def test_rueckwaerts_ist_keine_luecke(self):
+        """Ein niedrigerer Start ist ein Fahrzeugwechsel des Geraets oder ein
+        Ausreisser - jedenfalls keine verschlafene Strecke. _vollstaendig()
+        faengt den Fall an anderer Stelle ab; hier darf er nur nicht als
+        Luecke durchgehen."""
+        self.assertIsNone(v.aufzeichnungsluecke_km(21353.0, 21347.0))
+
+    def test_unbekannte_werte(self):
+        self.assertIsNone(v.aufzeichnungsluecke_km(None, 21353.0))
+        self.assertIsNone(v.aufzeichnungsluecke_km(21347.0, None))
+        self.assertIsNone(v.aufzeichnungsluecke_km(None, None))
+
+
+class Zerlegung(unittest.TestCase):
+    """Verschlafener Anfang in ganzen Kilometern, aufgezeichneter Rest
+    metergenau - und die Summe muss den Tacho-Anker weiterhin bestehen.
+
+    Ohne die Zerlegung waere die feine Zahl allein systematisch zu klein, und
+    bei einer kleinen Luecke laege sie sogar noch innerhalb der Toleranz und
+    kassierte die gerade erst geholte Strecke wieder ein. Genau das soll hier
+    nicht passieren."""
+
+    def test_summe_wird_genommen(self):
+        """6 km verschlafen, 1,428 km aufgezeichnet, Tacho sagt 7 km."""
+        fein = round(1.428 + 6.0, 3)
+        gewaehlt, genommen = v.strecke_waehlen(7.0, fein)
+        self.assertTrue(genommen)
+        self.assertEqual(gewaehlt, 7.428)
+
+    def test_ohne_zerlegung_wuerde_der_tacho_gewinnen(self):
+        """Zur Abgrenzung: die feine Zahl allein liegt 5,57 km daneben und
+        wird verworfen - die Fahrt bekaeme 7 statt 7,428 km."""
+        gewaehlt, genommen = v.strecke_waehlen(7.0, 1.428)
+        self.assertFalse(genommen)
+        self.assertEqual(gewaehlt, 7.0)
+
+    def test_kleine_luecke_ist_der_gefaehrliche_fall(self):
+        """Eine Luecke von 1 km: die feine Zahl allein (5,1 gegen 6) laege
+        INNERHALB der Toleranz und wuerde stillschweigend gewinnen - 0,9 km
+        weniger, ohne dass es jemand merkt. Mit Zerlegung stimmt es."""
+        ohne, genommen_ohne = v.strecke_waehlen(6.0, 5.1)
+        self.assertTrue(genommen_ohne, "ohne Zerlegung schluepft der Fehler durch")
+        self.assertEqual(ohne, 5.1)
+
+        mit, genommen_mit = v.strecke_waehlen(6.0, round(5.1 + 1.0, 3))
+        self.assertTrue(genommen_mit)
+        self.assertEqual(mit, 6.1)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)