pyxcp 0.25.2__cp314-cp314-win_arm64.whl

pyxcp/tests/test_transport.py

@@ -0,0 +1,177 @@
+from unittest import mock
+
+import pytest
+import serial
+from can.bus import BusABC
+
+import pyxcp.transport.base as tr
+
+
+def create_mock_serial():
+    """Create a mock serial port for testing."""
+    mock_serial = mock.MagicMock(spec=serial.Serial)
+    mock_serial.portstr = "MOCK_PORT"
+    mock_serial.in_waiting = 0
+    mock_serial.read.return_value = b""
+    mock_serial.is_open = True
+    return mock_serial
+
+
+def create_mock_can_interface():
+    """Create a mock CAN interface for testing."""
+    mock_can = mock.MagicMock(spec=BusABC)
+    mock_can.filters = []
+    mock_can.state = "ACTIVE"
+    mock_can.recv.return_value = None
+    return mock_can
+
+
+# Mock CAN interface configuration class
+class MockCanInterfaceConfig:
+    OPTIONAL_BASE_PARAMS = []
+    CAN_PARAM_MAP = {}
+
+    @classmethod
+    def class_own_traits(cls):
+        return {}
+
+
+def create_config():
+    # Create a class to simulate the config structure
+    class EthConfig:
+        def __init__(self):
+            self.host = "localhost"
+            self.port = 5555
+            self.bind_to_address = ""
+            self.bind_to_port = 0
+            self.protocol = "UDP"
+            self.ipv6 = False
+            self.tcp_nodelay = False
+
+    class SxiConfig:
+        def __init__(self):
+            self.port = "MOCK_PORT"  # This won't be used with the mock
+            self.bitrate = 115200
+            self.bytesize = 8
+            self.parity = "N"
+            self.stopbits = 1
+            self.mode = "NORMAL"
+            self.header_format = "HEADER_LEN_BYTE"
+            self.tail_format = ""
+            self.framing = 0
+            self.esc_sync = 0
+            self.esc_esc = 0
+
+    class CanConfig:
+        def __init__(self):
+            self.can_id_master = 1
+            self.can_id_slave = 2
+            self.interface = "MockCanInterface"
+            self.channel = "vcan0"
+            self.use_default_listener = False  # Don't start the listener
+            self.fd = False
+            self.max_dlc_required = False
+            self.padding_value = 0
+            self.timeout = 1.0
+            self.daq_identifier = []  # Empty list for DAQ identifiers
+
+            # Add the MockCanInterface attribute
+            self.MockCanInterface = MockCanInterfaceConfig()
+
+            # Special flag for testing
+            self.testing = True
+
+    class Config:
+        def __init__(self):
+            # Set attributes directly on the class for BaseTransport.load_config
+            self.eth = EthConfig()
+            self.sxi = SxiConfig()
+            self.can = CanConfig()
+
+            # Set attributes for BaseTransport.__init__
+            self.create_daq_timestamps = False
+            self.alignment = 1
+            self.timeout = 1.0
+
+    return Config()
+
+
+@mock.patch("pyxcp.transport.can.detect_available_configs")
+@mock.patch("pyxcp.transport.can.CAN_INTERFACE_MAP")
+def test_factory_works(mock_can_interface_map, mock_detect_configs):
+    # Mock the detect_available_configs function to return an empty list
+    mock_detect_configs.return_value = []
+
+    # Mock the CAN_INTERFACE_MAP to return an instance of our MockCanInterfaceConfig for any key
+    mock_can_interface_map.__getitem__.return_value = MockCanInterfaceConfig()
+
+    config = create_config()
+    mock_serial_port = create_mock_serial()
+    mock_can_interface = create_mock_can_interface()
+
+    # Test ETH transport
+    assert isinstance(tr.create_transport("eth", config=config), tr.BaseTransport)
+
+    # Test SXI transport with mock serial port
+    assert isinstance(tr.create_transport("sxi", config=config, transport_layer_interface=mock_serial_port), tr.BaseTransport)
+
+    # Test CAN transport with mock CAN interface
+    # assert isinstance(
+    #     tr.create_transport("can", config=config, transport_layer_interface=mock_can_interface),
+    #     tr.BaseTransport,
+    # )
+
+
+@mock.patch("pyxcp.transport.can.detect_available_configs")
+@mock.patch("pyxcp.transport.can.CAN_INTERFACE_MAP")
+def test_factory_works_case_insensitive(mock_can_interface_map, mock_detect_configs):
+    # Mock the detect_available_configs function to return an empty list
+    mock_detect_configs.return_value = []
+
+    # Mock the CAN_INTERFACE_MAP to return an instance of our MockCanInterfaceConfig for any key
+    mock_can_interface_map.__getitem__.return_value = MockCanInterfaceConfig()
+
+    config = create_config()
+    mock_serial_port = create_mock_serial()
+    mock_can_interface = create_mock_can_interface()
+
+    # Test ETH transport with uppercase name
+    assert isinstance(tr.create_transport("ETH", config=config), tr.BaseTransport)
+
+    # Test SXI transport with uppercase name and mock serial port
+    assert isinstance(tr.create_transport("SXI", config=config, transport_layer_interface=mock_serial_port), tr.BaseTransport)
+
+    # Test CAN transport with uppercase name and mock CAN interface
+    # assert isinstance(
+    #     tr.create_transport("CAN", config=config, transport_layer_interface=mock_can_interface),
+    #     tr.BaseTransport,
+    # )
+
+
+def test_factory_invalid_transport_name_raises():
+    with pytest.raises(ValueError):
+        tr.create_transport("xCp")
+
+
+def test_transport_names():
+    transports = tr.available_transports()
+
+    assert "can" in transports
+    assert "eth" in transports
+    assert "sxi" in transports
+
+
+def test_transport_names_are_lower_case_only():
+    transports = tr.available_transports()
+
+    assert "CAN" not in transports
+    assert "ETH" not in transports
+    assert "SXI" not in transports
+
+
+def test_transport_classes():
+    transports = tr.available_transports()
+
+    assert issubclass(transports.get("can"), tr.BaseTransport)
+    assert issubclass(transports.get("eth"), tr.BaseTransport)
+    assert issubclass(transports.get("sxi"), tr.BaseTransport)

pyxcp/tests/test_utils.py

@@ -0,0 +1,30 @@
+from sys import version_info
+
+from pyxcp.utils import PYTHON_VERSION, flatten, getPythonVersion, hexDump, slicer
+
+
+def test_hexdump(capsys):
+    print(hexDump(range(16)), end="")
+    captured = capsys.readouterr()
+    assert captured.out == "[00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f]"
+
+
+def test_slicer1():
+    res = slicer([1, 2, 3, 4, 5, 6, 7, 8], 4)
+    assert res == [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+
+def test_slicer2():
+    res = slicer(["10", "20", "30", "40", "50", "60", "70", "80"], 4, tuple)
+    assert res == [("10", "20", "30", "40"), ("50", "60", "70", "80")]
+
+
+def test_flatten1():
+    res = flatten([[1, 2, 3, 4], [5, 6, 7, 8]])
+    assert res == [1, 2, 3, 4, 5, 6, 7, 8]
+
+
+def test_version():
+    assert getPythonVersion() == version_info
+    assert PYTHON_VERSION == version_info
+    assert getPythonVersion() == PYTHON_VERSION

pyxcp/timing.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+import time
+
+
+class Timing:
+    T_US = 1000 * 1000
+    T_MS = 1000
+    T_S = 1
+
+    UNIT_MAP = {
+        T_US: "uS",
+        T_MS: "mS",
+        T_S: "S",
+    }
+    FMT = "min:  {0:2.3f} {4}\nmax:  {1:2.3f} {4}\navg:  {2:2.3f} {4}\nlast: {3:2.3f} {4}"
+
+    def __init__(self, unit=T_MS, record=False):
+        self.min = None
+        self.max = None
+        self.avg = None
+        self._previous = None
+        self.unit = unit
+        self._record = record
+        self._values = []
+
+    def start(self):
+        self._start = time.perf_counter()
+
+    def stop(self):
+        self._stop = time.perf_counter()
+        elapsed = self._stop - self._start
+        if self._record:
+            self._values.append(elapsed)
+        if self._previous:
+            self.min = min(self._previous, elapsed)
+            self.max = max(self._previous, elapsed)
+            self.avg = (self._previous + elapsed) / 2
+        else:
+            self.min = self.max = self.avg = elapsed
+        self._previous = elapsed
+
+    def __str__(self):
+        unitName = Timing.UNIT_MAP.get(self.unit, "??")
+        self.min = 0 if self.min is None else self.min
+        self.max = 0 if self.max is None else self.max
+        self.avg = 0 if self.avg is None else self.avg
+        self._previous = 0 if self._previous is None else self._previous
+        return Timing.FMT.format(
+            self.min * self.unit,
+            self.max * self.unit,
+            self.avg * self.unit,
+            self._previous * self.unit,
+            unitName,
+        )
+
+    __repr__ = __str__
+
+    @property
+    def values(self):
+        return self._values

pyxcp/transport/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# from .transport_ext import (
+#    FrameAcquisitionPolicy,  # noqa: F401
+#    FrameRecorderPolicy,  # noqa: F401
+#    LegacyFrameAcquisitionPolicy,  # noqa: F401
+#    NoOpPolicy,  # noqa: F401
+#    StdoutPolicy,  # noqa: F401
+# )
+
+from .can import Can  # noqa: F401
+from .eth import Eth  # noqa: F401
+from .sxi import SxI  # noqa: F401
+from .usb_transport import Usb  # noqa: F401