pyxcp 0.22.23__cp310-cp310-manylinux_2_28_x86_64.manylinux_2_27_x86_64.whl

pyxcp/tests/test_checksum.py

@@ -0,0 +1,95 @@
+import pytest
+
+from pyxcp import checksum
+
+
+"""
+XCP_ADD_11          0x10        0x10
+XCP_ADD_12          0x0F10      0x0F10
+XCP_ADD_14          0x00000F10  0x00000F10
+XCP_ADD_22          0x1800      0x0710
+XCP_ADD_24          0x00071800  0x00080710
+XCP_ADD_44          0x140C03F8  0xFC040B10
+
+XCP_CRC_16          0xC76A      0xC76A
+XCP_CRC_16_CITT     0x9D50      0x9D50
+XCP_CRC_32          0x89CD97CE  0x89CD97CE
+"""
+
+TEST = bytes(
+    (
+        0x01,
+        0x02,
+        0x03,
+        0x04,
+        0x05,
+        0x06,
+        0x07,
+        0x08,
+        0x09,
+        0x0A,
+        0x0B,
+        0x0C,
+        0x0D,
+        0x0E,
+        0x0F,
+        0x10,
+        0xF1,
+        0xF2,
+        0xF3,
+        0xF4,
+        0xF5,
+        0xF6,
+        0xF7,
+        0xF8,
+        0xF9,
+        0xFA,
+        0xFB,
+        0xFC,
+        0xFD,
+        0xFE,
+        0xFF,
+        0x00,
+    )
+)
+
+
+def testAdd11():
+    assert checksum.check(TEST, "XCP_ADD_11") == 0x10
+
+
+def testAdd12():
+    assert checksum.check(TEST, "XCP_ADD_12") == 0x0F10
+
+
+def testAdd14():
+    assert checksum.check(TEST, "XCP_ADD_14") == 0x00000F10
+
+
+def testAdd22():
+    assert checksum.check(TEST, "XCP_ADD_22") == 0x1800
+
+
+def testAdd24():
+    assert checksum.check(TEST, "XCP_ADD_24") == 0x00071800
+
+
+def testAdd44():
+    assert checksum.check(TEST, "XCP_ADD_44") == 0x140C03F8
+
+
+def testCrc16():
+    assert checksum.check(TEST, "XCP_CRC_16") == 0xC76A
+
+
+def testCrc16Ccitt():
+    assert checksum.check(TEST, "XCP_CRC_16_CITT") == 0x9D50
+
+
+def testCrc32():
+    assert checksum.check(TEST, "XCP_CRC_32") == 0x89CD97CE
+
+
+def testUserDefined():
+    with pytest.raises(NotImplementedError):
+        checksum.check(TEST, "XCP_USER_DEFINED")

pyxcp/tests/test_daq.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python
+
+from pyxcp.daq_stim import DaqList, DaqProcessor
+
+
+DAQ_INFO = {
+    "channels": [
+        {
+            "cycle": 0,
+            "maxDaqList": 1,
+            "name": "Key T",
+            "priority": 0,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": True, "packed": False, "stim": False},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+        {
+            "cycle": 10,
+            "maxDaqList": 1,
+            "name": "10 ms",
+            "priority": 1,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": True, "packed": False, "stim": True},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+        {
+            "cycle": 100,
+            "maxDaqList": 1,
+            "name": "100ms",
+            "priority": 2,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": True, "packed": False, "stim": True},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+        {
+            "cycle": 1,
+            "maxDaqList": 1,
+            "name": "1ms",
+            "priority": 3,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": True, "packed": False, "stim": True},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+        {
+            "cycle": 10,
+            "maxDaqList": 1,
+            "name": "FilterBypassDaq",
+            "priority": 4,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": True, "packed": False, "stim": True},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+        {
+            "cycle": 10,
+            "maxDaqList": 1,
+            "name": "FilterBypassStim",
+            "priority": 5,
+            "properties": {"consistency": "CONSISTENCY_ODT", "daq": False, "packed": False, "stim": True},
+            "unit": "EVENT_CHANNEL_TIME_UNIT_1MS",
+        },
+    ],
+    "processor": {
+        "keyByte": {
+            "addressExtension": "AE_DIFFERENT_WITHIN_ODT",
+            "identificationField": "IDF_REL_ODT_NUMBER_ABS_DAQ_LIST_NUMBER_BYTE",
+            "optimisationType": "OM_DEFAULT",
+        },
+        "maxDaq": 0,
+        "minDaq": 0,
+        "properties": {
+            "bitStimSupported": False,
+            "configType": "DYNAMIC",
+            "overloadEvent": False,
+            "overloadMsb": True,
+            "pidOffSupported": False,
+            "prescalerSupported": True,
+            "resumeSupported": True,
+            "timestampSupported": True,
+        },
+    },
+    "resolution": {
+        "granularityOdtEntrySizeDaq": 1,
+        "granularityOdtEntrySizeStim": 1,
+        "maxOdtEntrySizeDaq": 218,
+        "maxOdtEntrySizeStim": 218,
+        "timestampMode": {"fixed": False, "size": "S4", "unit": "DAQ_TIMESTAMP_UNIT_10US"},
+        "timestampTicks": 10,
+    },
+}
+
+SLAVE_INFO = {
+    "addressGranularity": 0,
+    "byteOrder": 0,
+    "interleavedMode": False,
+    "masterBlockMode": True,
+    "maxBs": 2,
+    "maxCto": 255,
+    "maxDto": 1500,
+    "maxWriteDaqMultipleElements": 31,
+    "minSt": 0,
+    "optionalCommMode": True,
+    "pgmProcessor": {},
+    "protocolLayerVersion": 1,
+    "queueSize": 0,
+    "slaveBlockMode": True,
+    "supportsCalpag": True,
+    "supportsDaq": True,
+    "supportsPgm": True,
+    "supportsStim": True,
+    "transportLayerVersion": 1,
+    "xcpDriverVersionNumber": 25,
+}
+
+
+class AttrDict(dict):
+    def __getattr__(self, name):
+        return self[name]
+
+
+class MockMaster:
+    def __init__(self):
+        self.slaveProperties = AttrDict(
+            {
+                "maxDto": 1500,
+                "supportsDaq": True,
+            }
+        )
+
+    def getDaqInfo(self):
+        return DAQ_INFO
+
+    def freeDaq(self):
+        pass
+
+    def allocDaq(self, daq_count):
+        self.daq_count = daq_count
+
+    def allocOdt(self, daq_num, odt_count):
+        pass
+
+    def allocOdtEntry(self, daq_num, odt_num, entry_count):
+        pass
+
+    def setDaqPtr(self, daqListNumber, odtNumber, odtEntryNumber):
+        pass
+
+    def writeDaq(self, bitOffset, entrySize, addressExt, address):
+        pass
+
+    def setDaqListMode(self, mode, daqListNumber, eventChannelNumber, prescaler, priority):
+        pass
+
+    def startStopDaqList(self, mode, daqListNumber):
+        pass
+
+    def startStopSynch(self, mode):
+        pass
+
+
+DAQ_LISTS = [
+    DaqList(
+        "list1",
+        1,
+        False,
+        True,
+        [
+            ("channel1", 0x1BD004, 0, "U32"),
+            ("channel2", 0x1BD008, 0, "U32"),
+            ("PWMFiltered", 0x1BDDE2, 0, "U8"),
+            ("PWM", 0x1BDDDF, 0, "U8"),
+            ("Triangle", 0x1BDDDE, 0, "U8"),
+        ],
+    ),
+    DaqList(
+        "list2",
+        3,
+        False,
+        True,
+        [
+            ("TestWord_002", 0x1BE124, 0, "U16"),
+            ("TestWord_003", 0x1BE128, 0, "U16"),
+            ("TestWord_001", 0x1BE120, 0, "U16"),
+            ("TestWord_003", 0x1BE128, 0, "U16"),
+            ("TestWord_004", 0x1BE12C, 0, "U16"),
+            ("TestWord_005", 0x1BE134, 0, "U16"),
+            ("TestWord_006", 0x1BE134, 0, "U16"),
+            ("TestWord_007", 0x1BE138, 0, "U16"),
+            ("TestWord_008", 0x1BE13C, 0, "U16"),
+            ("TestWord_009", 0x1BE140, 0, "U16"),
+            ("TestWord_011", 0x1BE148, 0, "U16"),
+        ],
+    ),
+]
+
+# daq = DaqProcessor(DAQ_LISTS)
+# daq.set_master(MockMaster())
+# daq.setup()
+# daq.start()

pyxcp/tests/test_frame_padding.py

@@ -0,0 +1,156 @@
+import pytest
+
+from pyxcp.transport.can import pad_frame
+
+
+def test_frame_padding_no_padding_length():
+    EXPECTED = (
+        (0, 8),
+        (1, 8),
+        (2, 8),
+        (3, 8),
+        (4, 8),
+        (5, 8),
+        (6, 8),
+        (7, 8),
+        (8, 8),
+        (9, 12),
+        (10, 12),
+        (11, 12),
+        (12, 12),
+        (13, 16),
+        (14, 16),
+        (15, 16),
+        (16, 16),
+        (17, 20),
+        (18, 20),
+        (19, 20),
+        (20, 20),
+        (21, 24),
+        (22, 24),
+        (23, 24),
+        (24, 24),
+        (25, 32),
+        (26, 32),
+        (27, 32),
+        (28, 32),
+        (29, 32),
+        (30, 32),
+        (31, 32),
+        (32, 32),
+        (33, 48),
+        (34, 48),
+        (35, 48),
+        (36, 48),
+        (37, 48),
+        (38, 48),
+        (39, 48),
+        (40, 48),
+        (41, 48),
+        (42, 48),
+        (43, 48),
+        (44, 48),
+        (45, 48),
+        (46, 48),
+        (47, 48),
+        (48, 48),
+        (49, 64),
+        (50, 64),
+        (51, 64),
+        (52, 64),
+        (53, 64),
+        (54, 64),
+        (55, 64),
+        (56, 64),
+        (57, 64),
+        (58, 64),
+        (59, 64),
+        (60, 64),
+        (61, 64),
+        (62, 64),
+        (63, 64),
+        (64, 64),
+    )
+    for frame_len in range(65):
+        frame = bytes(frame_len)
+        padded_frame = pad_frame(frame, padding_value=0, pad_frame=True)
+        frame_len = len(padded_frame)
+        _, expected_len = EXPECTED[frame_len]
+        assert frame_len == expected_len
+
+
+@pytest.mark.skip
+def test_frame_padding_padding_length32():
+    EXPECTED = (
+        (0, 32),
+        (1, 32),
+        (2, 32),
+        (3, 32),
+        (4, 32),
+        (5, 32),
+        (6, 32),
+        (7, 32),
+        (8, 32),
+        (9, 32),
+        (10, 32),
+        (11, 32),
+        (12, 32),
+        (13, 32),
+        (14, 32),
+        (15, 32),
+        (16, 32),
+        (17, 32),
+        (18, 32),
+        (19, 32),
+        (20, 32),
+        (21, 32),
+        (22, 32),
+        (23, 32),
+        (24, 32),
+        (25, 32),
+        (26, 32),
+        (27, 32),
+        (28, 32),
+        (29, 32),
+        (30, 32),
+        (31, 32),
+        (32, 32),
+        (33, 48),
+        (34, 48),
+        (35, 48),
+        (36, 48),
+        (37, 48),
+        (38, 48),
+        (39, 48),
+        (40, 48),
+        (41, 48),
+        (42, 48),
+        (43, 48),
+        (44, 48),
+        (45, 48),
+        (46, 48),
+        (47, 48),
+        (48, 48),
+        (49, 64),
+        (50, 64),
+        (51, 64),
+        (52, 64),
+        (53, 64),
+        (54, 64),
+        (55, 64),
+        (56, 64),
+        (57, 64),
+        (58, 64),
+        (59, 64),
+        (60, 64),
+        (61, 64),
+        (62, 64),
+        (63, 64),
+        (64, 64),
+    )
+    for frame_len in range(65):
+        frame = bytes(frame_len)
+        padded_frame = pad_frame(frame, padding_value=0, pad_frame=True)
+        frame_len = len(padded_frame)
+        _, expected_len = EXPECTED[frame_len]
+        assert frame_len == expected_len