unit tests

Author: JacobTh98

tests/test_datatype_conversion.py

@@ -0,0 +1,38 @@
+import struct
+
+import numpy as np
+
+from sciopy.datatype_conversion import (
+    bytelist_to_int,
+    byteintarray_to_float,
+    bytesarray_to_double,
+    bytesarray_to_float,
+    del_hex_in_list,
+    four_byte_to_int,
+    two_byte_to_int,
+)
+
+
+def test_hex_list_is_normalized_to_two_digits():
+    assert del_hex_in_list(["0x0", "0xa", "0xff", 1]).tolist() == [
+        "00",
+        "0a",
+        "ff",
+        "01",
+    ]
+
+
+def test_float_conversions_use_network_byte_order():
+    float_bytes = struct.pack("!f", 12.5)
+    double_bytes = struct.pack("!d", -0.125)
+
+    assert byteintarray_to_float(float_bytes) == 12.5
+    assert bytesarray_to_float([f"{value:02x}" for value in float_bytes]) == 12.5
+    assert bytesarray_to_double([f"{value:02x}" for value in double_bytes]) == -0.125
+
+
+def test_integer_conversions_include_every_byte():
+    assert two_byte_to_int([0x12, 0x34]) == 0x1234
+    assert four_byte_to_int([0x12, 0x34, 0x56, 0x78]) == 0x12345678
+    assert bytelist_to_int([0x12, 0x34]) == 0x1234
+    assert bytelist_to_int(np.array([0x12, 0x34, 0x56])) == 0x123456

tests/test_eit_system_message_callback.py

@@ -0,0 +1,79 @@
+from unittest.mock import Mock
+
+from sciopy.EIT_16_32_64_128 import EIT_16_32_64_128
+
+
+def test_system_message_callback_uses_configured_message_parser():
+    device = EIT_16_32_64_128(16)
+    device.print_msg = True
+    device.cMessageParser = Mock()
+    device.cMessageParser.read_usb_till_timeout.return_value = []
+
+    result = device.SystemMessageCallback()
+
+    assert result == []
+    assert device.cMessageParser.bPrintMessages is True
+    device.cMessageParser.read_usb_till_timeout.assert_called_once_with(
+        bSaveData=False,
+        bDeleteDataFrame=True,
+        bStartReset=False,
+    )
+
+
+def test_get_device_info_does_not_require_measurement_setup():
+    device = EIT_16_32_64_128(16)
+    device.serial_protocol = "HS"
+    device.device = Mock()
+    device.cMessageParser = Mock()
+
+    device.GetDeviceInfo()
+
+    device.device.write_data.assert_called_once_with(bytearray([0xD1, 0x00, 0xD1]))
+    device.cMessageParser.read_usb_till_timeout.assert_called_once_with(
+        bSaveData=False,
+        bDeleteDataFrame=True,
+        bStartReset=False,
+    )
+
+
+def test_read_message_uses_parser_transport_without_recursion():
+    device = EIT_16_32_64_128(16)
+    device.cMessageParser = Mock()
+    device.cMessageParser.device_read.return_value = bytearray([0x18, 0x01, 0x83, 0x18])
+
+    assert device.read_message() == bytearray([0x18, 0x01, 0x83, 0x18])
+    device.cMessageParser.device_read.assert_called_once_with()
+
+
+def test_update_measurement_mode_builds_valid_command():
+    device = EIT_16_32_64_128(16)
+    device.write_command_string = Mock()
+
+    device.update_measurement_mode("skip4", "external")
+
+    device.write_command_string.assert_called_once_with(
+        bytearray([0xB0, 0x03, 0x08, 0x04, 0x02, 0xB0])
+    )
+
+
+def test_get_measurement_setup_builds_valid_command():
+    device = EIT_16_32_64_128(16)
+    device.write_command_string = Mock()
+
+    device.GetMeasurementSetup(0x02)
+
+    device.write_command_string.assert_called_once_with(
+        bytearray([0xB1, 0x01, 0x02, 0xB1])
+    )
+
+
+def test_measurement_requires_setup_before_parser_reset():
+    device = EIT_16_32_64_128(16)
+    device.cMessageParser = Mock()
+
+    try:
+        device.StartStopMeasurement()
+    except RuntimeError as error:
+        assert str(error) == "SetMeasurementSetup must be called before measuring."
+    else:
+        raise AssertionError("StartStopMeasurement accepted a missing setup")

tests/test_file_and_visualization_helpers.py

@@ -0,0 +1,31 @@
+import pickle
+from types import SimpleNamespace
+
+import numpy as np
+
+from sciopy.doteit import list_eit_files, load_pickle_to_dict
+from sciopy.visualization import norm_data
+
+
+def test_list_eit_files_is_filtered_case_insensitively_and_sorted(tmp_path):
+    (tmp_path / "b.eit").touch()
+    (tmp_path / "A.EIT").touch()
+    (tmp_path / "ignored.txt").touch()
+
+    assert list_eit_files(tmp_path) == ["A.EIT", "b.eit"]
+
+
+def test_load_pickle_to_dict_reads_pickled_objects(tmp_path):
+    path = tmp_path / "sample.pickle"
+    with path.open("wb") as file:
+        pickle.dump(SimpleNamespace(value=42), file)
+
+    assert load_pickle_to_dict(path) == {"value": 42}
+
+
+def test_norm_data_handles_constant_arrays():
+    assert np.array_equal(norm_data(np.array([5.0, 5.0])), np.array([0.0, 0.0]))
+
+
+def test_norm_data_scales_to_unit_interval():
+    assert np.allclose(norm_data(np.array([2.0, 4.0, 6.0])), [0.0, 0.5, 1.0])

tests/test_isx_3.py

@@ -0,0 +1,245 @@
+from unittest.mock import Mock
+import struct
+
+import numpy as np
+
+from sciopy.ISX_3 import ISXMeasurement, ISX_3
+from sciopy.sciopy_dataclasses import EisMeasurementSetup
+
+
+def command_device():
+    device = ISX_3()
+    device.send_command = Mock(return_value=[])
+    return device
+
+
+def test_frame_builder_uses_sciospec_framing():
+    assert ISX_3.build_frame(0xB0, [0x02, 0x01, 0x00, 0x01]) == bytearray(
+        [0xB0, 0x04, 0x02, 0x01, 0x00, 0x01, 0xB0]
+    )
+
+
+def test_stream_parser_handles_partial_and_multiple_frames():
+    device = ISX_3()
+    first = bytes([0x18, 0x01, 0x83, 0x18])
+    second = bytes([0xBA, 0x04, 0x00, 0x00, 0x03, 0xE8, 0xBA])
+
+    assert device.parse_received_bytes(first[:2]) == []
+    assert device.parse_received_bytes(first[2:] + second) == [
+        list(first),
+        list(second),
+    ]
+
+
+def test_set_and_get_frontend_settings_follow_manual():
+    device = command_device()
+
+    device.SetFE_Settings("4-point", "bnc", "auto", "1v")
+    device.GetFE_Settings()
+
+    assert device.send_command.call_args_list == [
+        ((0xB0, [0x02, 0x01, 0x00, 0x01]),),
+        ((0xB1,),),
+    ]
+    assert device.decode_frame([0xB1, 0x04, 0x02, 0x01, 0x04, 0x02, 0xB1]) == {
+        "measurement_mode": 0x02,
+        "measurement_channel": 0x01,
+        "current_range": 0x04,
+        "voltage_range": 0x02,
+    }
+
+
+def test_options_update_measurement_layout_state():
+    device = command_device()
+
+    device.SetOptions("timestamp_us", True)
+    device.SetOptions("current_range", True)
+
+    assert device.timestamp_mode == "us"
+    assert device.current_range_output is True
+    assert device.send_command.call_args_list == [
+        ((0x97, [0x02, 0x01]),),
+        ((0x97, [0x04, 0x01]),),
+    ]
+
+
+def test_add_frequency_point_encodes_float_and_extended_options():
+    device = command_device()
+
+    device.AddFrequencyPoint(
+        32_000,
+        1.0,
+        0.25,
+        point_delay=1000,
+        phase_sync=True,
+        excitation_type="voltage",
+    )
+
+    payload = device.send_command.call_args.args[1]
+    assert device.send_command.call_args.args[0] == 0xB6
+    assert payload[0] == 0x02
+    assert struct.unpack(">fff", payload[1:13]) == (32_000.0, 1.0, 0.25)
+    assert payload[13:] == bytearray(
+        [0x01, 0x00, 0x00, 0x03, 0xE8, 0x02, 0, 0, 0, 1, 0x03, 0, 0, 0, 1]
+    )
+
+
+def test_add_frequency_list_encodes_documented_setup():
+    device = command_device()
+
+    device.AddFrequencyList(1_000, 10_000, 10, "log", 1.0, 0.25)
+
+    tag, payload = device.send_command.call_args.args
+    assert tag == 0xB6
+    assert payload[0] == 0x03
+    assert struct.unpack(">fff", payload[1:13]) == (1_000.0, 10_000.0, 10.0)
+    assert payload[13] == 0x01
+    assert struct.unpack(">ff", payload[14:22]) == (1.0, 0.25)
+
+
+def test_eis_dataclass_configures_setup():
+    device = command_device()
+    setup = EisMeasurementSetup(
+        start=100,
+        stop=100_000,
+        step=20,
+        stepmode="log",
+        avg=1,
+        amplitude=0.1,
+        precision=1,
+        measurement_time=0,
+    )
+
+    device.SetMeasurementSetup(setup)
+
+    assert device.setup is setup
+    assert device.send_command.call_args_list[0] == ((0xB6, [0x01]),)
+    assert device.send_command.call_args_list[1].args[0] == 0xB6
+
+
+def test_measurement_without_optional_fields_is_decoded():
+    device = ISX_3()
+    payload = [0x00, 0x02, *struct.pack(">ff", 123.5, -4.25)]
+
+    result = device.decode_frame([0xB8, len(payload), *payload, 0xB8])
+
+    assert result == ISXMeasurement(frequency_id=2, impedance=123.5 - 4.25j)
+
+
+def test_measurement_with_microsecond_timestamp_and_range_is_decoded():
+    device = ISX_3()
+    device.timestamp_mode = "us"
+    device.current_range_output = True
+    payload = [0x00, 0x03, 0, 0, 0, 1, 2, 0x04, *struct.pack(">ff", 10, 2)]
+
+    result = device.decode_frame([0xB8, len(payload), *payload, 0xB8])
+
+    assert result == ISXMeasurement(
+        frequency_id=3,
+        impedance=10 + 2j,
+        timestamp=258,
+        timestamp_unit="us",
+        current_range=0x04,
+    )
+
+
+def test_setup_response_decoders():
+    device = ISX_3()
+    frequencies = struct.pack(">ff", 100.0, 1_000.0)
+
+    assert device.decode_frame([0xB7, 0x03, 0x01, 0x00, 0x10, 0xB7]) == {
+        "frequency_count": 16
+    }
+    result = device.decode_frame([0xB7, 0x09, 0x04, *frequencies, 0xB7])
+    assert np.allclose(result["frequencies_hz"], [100, 1_000])
+
+
+def test_frequency_point_response_decodes_extended_options():
+    device = ISX_3()
+    data = [
+        0x02,
+        *struct.pack(">fff", 32_000, 1.0, 0.25),
+        0x01,
+        0,
+        0,
+        3,
+        0xE8,
+        0x03,
+        0,
+        0,
+        0,
+        1,
+    ]
+
+    result = device.decode_frame([0xB7, len(data), *data, 0xB7])
+
+    assert result == {
+        "frequency_hz": 32_000.0,
+        "precision": 1.0,
+        "amplitude": 0.25,
+        "point_delay_us": 1_000,
+        "excitation_type": 1,
+    }
+
+
+def test_compensation_record_encodes_three_complex_values():
+    device = command_device()
+
+    device.SetCompensationData(2, 3, 1 + 2j, 3 + 4j, 5 + 6j)
+
+    tag, payload = device.send_command.call_args.args
+    assert tag == 0xB6
+    assert payload[:5] == bytearray([0x17, 0x02, 0x02, 0x00, 0x03])
+    assert struct.unpack(">ffffff", payload[5:]) == (1, 2, 3, 4, 5, 6)
+
+
+def test_sync_ethernet_and_watchdog_commands():
+    device = command_device()
+
+    device.SetSyncTime(1_000)
+    device.SetEthernetConfiguration(ip_address="192.168.1.25")
+    device.SetEthernetConfiguration(dhcp=True)
+    device.GetEthernetConfiguration("mac_address")
+    device.SetTCPWatchdog(60)
+
+    assert device.send_command.call_args_list == [
+        ((0xB9, bytes([0, 0, 3, 0xE8])),),
+        ((0xBD, [0x01, 192, 168, 1, 25]),),
+        ((0xBD, [0x03, 1]),),
+        ((0xBE, [0x02]),),
+        ((0xCF, [0x00, 0, 0, 0, 60]),),
+    ]
+
+
+def test_firmware_and_device_information_are_decoded():
+    device = ISX_3()
+
+    arm = device.decode_frame([0xD0, 0x06, 1, 2, 0, 3, 0, 4, 0xD0])
+    identity = device.decode_frame([0xD1, 0x07, 1, 0, 7, 0x12, 0x34, 14, 9, 0xD1])
+
+    assert arm == {"developer_information": "0102", "revision": 3, "build": 4}
+    assert identity == {
+        "information_version": 1,
+        "device_identifier": 7,
+        "serial_number": 0x1234,
+        "delivery_year": 2024,
+        "delivery_month": 9,
+        "developer_information": "",
+    }
+
+
+def test_invalid_protocol_values_are_rejected():
+    device = command_device()
+
+    for action in (
+        lambda: device.SetFE_Settings("invalid", "bnc", "auto"),
+        lambda: device.SetSyncTime(180_000_001),
+        lambda: device.SetTCPWatchdog(0),
+        lambda: device.SetDCBiasValue(1.1),
+    ):
+        try:
+            action()
+        except ValueError:
+            pass
+        else:
+            raise AssertionError("invalid protocol value was accepted")