From c7195881e39eff90523fe392e682429122ff12b4 Mon Sep 17 00:00:00 2001 From: "Peter F. Patel-Schneider" Date: Mon, 1 Apr 2024 18:13:02 -0400 Subject: [PATCH] tests: expand tests for device.py --- tests/logitech_receiver/hidpp.py | 183 +++++++++++++----- tests/logitech_receiver/test_device.py | 120 ++++++++---- .../logitech_receiver/test_hidpp20_complex.py | 107 ++-------- .../test_setting_templates.py | 2 + 4 files changed, 239 insertions(+), 173 deletions(-) diff --git a/tests/logitech_receiver/hidpp.py b/tests/logitech_receiver/hidpp.py index 4ae3bb1f..0a74d20e 100644 --- a/tests/logitech_receiver/hidpp.py +++ b/tests/logitech_receiver/hidpp.py @@ -37,6 +37,21 @@ def open_path(path: Optional[str]) -> int: return int(path, 16) # can raise exception +def ping(responses, handle, devnumber, long_message=False): + for r in responses: + if handle == r.handle and devnumber == r.devnumber and r.id == 0x0010: + return r.response + + +def request(responses, handle, devnumber, id, *params, no_reply=False, return_error=False, long_message=False, protocol=1.0): + params = b"".join(pack("B", p) if isinstance(p, int) else p for p in params) + print("REQUEST ", hex(handle), hex(devnumber), hex(id), params.hex()) + for r in responses: + if handle == r.handle and devnumber == r.devnumber and r.id == id and bytes.fromhex(r.params) == params: + print("RESPONSE", hex(r.handle), hex(r.devnumber), hex(r.id), r.params, r.response) + return bytes.fromhex(r.response) if r.response is not None else None + + @dataclass class Response: response: Optional[str] @@ -51,21 +66,8 @@ def replace_number(responses, number): # change the devnumber for a list of res return [Response(r.response, r.id, r.params, r.handle, number, r.no_reply) for r in responses] -def ping(responses, handle, devnumber, long_message=False): - print("PING ", hex(handle), hex(devnumber) if devnumber else devnumber) - for r in responses: - if handle == r.handle and devnumber == r.devnumber and r.id == 0x0010: - print("RESPONSE", hex(r.handle), hex(r.devnumber), r.response) - return r.response - - -def request(responses, handle, devnumber, id, *params, no_reply=False, return_error=False, long_message=False, protocol=1.0): - params = b"".join(pack("B", p) if isinstance(p, int) else p for p in params) - print("REQUEST ", hex(handle), hex(devnumber), hex(id), params.hex()) - for r in responses: - if handle == r.handle and devnumber == r.devnumber and r.id == id and bytes.fromhex(r.params) == params: - print("RESPONSE", hex(r.handle), hex(r.devnumber), hex(r.id), r.params, r.response) - return bytes.fromhex(r.response) if r.response is not None else None +def adjust_responses_index(index, responses): # change index-4 responses to index + return [Response(r.response, r.id - 0x400 + (index << 8), r.params, r.handle, r.devnumber, r.no_reply) for r in responses] r_empty = [ # a HID++ device with no responses except for ping @@ -87,18 +89,30 @@ r_keyboard_2 = [ # a HID++ 2.0 keyboard Response("030001", 0x0000, "0003"), # device information at 0x03 Response("040003", 0x0000, "0100"), # unknown 0100 at 0x04 Response("050003", 0x0000, "1B04"), # reprogrammable keys V4 at 0x05 + Response("060003", 0x0000, "0007"), # device friendly name at 0x06 + Response("070003", 0x0000, "0005"), # device name at 0x07 Response("08", 0x0100), # 8 features Response("00010001", 0x0110, "01"), # feature set at 0x01 Response("10000001", 0x0110, "02"), # battery status at 0x02 Response("00030001", 0x0110, "03"), # device information at 0x03 Response("01000003", 0x0110, "04"), # unknown 0100 at 0x04 Response("1B040003", 0x0110, "05"), # reprogrammable keys V4 at 0x05 + Response("00070003", 0x0000, "06"), # device friendly name at 0x06 + Response("00050003", 0x0000, "07"), # device name at 0x07 Response("0212345678000D1234567890ABAA01", 0x0300), # device information + Response("04", 0x0500), # reprogrammable keys V4 Response("00110012AB010203CD00", 0x0510, "00"), # reprogrammable keys V4 Response("01110022AB010203CD00", 0x0510, "01"), # reprogrammable keys V4 Response("00010111AB010203CD00", 0x0510, "02"), # reprogrammable keys V4 Response("03110032AB010204CD00", 0x0510, "03"), # reprogrammable keys V4 Response("00030333AB010203CD00", 0x0510, "04"), # reprogrammable keys V4 + Response("12", 0x0600), # friendly namme + Response("004142434445464748494A4B4C4D4E", 0x0610, "00"), + Response("0E4F50515253000000000000000000", 0x0610, "0E"), + Response("12", 0x0700), # name and kind + Response("4142434445464748494A4B4C4D4E4F", 0x0710, "00"), + Response("505152530000000000000000000000", 0x0710, "0F"), + Response("00", 0x0720), ] r_mouse_1 = [ # a HID++ 1.0 mouse @@ -130,7 +144,8 @@ r_mouse_3 = [ # a HID++ 2.0 mouse Response("444544000000000000000000000000", 0x0510, "0F"), # name - last 3 characters ] -responses_key = [ + +responses_key = [ # responses for Reprogrammable Keys V4 at 0x05 Response("08", 0x0500), # Reprogrammable Keys V4 count Response("00500038010001010400000000000000", 0x0510, "00"), # left button Response("00510039010001010400000000000000", 0x0510, "01"), # right button @@ -163,27 +178,18 @@ responses_key = [ Response("0051FF01005100", 0x0440, "0051FF01005100"), # right button set write ] -responses_XX = [ # a viable set of responses for Reprogrammable Keys V4 - Response(4.2, 0x0010), # ping - Response("010001", 0x0000, "0001"), # feature set at 0x01 - Response("020003", 0x0000, "1000"), # battery status at 0x02 - Response("030001", 0x0000, "0003"), # device information at 0x03 - Response("040003", 0x0000, "0100"), # unknown 0100 at 0x04 - Response("050003", 0x0000, "1B04"), # reprogrammable keys V4 at 0x05 - Response("08", 0x0100), # 8 features - Response("00010001", 0x0110, "01"), # feature set at 0x01 - Response("10000001", 0x0110, "02"), # battery status at 0x02 - Response("00030001", 0x0110, "03"), # device information at 0x03 - Response("01000003", 0x0110, "04"), # unknown 0100 at 0x04 - Response("1B040003", 0x0110, "05"), # reprogrammable keys V4 at 0x05 - Response("0212345678000D1234567890ABAA01", 0x0300), # device information - Response("05", 0x0500), # reprogrammable keys V4 - Response("00500038610000010100", 0x0510, "00"), # left button - Response("00510039600000010100", 0x0510, "01"), # right button - Response("0052003A110000020300", 0x0510, "02"), # middle button - Response("0053003C710101030700", 0x0510, "03"), # back button - Response("0056003E710102030700", 0x0510, "04"), # forward button -] +responses_remap = [ # responses for Persistent Remappable Actions at 0x04 and reprogrammable keys at 0x05 + Response("0041", 0x0400), + Response("03", 0x0410), + Response("0301", 0x0410, "00"), + Response("0050", 0x0420, "00FF"), + Response("0050000200010001", 0x0430, "0050FF"), # Left Button + Response("0051", 0x0420, "01FF"), + Response("0051000200010000", 0x0430, "0051FF"), # Left Button + Response("0052", 0x0420, "02FF"), + Response("0052000100510000", 0x0430, "0052FF"), # key DOWN + Response("050002", 0x0000, "1B04"), # REPROGRAMMABLE_KEYS_V4 +] + responses_key responses_gestures = [ # the commented-out messages are not used by either the setting or other testing Response("4203410141020400320480148C21A301", 0x0400, "0000"), # items @@ -233,8 +239,91 @@ responses_gestures = [ # the commented-out messages are not used by either the Response("000180FF", 0x0480, "000180FF"), # write param 0 ] +zone_responses_1 = [ # responses for COLOR LED EFFECTS + Response("00000102", 0x0710, "00FF00"), + Response("0000000300040005", 0x0720, "000000"), + Response("0001000B00080009", 0x0720, "000100"), +] +zone_responses_2 = [ # responses for RGB EFFECTS + Response("0000000102", 0x0700, "00FF00"), + Response("0000000300040005", 0x0700, "000000"), + Response("0001000200080009", 0x0700, "000100"), +] +effects_responses_1 = [Response("0100000001", 0x0700)] + zone_responses_1 +effects_responses_2 = [Response("FFFF0100000001", 0x0700, "FFFF00")] + zone_responses_2 + +responses_profiles = [ # OnboardProfile in RAM + Response("0104010101020100FE0200", 0x0900), + Response("000101FF", 0x0950, "00000000"), + Response("FFFFFFFF", 0x0950, "00000004"), + Response("01010290018003000700140028FFFFFF", 0x0950, "00010000"), + Response("FFFF0000000000000000000000000000", 0x0950, "00010010"), + Response("8000FFFF900aFF00800204548000FFFF", 0x0950, "00010020"), + Response("900aFF00800204548000FFFF900aFF00", 0x0950, "00010030"), + Response("800204548000FFFF900aFF0080020454", 0x0950, "00010040"), + Response("8000FFFF900aFF00800204548000FFFF", 0x0950, "00010050"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "00010060"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "00010070"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "00010080"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "00010090"), + Response("54004500370000000000000000000000", 0x0950, "000100A0"), + Response("00000000000000000000000000000000", 0x0950, "000100B0"), + Response("00000000000000000000000000000000", 0x0950, "000100C0"), + Response("0A01020300500407000000FFFFFFFFFF", 0x0950, "000100D0"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "000100E0"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFF7C81AB", 0x0950, "000100EE"), +] +responses_profiles_rom = [ # OnboardProfile in ROM + Response("0104010101020100FE0200", 0x0900), + Response("00000000", 0x0950, "00000000"), + Response("010101FF", 0x0950, "01000000"), + Response("FFFFFFFF", 0x0950, "01000004"), + Response("01010290018003000700140028FFFFFF", 0x0950, "01010000"), + Response("FFFF0000000000000000000000000000", 0x0950, "01010010"), + Response("8000FFFF900aFF00800204548000FFFF", 0x0950, "01010020"), + Response("900aFF00800204548000FFFF900aFF00", 0x0950, "01010030"), + Response("800204548000FFFF900aFF0080020454", 0x0950, "01010040"), + Response("8000FFFF900aFF00800204548000FFFF", 0x0950, "01010050"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "01010060"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "01010070"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "01010080"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "01010090"), + Response("54004500370000000000000000000000", 0x0950, "010100A0"), + Response("00000000000000000000000000000000", 0x0950, "010100B0"), + Response("00000000000000000000000000000000", 0x0950, "010100C0"), + Response("0A01020300500407000000FFFFFFFFFF", 0x0950, "010100D0"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0950, "010100E0"), + Response("FFFFFFFFFFFFFFFFFFFFFFFFFF7C81AB", 0x0950, "010100EE"), +] + +complex_responses_1 = [ # COLOR_LED_EFFECTS + Response(4.2, 0x0010), # ping + Response("010001", 0x0000, "0001"), # FEATURE SET at x01 + Response("0A", 0x0100), # 10 features + Response("070001", 0x0000, "8070"), # COLOR_LED_EFFECTS at 0x07 + *effects_responses_1, +] + +complex_responses_2 = [ # RGB_EFFECTS + reprogrammable keys + persistent actions + Response(4.2, 0x0010), # ping + Response("010001", 0x0000, "0001"), # FEATURE SET at x01 + Response("0A", 0x0100), # 10 features + Response("070001", 0x0000, "8071"), # RGB_EFFECTS at 0x07 + *effects_responses_2, + Response("040001", 0x0000, "1C00"), # Persistent Remappable Actions at 0x04 + *responses_remap, + Response("080001", 0x0000, "6501"), # Gestures at 0x08 + *adjust_responses_index(8, responses_gestures), + Response("060003", 0x0000, "1982"), # Backlight 2 at 0x06 + Response("010118000001020003000400", 0x0600), + Response("090003", 0x0000, "8100"), # Onboard Profiles at 0x09 + *responses_profiles, +] + responses_speedchange = [ Response("0100", 0x0400), + Response("010001", 0x0000, "0001"), # FEATURE SET at x01 + Response("0A", 0x0100), # 10 features Response("0120", 0x0410, "0120"), Response("050001", 0x0000, "1B04"), # REPROG_CONTROLS_V4 Response("01", 0x0500), @@ -269,9 +358,13 @@ class Device: led_effects = device.Device.led_effects gestures = device.Device.gestures __hash__ = device.Device.__hash__ + feature_request = device.Device.feature_request def __post_init__(self): + self._name = self.name + self._protocol = self.protocol self.persister = configuration._DeviceEntry() + self.features = hidpp20.FeaturesArray(self) self.settings = [] if self.feature is not None: self.features = hidpp20.FeaturesArray(self) @@ -281,20 +374,18 @@ class Device: self.setting_callback = lambda x, y, z: None self.add_notification_handler = lambda x, y: None - def request(self, id, *params, no_reply=False): - if params is None: - params = [] + def request(self, id, *params, no_reply=False, long_message=False, protocol=2.0): params = b"".join(pack("B", p) if isinstance(p, int) else p for p in params) - print("REQUEST ", self.name, hex(id), params.hex().upper()) + print("REQUEST ", self._name, hex(id), params.hex().upper()) for r in self.responses: if id == r.id and params == bytes.fromhex(r.params): - print("RESPONSE", self.name, hex(r.id), r.params, r.response) + print("RESPONSE", self._name, hex(r.id), r.params, r.response) return bytes.fromhex(r.response) if isinstance(r.response, str) else r.response - print("RESPONSE", self.name, None) + print("RESPONSE", self._name, None) - def feature_request(self, feature, function=0x00, *params, no_reply=False): - if self.protocol >= 2.0: - return hidpp20.feature_request(self, feature, function, *params, no_reply=no_reply) + def ping(self, handle=None, devnumber=None, long_message=False): + print("PING", self._protocol) + return self._protocol def match_requests(number, responses, call_args_list): diff --git a/tests/logitech_receiver/test_device.py b/tests/logitech_receiver/test_device.py index aae23f25..783fdedd 100644 --- a/tests/logitech_receiver/test_device.py +++ b/tests/logitech_receiver/test_device.py @@ -21,13 +21,15 @@ from unittest import mock import pytest +from logitech_receiver import common from logitech_receiver import device +from logitech_receiver import hidpp20 from . import hidpp @pytest.fixture -def mock_base(): +def mock_base(): # allow override of base functions with mock.patch("logitech_receiver.base.open_path", return_value=None) as mock_open_path: with mock.patch("logitech_receiver.base.request", return_value=None) as mock_request: with mock.patch("logitech_receiver.base.ping", return_value=None) as mock_ping: @@ -72,7 +74,29 @@ def test_DeviceFactory(device_info, responses, success, mock_base): @pytest.mark.parametrize( - "device_info, responses, handle, _name, _codename, number, protocol", + "device_info, responses, codename, name, kind", + [ + (di_CCCC, hidpp.r_empty, "?? (CCCC)", "Unknown device CCCC", "?"), + (di_C318, hidpp.r_keyboard_1, "?? (C318)", "Unknown device C318", "?"), + (di_B530, hidpp.r_keyboard_2, "ABCDEFGHIJKLMNOPQR", "ABCDEFGHIJKLMNOPQR", common.NamedInt(1, "keyboard")), + ], +) +def test_Device_name(device_info, responses, codename, name, kind, mock_base): + mock_base[0].side_effect = hidpp.open_path + mock_base[1].side_effect = partial(hidpp.request, responses) + mock_base[2].side_effect = partial(hidpp.ping, responses) + test_device = device.DeviceFactory.create_device(device_info) + test_device._codename = None + test_device._name = None + test_device._kind = None + + assert test_device.codename == codename + assert test_device.name == name + assert test_device.kind == kind + + +@pytest.mark.parametrize( + "device_info, responses, handle, _name, _codename, number, protocol, registers", zip( [di_CCCC, di_C318, di_B530, di_C068, di_C08A, di_DDDD], [hidpp.r_empty, hidpp.r_keyboard_1, hidpp.r_keyboard_2, hidpp.r_mouse_1, hidpp.r_mouse_2, hidpp.r_mouse_3], @@ -81,9 +105,10 @@ def test_DeviceFactory(device_info, responses, success, mock_base): [None, "Illuminated", "Craft", "G700", "MX Vertical", None], [0xFF, 0x0, 0xFF, 0x0, 0xFF, 0xFF], [1.0, 1.0, 4.5, 1.0, 4.5, 4.5], + [None, [], [], (common.NamedInt(7, "battery status"), common.NamedInt(81, "three leds")), [], None], ), ) -def test_Device_info(device_info, responses, handle, _name, _codename, number, protocol, mock_base): +def test_Device_info(device_info, responses, handle, _name, _codename, number, protocol, registers, mock_base): mock_base[0].side_effect = hidpp.open_path mock_base[1].side_effect = partial(hidpp.request, responses) mock_base[2].side_effect = partial(hidpp.ping, responses) @@ -95,6 +120,7 @@ def test_Device_info(device_info, responses, handle, _name, _codename, number, p assert test_device._codename == _codename assert test_device.number == number assert test_device._protocol == protocol + assert test_device.registers == registers assert bool(test_device) test_device.__del__() @@ -174,7 +200,7 @@ def test_Device_receiver(number, pairing_info, responses, handle, _name, codenam @pytest.mark.parametrize( - "number, pairing_info, responses, handle, unitId, modelId, tid_map, kind, firmware, serial, id, psl, rate", + "number, info, responses, handle, unitId, modelId, tid, kind, firmware, serial, id, psl, rate", zip( range(1, 7), [pi_CCCC, pi_2011, pi_4066, pi_1007, pi_407B, pi_DDDD], @@ -192,55 +218,77 @@ def test_Device_receiver(number, pairing_info, responses, handle, _name, codenam ), ) def test_Device_ids( - number, - pairing_info, - responses, - handle, - unitId, - modelId, - tid_map, - kind, - firmware, - serial, - id, - psl, - rate, - mock_base, - mock_hid, + number, info, responses, handle, unitId, modelId, tid, kind, firmware, serial, id, psl, rate, mock_base, mock_hid ): mock_base[0].side_effect = hidpp.open_path mock_base[1].side_effect = partial(hidpp.request, hidpp.replace_number(responses, number)) mock_base[2].side_effect = partial(hidpp.ping, hidpp.replace_number(responses, number)) mock_hid.side_effect = lambda x, y, z: x - test_device = device.Device(Receiver(), number, True, pairing_info, handle=handle) + test_device = device.Device(Receiver(), number, True, info, handle=handle) assert test_device.unitId == unitId assert test_device.modelId == modelId - assert test_device.tid_map == tid_map + assert test_device.tid_map == tid assert test_device.kind == kind - assert test_device.firmware == firmware or len(test_device.firmware) > 0 and firmware is True assert test_device.id == id assert test_device.power_switch_location == psl assert test_device.polling_rate == rate +class TestDevice(device.Device): # a fully functional Device but its HID++ functions look at local data + def __init__(self, responses, *args, **kwargs): + self.responses = responses + super().__init__(*args, **kwargs) + + request = hidpp.Device.request + ping = hidpp.Device.ping + + +@pytest.mark.parametrize( + "device_info, responses, protocol, led, keys, remap, gestures, backlight, profiles", + [ + (di_CCCC, hidpp.r_empty, 1.0, type(None), None, None, None, None, None), + (di_C318, hidpp.r_empty, 1.0, type(None), None, None, None, None, None), + (di_B530, hidpp.r_keyboard_1, 2.0, type(None), 0, 0, 0, None, None), + (di_B530, hidpp.complex_responses_1, 4.5, hidpp20.LEDEffectsInfo, 0, 0, 0, None, None), + (di_B530, hidpp.complex_responses_2, 4.5, hidpp20.RGBEffectsInfo, 8, 3, 1, True, True), + ], +) +def test_Device_complex(device_info, responses, protocol, led, keys, remap, gestures, backlight, profiles): + test_device = TestDevice(responses, None, None, online=True, device_info=device_info) + test_device._name = "TestDevice" + test_device._protocol = protocol + + assert type(test_device.led_effects) == led + if keys is None: + assert test_device.keys == keys + else: + assert len(test_device.keys) == keys + if remap is None: + assert test_device.remap_keys == remap + else: + assert len(test_device.remap_keys) == remap + assert (test_device.gestures is None) == (gestures is None) + assert (test_device.backlight is None) == (backlight is None) + assert (test_device.profiles is None) == (profiles is None) + + """ TODO -302-305 profiles -309-314 registers -318-337 settings -340-341 set configuration -344 reset -348-352 persister -355-368 battery -372-390 set_battery_info -394-396 read_battery -401-420 enable_connection_notifications -425-451 changed -465 add_notification_handler -470-473 remove_notification_handler -476-480 handle_notification + + settings + set configuration + reset + persister + battery + set_battery_info + read_battery + enable_connection_notifications + changed + add_notification_handler + remove_notification_handler + handle_notification """ # IMPORTANT TODO - battery diff --git a/tests/logitech_receiver/test_hidpp20_complex.py b/tests/logitech_receiver/test_hidpp20_complex.py index ce0c4db1..2c912f52 100644 --- a/tests/logitech_receiver/test_hidpp20_complex.py +++ b/tests/logitech_receiver/test_hidpp20_complex.py @@ -418,20 +418,6 @@ def test_KeysArrayV4_key(key, expected_index, expected_mapped_to, expected_remap assert list(remappable_to) == expected_remappable_to -responses_remap = [ - hidpp.Response("0041", 0x0400), - hidpp.Response("03", 0x0410), - hidpp.Response("0301", 0x0410, "00"), - hidpp.Response("0050", 0x0420, "00FF"), - hidpp.Response("0050000200010001", 0x0430, "0050FF"), # Left Button - hidpp.Response("0051", 0x0420, "01FF"), - hidpp.Response("0051000200010000", 0x0430, "0051FF"), # Left Button - hidpp.Response("0052", 0x0420, "02FF"), - hidpp.Response("0052000100510000", 0x0430, "0052FF"), # key DOWN - hidpp.Response("050002", 0x0000, "1B04"), # REPROGRAMMABLE_KEYS_V4 -] + hidpp.responses_key - - @pytest.mark.parametrize( "device, index", [(device_zerofeatures, -1), (device_zerofeatures, 5), (device_standard, -1), (device_standard, 6)] ) @@ -448,9 +434,9 @@ def test_KeysArrayPersistent_index_error(device, index): @pytest.mark.parametrize( "responses, key, index, mapped_to, capabilities", [ - (responses_remap, special_keys.CONTROL.Left_Button, 0, common.NamedInt(0x01, "Mouse Button Left"), 0x41), - (responses_remap, special_keys.CONTROL.Right_Button, 1, common.NamedInt(0x01, "Mouse Button Left"), 0x41), - (responses_remap, special_keys.CONTROL.Middle_Button, 2, common.NamedInt(0x51, "DOWN"), 0x41), + (hidpp.responses_remap, special_keys.CONTROL.Left_Button, 0, common.NamedInt(0x01, "Mouse Button Left"), 0x41), + (hidpp.responses_remap, special_keys.CONTROL.Right_Button, 1, common.NamedInt(0x01, "Mouse Button Left"), 0x41), + (hidpp.responses_remap, special_keys.CONTROL.Middle_Button, 2, common.NamedInt(0x51, "DOWN"), 0x41), ], ) def test_KeysArrayPersistent_key(responses, key, index, mapped_to, capabilities): @@ -672,27 +658,15 @@ def test_LEDEffectInfo(feature, function, response, ID, capabilities, period): assert info.period == period -zone_responses_1 = [ - hidpp.Response("00000102", 0x0410, "00FF00"), - hidpp.Response("0000000300040005", 0x0420, "000000"), - hidpp.Response("0001000B00080009", 0x0420, "000100"), -] -zone_responses_2 = [ - hidpp.Response("0000000102", 0x0400, "00FF00"), - hidpp.Response("0000000300040005", 0x0400, "000000"), - hidpp.Response("0001000200080009", 0x0400, "000100"), -] - - @pytest.mark.parametrize( "feature, function, offset, effect_function, responses, index, location, count, id_1", [ - [hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x10, 0, 0x20, zone_responses_1, 0, 1, 2, 0xB], - [hidpp20_constants.FEATURE.RGB_EFFECTS, 0x00, 1, 0x00, zone_responses_2, 0, 1, 2, 2], + [hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x10, 0, 0x20, hidpp.zone_responses_1, 0, 1, 2, 0xB], + [hidpp20_constants.FEATURE.RGB_EFFECTS, 0x00, 1, 0x00, hidpp.zone_responses_2, 0, 1, 2, 2], ], ) def test_LEDZoneInfo(feature, function, offset, effect_function, responses, index, location, count, id_1): - device = hidpp.Device(feature=feature, responses=responses) + device = hidpp.Device(feature=feature, responses=responses, offset=0x07) zone = hidpp20.LEDZoneInfo(feature, function, offset, effect_function, device, index) @@ -706,13 +680,13 @@ def test_LEDZoneInfo(feature, function, offset, effect_function, responses, inde @pytest.mark.parametrize( "responses, setting, expected_command", [ - [zone_responses_1, hidpp20.LEDEffectSetting(ID=0), None], - [zone_responses_1, hidpp20.LEDEffectSetting(ID=3, period=0x20, intensity=0x50), "000000000000000020500000"], - [zone_responses_1, hidpp20.LEDEffectSetting(ID=0xB, color=0x808080, period=0x20), "000180808000002000000000"], + [hidpp.zone_responses_1, hidpp20.LEDEffectSetting(ID=0), None], + [hidpp.zone_responses_1, hidpp20.LEDEffectSetting(ID=3, period=0x20, intensity=0x50), "000000000000000020500000"], + [hidpp.zone_responses_1, hidpp20.LEDEffectSetting(ID=0xB, color=0x808080, period=0x20), "000180808000002000000000"], ], ) def test_LEDZoneInfo_to_command(responses, setting, expected_command): - device = hidpp.Device(feature=hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, responses=responses) + device = hidpp.Device(feature=hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, responses=responses, offset=0x07) zone = hidpp20.LEDZoneInfo(hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x10, 0, 0x20, device, 0) command = zone.to_command(setting) @@ -720,19 +694,15 @@ def test_LEDZoneInfo_to_command(responses, setting, expected_command): assert command == (bytes.fromhex(expected_command) if expected_command is not None else None) -effects_responses_1 = [hidpp.Response("0100000001", 0x0400)] + zone_responses_1 -effects_responses_2 = [hidpp.Response("FFFF0100000001", 0x0400, "FFFF00")] + zone_responses_2 - - @pytest.mark.parametrize( "feature, cls, responses, readable, count, count_0", [ - [hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, hidpp20.LEDEffectsInfo, effects_responses_1, 1, 1, 2], - [hidpp20_constants.FEATURE.RGB_EFFECTS, hidpp20.RGBEffectsInfo, effects_responses_2, 1, 1, 2], + [hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, hidpp20.LEDEffectsInfo, hidpp.effects_responses_1, 1, 1, 2], + [hidpp20_constants.FEATURE.RGB_EFFECTS, hidpp20.RGBEffectsInfo, hidpp.effects_responses_2, 1, 1, 2], ], ) def test_LED_RGB_EffectsInfo(feature, cls, responses, readable, count, count_0): - device = hidpp.Device(feature=feature, responses=responses) + device = hidpp.Device(feature=feature, responses=responses, offset=0x07) effects = cls(device) @@ -827,60 +797,15 @@ def test_OnboardProfile_bytes(hex, name, sector, enabled, buttons, gbuttons, res assert yaml.safe_load(yaml.dump(profile)).to_bytes(len(hex) // 2).hex().upper() == hex -responses_profiles = [ - hidpp.Response("0104010101020100FE0200", 0x0400), - hidpp.Response("000101FF", 0x0450, "00000000"), - hidpp.Response("FFFFFFFF", 0x0450, "00000004"), - hidpp.Response("01010290018003000700140028FFFFFF", 0x0450, "00010000"), - hidpp.Response("FFFF0000000000000000000000000000", 0x0450, "00010010"), - hidpp.Response("8000FFFF900aFF00800204548000FFFF", 0x0450, "00010020"), - hidpp.Response("900aFF00800204548000FFFF900aFF00", 0x0450, "00010030"), - hidpp.Response("800204548000FFFF900aFF0080020454", 0x0450, "00010040"), - hidpp.Response("8000FFFF900aFF00800204548000FFFF", 0x0450, "00010050"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "00010060"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "00010070"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "00010080"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "00010090"), - hidpp.Response("54004500370000000000000000000000", 0x0450, "000100A0"), - hidpp.Response("00000000000000000000000000000000", 0x0450, "000100B0"), - hidpp.Response("00000000000000000000000000000000", 0x0450, "000100C0"), - hidpp.Response("0A01020300500407000000FFFFFFFFFF", 0x0450, "000100D0"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "000100E0"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFF7C81AB", 0x0450, "000100EE"), -] -responses_profiles_rom = [ - hidpp.Response("0104010101020100FE0200", 0x0400), - hidpp.Response("00000000", 0x0450, "00000000"), - hidpp.Response("010101FF", 0x0450, "01000000"), - hidpp.Response("FFFFFFFF", 0x0450, "01000004"), - hidpp.Response("01010290018003000700140028FFFFFF", 0x0450, "01010000"), - hidpp.Response("FFFF0000000000000000000000000000", 0x0450, "01010010"), - hidpp.Response("8000FFFF900aFF00800204548000FFFF", 0x0450, "01010020"), - hidpp.Response("900aFF00800204548000FFFF900aFF00", 0x0450, "01010030"), - hidpp.Response("800204548000FFFF900aFF0080020454", 0x0450, "01010040"), - hidpp.Response("8000FFFF900aFF00800204548000FFFF", 0x0450, "01010050"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "01010060"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "01010070"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "01010080"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "01010090"), - hidpp.Response("54004500370000000000000000000000", 0x0450, "010100A0"), - hidpp.Response("00000000000000000000000000000000", 0x0450, "010100B0"), - hidpp.Response("00000000000000000000000000000000", 0x0450, "010100C0"), - hidpp.Response("0A01020300500407000000FFFFFFFFFF", 0x0450, "010100D0"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0450, "010100E0"), - hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFF7C81AB", 0x0450, "010100EE"), -] - - @pytest.mark.parametrize( "responses, name, count, buttons, gbuttons, sectors, size", [ - (responses_profiles, "ONB", 1, 2, 2, 1, 254), - (responses_profiles_rom, "ONB", 1, 2, 2, 1, 254), + (hidpp.responses_profiles, "ONB", 1, 2, 2, 1, 254), + (hidpp.responses_profiles_rom, "ONB", 1, 2, 2, 1, 254), ], ) def test_OnboardProfiles_device(responses, name, count, buttons, gbuttons, sectors, size): - device = hidpp.Device(name, True, 4.5, responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES) + device = hidpp.Device(name, True, 4.5, responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES, offset=0x9) device._profiles = None profiles = _hidpp20.get_profiles(device) diff --git a/tests/logitech_receiver/test_setting_templates.py b/tests/logitech_receiver/test_setting_templates.py index a6197237..84fcf090 100644 --- a/tests/logitech_receiver/test_setting_templates.py +++ b/tests/logitech_receiver/test_setting_templates.py @@ -348,6 +348,7 @@ simple_tests = [ Setup( FeatureTest(settings_templates.OnboardProfiles, 0, 1, offset=0x0C), common.NamedInts(**{"Disabled": 0, "Profile 1": 1, "Profile 2": 2}), + hidpp.Response("01030001010101000101", 0x0C00), hidpp.Response("00010100000201FFFFFFFFFFFFFFFFFF", 0x0C50, "00000000"), hidpp.Response("000201FFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000004"), hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000008"), @@ -358,6 +359,7 @@ simple_tests = [ Setup( FeatureTest(settings_templates.OnboardProfiles, 1, 0, offset=0x0C), common.NamedInts(**{"Disabled": 0, "Profile 1": 1, "Profile 2": 2}), + hidpp.Response("01030001010101000101", 0x0C00), hidpp.Response("00010100000201FFFFFFFFFFFFFFFFFF", 0x0C50, "00000000"), hidpp.Response("000201FFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000004"), hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000008"),