temp

Author: PhantomInTheWire

opendbc/car/ford/tests/test_ford.py

@@ -1,13 +1,8 @@
 import random
 from collections.abc import Iterable
-
-from hypothesis import settings, given, strategies as st
-from parameterized import parameterized
+import pytest
 
 from opendbc.car.structs import CarParams
-from opendbc.car.fw_versions import build_fw_dict
-from opendbc.car.ford.values import CAR, FW_QUERY_CONFIG, FW_PATTERN, get_platform_codes
-from opendbc.car.ford.fingerprints import FW_VERSIONS
 
 Ecu = CarParams.Ecu
 
@@ -42,39 +37,50 @@
 
 class TestFordFW:
   def test_fw_query_config(self):
+    from opendbc.car.ford.values import FW_QUERY_CONFIG
     for (ecu, addr, subaddr) in FW_QUERY_CONFIG.extra_ecus:
       assert ecu in ECU_ADDRESSES, "Unknown ECU"
       assert addr == ECU_ADDRESSES[ecu], "ECU address mismatch"
       assert subaddr is None, "Unexpected ECU subaddress"
 
-  @parameterized.expand(FW_VERSIONS.items())
-  def test_fw_versions(self, car_model: str, fw_versions: dict[tuple[int, int, int | None], Iterable[bytes]]):
-    for (ecu, addr, subaddr), fws in fw_versions.items():
-      assert ecu in ECU_PART_NUMBER, "Unexpected ECU"
-      assert addr == ECU_ADDRESSES[ecu], "ECU address mismatch"
-      assert subaddr is None, "Unexpected ECU subaddress"
+  def test_fw_versions(self):
+    from opendbc.car.ford.values import FW_PATTERN, get_platform_codes
+    from opendbc.car.ford.fingerprints import FW_VERSIONS
 
-      for fw in fws:
-        assert len(fw) == 24, "Expected ECU response to be 24 bytes"
+    for car_model, fw_versions in FW_VERSIONS.items(): 
+      for (ecu, addr, subaddr), fws in fw_versions.items():
+        assert ecu in ECU_PART_NUMBER, "Unexpected ECU"
+        assert addr == ECU_ADDRESSES[ecu], "ECU address mismatch"
+        assert subaddr is None, "Unexpected ECU subaddress"
 
-        match = FW_PATTERN.match(fw)
-        assert match is not None, f"Unable to parse FW: {fw!r}"
-        if match:
-          part_number = match.group("part_number")
-          assert part_number in ECU_PART_NUMBER[ecu], f"Unexpected part number for {fw!r}"
+        for fw in fws:
+          assert len(fw) == 24, "Expected ECU response to be 24 bytes"
 
-        codes = get_platform_codes([fw])
-        assert 1 == len(codes), f"Unable to parse FW: {fw!r}"
+          match = FW_PATTERN.match(fw)
+          assert match is not None, f"Unable to parse FW: {fw!r}"
+          if match:
+            part_number = match.group("part_number")
+            assert part_number in ECU_PART_NUMBER[ecu], f"Unexpected part number for {fw!r}"
 
-  @settings(max_examples=100)
-  @given(data=st.data())
-  def test_platform_codes_fuzzy_fw(self, data):
+          codes = get_platform_codes([fw])
+          assert 1 == len(codes), f"Unable to parse FW: {fw!r}"
+
+  def test_platform_codes_fuzzy_fw(self):
     """Ensure function doesn't raise an exception"""
-    fw_strategy = st.lists(st.binary())
-    fws = data.draw(fw_strategy)
-    get_platform_codes(fws)
+    from hypothesis import settings, given, strategies as st
+      
+    @settings(max_examples=100)
+    @given(data=st.data())
+    def _test_impl(data):
+      from opendbc.car.ford.values import get_platform_codes
+      fw_strategy = st.lists(st.binary())
+      fws = data.draw(fw_strategy)
+      get_platform_codes(fws)
+      
+    _test_impl()
 
   def test_platform_codes_spot_check(self):
+    from opendbc.car.ford.values import get_platform_codes
     # Asserts basic platform code parsing behavior for a few cases
     results = get_platform_codes([
       b"JX6A-14C204-BPL\x00\x00\x00\x00\x00\x00\x00\x00\x00",
@@ -85,6 +91,10 @@ def test_platform_codes_spot_check(self):
     assert results == {(b"X6A", b"J"), (b"Z6T", b"N"), (b"J6T", b"P"), (b"B5A", b"L")}
 
   def test_fuzzy_match(self):
+    from opendbc.car.ford.values import FW_QUERY_CONFIG
+    from opendbc.car.fw_versions import build_fw_dict
+    from opendbc.car.ford.fingerprints import FW_VERSIONS
+
     for platform, fw_by_addr in FW_VERSIONS.items():
       # Ensure there's no overlaps in platform codes
       for _ in range(20):
@@ -100,6 +110,7 @@ def test_fuzzy_match(self):
         assert matches == {platform}
 
   def test_match_fw_fuzzy(self):
+    from opendbc.car.ford.values import CAR, FW_QUERY_CONFIG
     offline_fw = {
       (Ecu.eps, 0x730, None): [
         b"L1MC-14D003-AJ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",

opendbc/car/hyundai/tests/test_hyundai.py

@@ -1,18 +1,12 @@
-from hypothesis import settings, given, strategies as st
-
 import pytest
 
 from opendbc.car import gen_empty_fingerprint
 from opendbc.car.structs import CarParams
-from opendbc.car.fw_versions import build_fw_dict
-from opendbc.car.hyundai.interface import CarInterface
 from opendbc.car.hyundai.hyundaicanfd import CanBus
-from opendbc.car.hyundai.radar_interface import RADAR_START_ADDR
 from opendbc.car.hyundai.values import CAMERA_SCC_CAR, CANFD_CAR, CAN_GEARS, CAR, CHECKSUM, DATE_FW_ECUS, \
                                          HYBRID_CAR, EV_CAR, FW_QUERY_CONFIG, LEGACY_SAFETY_MODE_CAR, CANFD_FUZZY_WHITELIST, \
                                          UNSUPPORTED_LONGITUDINAL_CAR, PLATFORM_CODE_ECUS, HYUNDAI_VERSION_REQUEST_LONG, \
                                          HyundaiFlags, get_platform_codes, HyundaiSafetyFlags
-from opendbc.car.hyundai.fingerprints import FW_VERSIONS
 
 Ecu = CarParams.Ecu
 
@@ -45,6 +39,8 @@
 
 class TestHyundaiFingerprint:
   def test_feature_detection(self):
+    from opendbc.car.hyundai.interface import CarInterface
+    from opendbc.car.hyundai.radar_interface import RADAR_START_ADDR
     # LKA steering
     for lka_steering in (True, False):
       fingerprint = gen_empty_fingerprint()
@@ -63,6 +59,8 @@ def test_feature_detection(self):
       assert CP.radarUnavailable != radar
 
   def test_alternate_limits(self):
+    from opendbc.car.hyundai.interface import CarInterface
+    
     # Alternate lateral control limits, for high torque cars, verify Panda safety mode flag is set
     fingerprint = gen_empty_fingerprint()
     for car_model in CAR:
@@ -83,6 +81,8 @@ def test_hybrid_ev_sets(self):
     assert CANFD_CAR & HYBRID_CAR == set(), "Hard coding CAN FD cars as hybrid is no longer supported"
 
   def test_canfd_ecu_whitelist(self):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     # Asserts only expected Ecus can exist in database for CAN-FD cars
     for car_model in CANFD_CAR:
       ecus = {fw[0] for fw in FW_VERSIONS[car_model].keys()}
@@ -92,6 +92,8 @@ def test_canfd_ecu_whitelist(self):
                        f"{car_model}: Car model has unexpected ECUs: {ecu_strings}"
 
   def test_blacklisted_parts(self, subtests):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     # Asserts no ECUs known to be shared across platforms exist in the database.
     # Tucson having Santa Cruz camera and EPS for example
     for car_model, ecus in FW_VERSIONS.items():
@@ -106,6 +108,8 @@ def test_blacklisted_parts(self, subtests):
           assert not part.startswith(b'CW'), "Car has bad part number"
 
   def test_correct_ecu_response_database(self, subtests):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     """
     Assert standard responses for certain ECUs, since they can
     respond to multiple queries with different data
@@ -117,15 +121,22 @@ def test_correct_ecu_response_database(self, subtests):
           assert all(fw.startswith(expected_fw_prefix) for fw in fws), \
                           f"FW from unexpected request in database: {(ecu, fws)}"
 
-  @settings(max_examples=100)
-  @given(data=st.data())
-  def test_platform_codes_fuzzy_fw(self, data):
+  def test_platform_codes_fuzzy_fw(self):
+    from hypothesis import settings, given, strategies as st
+    
     """Ensure function doesn't raise an exception"""
-    fw_strategy = st.lists(st.binary())
-    fws = data.draw(fw_strategy)
-    get_platform_codes(fws)
+    @settings(max_examples=100)
+    @given(data=st.data())
+    def _test_impl(data):
+      fw_strategy = st.lists(st.binary())
+      fws = data.draw(fw_strategy)
+      get_platform_codes(fws)
+    
+    _test_impl()
 
   def test_expected_platform_codes(self, subtests):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     # Ensures we don't accidentally add multiple platform codes for a car unless it is intentional
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
@@ -145,6 +156,8 @@ def test_expected_platform_codes(self, subtests):
   # Tests for platform codes, part numbers, and FW dates which Hyundai will use to fuzzy
   # fingerprint in the absence of full FW matches:
   def test_platform_code_ecus_available(self, subtests):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     # TODO: add queries for these non-CAN FD cars to get EPS
     no_eps_platforms = CANFD_CAR | {CAR.KIA_SORENTO, CAR.KIA_OPTIMA_G4, CAR.KIA_OPTIMA_G4_FL, CAR.KIA_OPTIMA_H,
                                     CAR.KIA_OPTIMA_H_G4_FL, CAR.HYUNDAI_SONATA_LF, CAR.HYUNDAI_TUCSON, CAR.GENESIS_G90, CAR.GENESIS_G80, CAR.HYUNDAI_ELANTRA}
@@ -160,6 +173,8 @@ def test_platform_code_ecus_available(self, subtests):
           assert platform_code_ecu in [e[0] for e in ecus]
 
   def test_fw_format(self, subtests):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    
     # Asserts:
     # - every supported ECU FW version returns one platform code
     # - every supported ECU FW version has a part number
@@ -219,6 +234,9 @@ def test_platform_codes_spot_check(self):
                                (b"ON-S9100", b"190405"), (b"ON-S9100", b"190720")}
 
   def test_fuzzy_excluded_platforms(self):
+    from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+    from opendbc.car.fw_versions import build_fw_dict
+
     # Asserts a list of platforms that will not fuzzy fingerprint with platform codes due to them being shared.
     # This list can be shrunk as we combine platforms and detect features
     excluded_platforms = {

opendbc/car/toyota/tests/test_toyota.py

@@ -1,12 +1,5 @@
-from hypothesis import given, settings, strategies as st
-
 from opendbc.car import Bus
 from opendbc.car.structs import CarParams
-from opendbc.car.fw_versions import build_fw_dict
-from opendbc.car.toyota.fingerprints import FW_VERSIONS
-from opendbc.car.toyota.values import CAR, DBC, TSS2_CAR, ANGLE_CONTROL_CAR, RADAR_ACC_CAR, SECOC_CAR, \
-                                                  FW_QUERY_CONFIG, PLATFORM_CODE_ECUS, FUZZY_EXCLUDED_PLATFORMS, \
-                                                  get_platform_codes
 
 Ecu = CarParams.Ecu
 
@@ -18,22 +11,28 @@ def check_fw_version(fw_version: bytes) -> bool:
 
 class TestToyotaInterfaces:
   def test_car_sets(self):
+    from opendbc.car.toyota.values import TSS2_CAR, ANGLE_CONTROL_CAR, RADAR_ACC_CAR
     assert len(ANGLE_CONTROL_CAR - TSS2_CAR) == 0
     assert len(RADAR_ACC_CAR - TSS2_CAR) == 0
 
   def test_lta_platforms(self):
     # At this time, only RAV4 2023 is expected to use LTA/angle control
+    from opendbc.car.toyota.values import CAR, ANGLE_CONTROL_CAR
     assert ANGLE_CONTROL_CAR == {CAR.TOYOTA_RAV4_TSS2_2023}
 
   def test_tss2_dbc(self):
     # We make some assumptions about TSS2 platforms,
     # like looking up certain signals only in this DBC
+    from opendbc.car.toyota.values import DBC, TSS2_CAR, SECOC_CAR
     for car_model, dbc in DBC.items():
       if car_model in TSS2_CAR and car_model not in SECOC_CAR:
         assert dbc[Bus.pt] == "toyota_nodsu_pt_generated"
 
   def test_essential_ecus(self, subtests):
     # Asserts standard ECUs exist for each platform
+    from opendbc.car.toyota.values import CAR
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
+    
     common_ecus = {Ecu.fwdRadar, Ecu.fwdCamera}
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
@@ -55,6 +54,9 @@ def test_essential_ecus(self, subtests):
 class TestToyotaFingerprint:
   def test_non_essential_ecus(self, subtests):
     # Ensures only the cars that have multiple engine ECUs are in the engine non-essential ECU list
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
+    from opendbc.car.toyota.values import FW_QUERY_CONFIG
+    
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
         engine_ecus = {ecu for ecu in ecus if ecu[0] == Ecu.engine}
@@ -63,6 +65,8 @@ def test_non_essential_ecus(self, subtests):
 
   def test_valid_fw_versions(self, subtests):
     # Asserts all FW versions are valid
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
+    
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
         for fws in ecus.values():
@@ -71,15 +75,24 @@ def test_valid_fw_versions(self, subtests):
 
   # Tests for part numbers, platform codes, and sub-versions which Toyota will use to fuzzy
   # fingerprint in the absence of full FW matches:
-  @settings(max_examples=100)
-  @given(data=st.data())
-  def test_platform_codes_fuzzy_fw(self, data):
-    fw_strategy = st.lists(st.binary())
-    fws = data.draw(fw_strategy)
-    get_platform_codes(fws)
+  def test_platform_codes_fuzzy_fw(self):
+    from hypothesis import given, settings, strategies as st
+    from opendbc.car.toyota.values import get_platform_codes
+    
+    @settings(max_examples=100)
+    @given(data=st.data())
+    def _test_impl(data):
+      fw_strategy = st.lists(st.binary())
+      fws = data.draw(fw_strategy)
+      get_platform_codes(fws)
+    
+    _test_impl()
 
   def test_platform_code_ecus_available(self, subtests):
     # Asserts ECU keys essential for fuzzy fingerprinting are available on all platforms
+    from opendbc.car.toyota.values import CAR, PLATFORM_CODE_ECUS
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
+    
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
         for platform_code_ecu in PLATFORM_CODE_ECUS:
@@ -94,6 +107,8 @@ def test_fw_format(self, subtests):
     # - every supported ECU FW version returns one platform code
     # - every supported ECU FW version has a part number
     # - expected parsing of ECU sub-versions
+    from opendbc.car.toyota.values import PLATFORM_CODE_ECUS, get_platform_codes
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
 
     for car_model, ecus in FW_VERSIONS.items():
       with subtests.test(car_model=car_model.value):
@@ -116,6 +131,8 @@ def test_fw_format(self, subtests):
 
   def test_platform_codes_spot_check(self):
     # Asserts basic platform code parsing behavior for a few cases
+    from opendbc.car.toyota.values import get_platform_codes
+    
     results = get_platform_codes([
       b"F152607140\x00\x00\x00\x00\x00\x00",
       b"F152607171\x00\x00\x00\x00\x00\x00",
@@ -147,6 +164,10 @@ def test_platform_codes_spot_check(self):
 
   def test_fuzzy_excluded_platforms(self):
     # Asserts a list of platforms that will not fuzzy fingerprint with platform codes due to them being shared.
+    from opendbc.car.fw_versions import build_fw_dict
+    from opendbc.car.toyota.fingerprints import FW_VERSIONS
+    from opendbc.car.toyota.values import FW_QUERY_CONFIG, FUZZY_EXCLUDED_PLATFORMS
+    
     platforms_with_shared_codes = set()
     for platform, fw_by_addr in FW_VERSIONS.items():
       car_fw = []