RomanNum3ral
/
Solaar
mirror of https://github.com/pwr-Solaar/Solaar.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clarify that fake hidpp is used 

This module shouldn't be necessary on the long run. Remove pieces from
it whenever possible.
This commit is contained in:
MattHag 2024-09-15 16:43:26 +02:00 committed by Peter F. Patel-Schneider
parent 3c1aa35067
commit 741c0861c2
6 changed files with 576 additions and 510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
tests/logitech_receiver/hidpp.py → tests/logitech_receiver/fake_hidpp.py
View File

97
tests/logitech_receiver/test_device.py
View File

@ -25,7 +25,7 @@ from logitech_receiver import common
from logitech_receiver import device
from logitech_receiver import hidpp20
from . import hidpp
from . import fake_hidpp
class LowLevelInterfaceFake:
@ -33,14 +33,14 @@ class LowLevelInterfaceFake:
self.responses = responses
def open_path(self, path):
return hidpp.open_path(path)
return fake_hidpp.open_path(path)
def request(self, response, *args, **kwargs):
func = partial(hidpp.request, self.responses)
func = partial(fake_hidpp.request, self.responses)
return func(response, *args, **kwargs)
def ping(self, response, *args, **kwargs):
func = partial(hidpp.ping, self.responses)
func = partial(fake_hidpp.ping, self.responses)
return func(response, *args, **kwargs)
def close(self, *args, **kwargs):
@ -70,7 +70,11 @@ di_DDDD = DeviceInfoStub("11", product_id="DDDD")
@pytest.mark.parametrize(
"device_info, responses, expected_success",
[(di_bad_handle, hidpp.r_empty, None), (di_error, hidpp.r_empty, False), (di_CCCC, hidpp.r_empty, True)],
[
(di_bad_handle, fake_hidpp.r_empty, None),
(di_error, fake_hidpp.r_empty, False),
(di_CCCC, fake_hidpp.r_empty, True),
],
)
def test_create_device(device_info, responses, expected_success):
low_level_mock = LowLevelInterfaceFake(responses)
@ -87,7 +91,7 @@ def test_create_device(device_info, responses, expected_success):
@pytest.mark.parametrize(
"device_info, responses, expected_codename, expected_name, expected_kind",
[(di_CCCC, hidpp.r_empty, "?? (CCCC)", "Unknown device CCCC", "?")],
[(di_CCCC, fake_hidpp.r_empty, "?? (CCCC)", "Unknown device CCCC", "?")],
)
def test_device_name(device_info, responses, expected_codename, expected_name, expected_kind):
low_level = LowLevelInterfaceFake(responses)
@ -103,7 +107,14 @@ def test_device_name(device_info, responses, expected_codename, expected_name, e
"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],
[
fake_hidpp.r_empty,
fake_hidpp.r_keyboard_1,
fake_hidpp.r_keyboard_2,
fake_hidpp.r_mouse_1,
fake_hidpp.r_mouse_2,
fake_hidpp.r_mouse_3,
],
[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
[None, "Illuminated Keyboard", "Craft Advanced Keyboard", "G700 Gaming Mouse", "MX Vertical Wireless Mouse", None],
[None, "Illuminated", "Craft", "G700", "MX Vertical", None],
@ -160,7 +171,14 @@ pi_DDDD = {"wpid": "DDDD", "kind": 2, "serial": "1234", "polling": "2ms", "power
zip(
range(1, 7),
[pi_CCCC, pi_2011, pi_4066, pi_1007, pi_407B, pi_DDDD],
[hidpp.r_empty, hidpp.r_keyboard_1, hidpp.r_keyboard_2, hidpp.r_mouse_1, hidpp.r_mouse_2, hidpp.r_mouse_3],
[
fake_hidpp.r_empty,
fake_hidpp.r_keyboard_1,
fake_hidpp.r_keyboard_2,
fake_hidpp.r_mouse_1,
fake_hidpp.r_mouse_2,
fake_hidpp.r_mouse_3,
],
[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
[None, "Wireless Keyboard K520", "Craft Advanced Keyboard", "MX Air", "MX Vertical Wireless Mouse", None],
["CODE", "K520", "Craft", "MX Air", "MX Vertical", "CODE"],
@ -180,8 +198,8 @@ def test_device_receiver(number, pairing_info, responses, handle, _name, codenam
mock_hid.side_effect = lambda x, y, z: x
low_level = LowLevelInterfaceFake(responses)
low_level.request = partial(hidpp.request, hidpp.replace_number(responses, number))
low_level.ping = partial(hidpp.ping, hidpp.replace_number(responses, number))
low_level.request = partial(fake_hidpp.request, fake_hidpp.replace_number(responses, number))
low_level.ping = partial(fake_hidpp.ping, fake_hidpp.replace_number(responses, number))
test_device = device.Device(low_level, FakeReceiver(codename="CODE"), number, True, pairing_info, handle=handle)
test_device.receiver.device = test_device
@ -207,7 +225,14 @@ def test_device_receiver(number, pairing_info, responses, handle, _name, codenam
zip(
range(1, 7),
[pi_CCCC, pi_2011, pi_4066, pi_1007, pi_407B, pi_DDDD],
[hidpp.r_empty, hidpp.r_keyboard_1, hidpp.r_keyboard_2, hidpp.r_mouse_1, hidpp.r_mouse_2, hidpp.r_mouse_3],
[
fake_hidpp.r_empty,
fake_hidpp.r_keyboard_1,
fake_hidpp.r_keyboard_2,
fake_hidpp.r_mouse_1,
fake_hidpp.r_mouse_2,
fake_hidpp.r_mouse_3,
],
[None, 0x11, 0x11, 0x11, 0x11, 0x11],
[None, None, "12345678", None, None, "12345679"], # unitId
[None, None, "1234567890AB", None, None, "123456780000"], # modelId
@ -224,8 +249,8 @@ def test_device_ids(number, info, responses, handle, unitId, modelId, tid, kind,
mock_hid.side_effect = lambda x, y, z: x
low_level = LowLevelInterfaceFake(responses)
low_level.request = partial(hidpp.request, hidpp.replace_number(responses, number))
low_level.ping = partial(hidpp.ping, hidpp.replace_number(responses, number))
low_level.request = partial(fake_hidpp.request, fake_hidpp.replace_number(responses, number))
low_level.ping = partial(fake_hidpp.ping, fake_hidpp.replace_number(responses, number))
test_device = device.Device(low_level, FakeReceiver(), number, True, info, handle=handle)
@ -244,19 +269,19 @@ class FakeDevice(device.Device): # a fully functional Device but its HID++ func
self.responses = responses
super().__init__(LowLevelInterfaceFake(responses), *args, **kwargs)
request = hidpp.Device.request
ping = hidpp.Device.ping
request = fake_hidpp.Device.request
ping = fake_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, 1.0, type(None), None, None, None, None, None),
(di_B530, hidpp.r_keyboard_2, 2.0, type(None), 4, 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),
(di_CCCC, fake_hidpp.r_empty, 1.0, type(None), None, None, None, None, None),
(di_C318, fake_hidpp.r_empty, 1.0, type(None), None, None, None, None, None),
(di_B530, fake_hidpp.r_keyboard_1, 1.0, type(None), None, None, None, None, None),
(di_B530, fake_hidpp.r_keyboard_2, 2.0, type(None), 4, 0, 0, None, None),
(di_B530, fake_hidpp.complex_responses_1, 4.5, hidpp20.LEDEffectsInfo, 0, 0, 0, None, None),
(di_B530, fake_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, mocker):
@ -289,12 +314,12 @@ def test_device_complex(device_info, responses, protocol, led, keys, remap, gest
@pytest.mark.parametrize(
"device_info, responses, protocol, p, persister, settings",
[
(di_CCCC, hidpp.r_empty, 1.0, None, None, 0),
(di_C318, hidpp.r_empty, 1.0, {}, {}, 0),
(di_C318, hidpp.r_keyboard_1, 1.0, {"n": "n"}, {"n": "n"}, 1),
(di_B530, hidpp.r_keyboard_2, 4.5, {"m": "m"}, {"m": "m"}, 1),
(di_C068, hidpp.r_mouse_1, 1.0, {"o": "o"}, {"o": "o"}, 2),
(di_C08A, hidpp.r_mouse_2, 4.5, {"p": "p"}, {"p": "p"}, 0),
(di_CCCC, fake_hidpp.r_empty, 1.0, None, None, 0),
(di_C318, fake_hidpp.r_empty, 1.0, {}, {}, 0),
(di_C318, fake_hidpp.r_keyboard_1, 1.0, {"n": "n"}, {"n": "n"}, 1),
(di_B530, fake_hidpp.r_keyboard_2, 4.5, {"m": "m"}, {"m": "m"}, 1),
(di_C068, fake_hidpp.r_mouse_1, 1.0, {"o": "o"}, {"o": "o"}, 2),
(di_C08A, fake_hidpp.r_mouse_2, 4.5, {"p": "p"}, {"p": "p"}, 0),
],
)
def test_device_settings(device_info, responses, protocol, p, persister, settings, mocker):
@ -310,9 +335,21 @@ def test_device_settings(device_info, responses, protocol, p, persister, setting
@pytest.mark.parametrize(
"device_info, responses, protocol, battery, changed",
[
(di_C318, hidpp.r_empty, 1.0, None, {"active": True, "alert": 0, "reason": None}),
(di_C318, hidpp.r_keyboard_1, 1.0, common.Battery(50, None, 0, None), {"active": True, "alert": 0, "reason": None}),
(di_B530, hidpp.r_keyboard_2, 4.5, common.Battery(18, 52, None, None), {"active": True, "alert": 0, "reason": None}),
(di_C318, fake_hidpp.r_empty, 1.0, None, {"active": True, "alert": 0, "reason": None}),
(
di_C318,
fake_hidpp.r_keyboard_1,
1.0,
common.Battery(50, None, 0, None),
{"active": True, "alert": 0, "reason": None},
),
(
di_B530,
fake_hidpp.r_keyboard_2,
4.5,
common.Battery(18, 52, None, None),
{"active": True, "alert": 0, "reason": None},
),
],
)
def test_device_battery(device_info, responses, protocol, battery, changed, mocker):

155
tests/logitech_receiver/test_hidpp20_complex.py
View File

@ -23,16 +23,18 @@ from logitech_receiver import hidpp20
from logitech_receiver import hidpp20_constants
from logitech_receiver import special_keys
from . import hidpp
from . import fake_hidpp
_hidpp20 = hidpp20.Hidpp20()
device_offline = hidpp.Device("REGISTERS", False)
device_registers = hidpp.Device("OFFLINE", True, 1.0)
device_nofeatures = hidpp.Device("NOFEATURES", True, 4.5)
device_zerofeatures = hidpp.Device("ZEROFEATURES", True, 4.5, [hidpp.Response("0000", 0x0000, "0001")])
device_broken = hidpp.Device("BROKEN", True, 4.5, [hidpp.Response("0500", 0x0000, "0001"), hidpp.Response(None, 0x0100)])
device_standard = hidpp.Device("STANDARD", True, 4.5, hidpp.r_keyboard_2)
device_offline = fake_hidpp.Device("REGISTERS", False)
device_registers = fake_hidpp.Device("OFFLINE", True, 1.0)
device_nofeatures = fake_hidpp.Device("NOFEATURES", True, 4.5)
device_zerofeatures = fake_hidpp.Device("ZEROFEATURES", True, 4.5, [fake_hidpp.Response("0000", 0x0000, "0001")])
device_broken = fake_hidpp.Device(
"BROKEN", True, 4.5, [fake_hidpp.Response("0500", 0x0000, "0001"), fake_hidpp.Response(None, 0x0100)]
)
device_standard = fake_hidpp.Device("STANDARD", True, 4.5, fake_hidpp.r_keyboard_2)
@pytest.mark.parametrize(
@ -210,15 +212,15 @@ def test_ReprogrammableKeyV4_key(device, index, cid, tid, flags, pos, group, gma
@pytest.mark.parametrize(
"responses, index, mapped_to, remappable_to, mapping_flags",
[
(hidpp.responses_key, 1, "Right Click", common.UnsortedNamedInts(Right_Click=81, Left_Click=80), []),
(hidpp.responses_key, 2, "Left Click", None, ["diverted"]),
(hidpp.responses_key, 3, "Mouse Back Button", None, ["diverted", "persistently diverted"]),
(hidpp.responses_key, 4, "Mouse Forward Button", None, ["diverted", "raw XY diverted"]),
(fake_hidpp.responses_key, 1, "Right Click", common.UnsortedNamedInts(Right_Click=81, Left_Click=80), []),
(fake_hidpp.responses_key, 2, "Left Click", None, ["diverted"]),
(fake_hidpp.responses_key, 3, "Mouse Back Button", None, ["diverted", "persistently diverted"]),
(fake_hidpp.responses_key, 4, "Mouse Forward Button", None, ["diverted", "raw XY diverted"]),
],
)
# these fields need access all the key data, so start by setting up a device and its key data
def test_ReprogrammableKeyV4_query(responses, index, mapped_to, remappable_to, mapping_flags):
device = hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
device = fake_hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
device._keys = _hidpp20.get_keys(device)
key = device.keys[index]
@ -231,15 +233,15 @@ def test_ReprogrammableKeyV4_query(responses, index, mapped_to, remappable_to, m
@pytest.mark.parametrize(
"responses, index, diverted, persistently_diverted, rawXY_reporting, remap, sets",
[
(hidpp.responses_key, 1, True, False, True, 0x52, ["0051080000"]),
(hidpp.responses_key, 2, False, True, False, 0x51, ["0052020000", "0052200000", "0052000051"]),
(hidpp.responses_key, 3, False, True, True, 0x50, ["0053020000", "00530C0000", "0053300000", "0053000050"]),
(hidpp.responses_key, 4, False, False, False, 0x50, ["0056020000", "0056080000", "0056200000", "0056000050"]),
(fake_hidpp.responses_key, 1, True, False, True, 0x52, ["0051080000"]),
(fake_hidpp.responses_key, 2, False, True, False, 0x51, ["0052020000", "0052200000", "0052000051"]),
(fake_hidpp.responses_key, 3, False, True, True, 0x50, ["0053020000", "00530C0000", "0053300000", "0053000050"]),
(fake_hidpp.responses_key, 4, False, False, False, 0x50, ["0056020000", "0056080000", "0056200000", "0056000050"]),
],
)
def test_ReprogrammableKeyV4_set(responses, index, diverted, persistently_diverted, rawXY_reporting, remap, sets, mocker):
responses += [hidpp.Response(r, 0x530, r) for r in sets]
device = hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
responses += [fake_hidpp.Response(r, 0x530, r) for r in sets]
device = fake_hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
device._keys = _hidpp20.get_keys(device)
device._keys._ensure_all_keys_queried() # do this now so that the last requests are sets
spy_request = mocker.spy(device, "request")
@ -275,23 +277,26 @@ def test_ReprogrammableKeyV4_set(responses, index, diverted, persistently_divert
key.remap(remap)
assert (key.mapped_to == remap) or (remap not in key.remappable_to and remap != 0)
hidpp.match_requests(len(sets), responses, spy_request.call_args_list)
fake_hidpp.match_requests(len(sets), responses, spy_request.call_args_list)
@pytest.mark.parametrize(
"r, index, cid, actionId, remapped, mask, status, action, modifiers, byts, remap",
[
(hidpp.responses_key, 1, 0x0051, 0x02, 0x0002, 0x01, 0, "Mouse Button: 2", "Cntrl+", "02000201", "01000400"),
(hidpp.responses_key, 2, 0x0052, 0x01, 0x0001, 0x00, 1, "Key: 1", "", "01000100", "02005004"),
(hidpp.responses_key, 3, 0x0053, 0x02, 0x0001, 0x00, 1, "Mouse Button: 1", "", "02000100", "7FFFFFFF"),
(fake_hidpp.responses_key, 1, 0x0051, 0x02, 0x0002, 0x01, 0, "Mouse Button: 2", "Cntrl+", "02000201", "01000400"),
(fake_hidpp.responses_key, 2, 0x0052, 0x01, 0x0001, 0x00, 1, "Key: 1", "", "01000100", "02005004"),
(fake_hidpp.responses_key, 3, 0x0053, 0x02, 0x0001, 0x00, 1, "Mouse Button: 1", "", "02000100", "7FFFFFFF"),
],
)
def test_RemappableAction(r, index, cid, actionId, remapped, mask, status, action, modifiers, byts, remap, mocker):
if int(remap, 16) == special_keys.KEYS_Default:
responses = r + [hidpp.Response("040000", 0x0000, "1C00"), hidpp.Response("00", 0x450, f"{cid:04X}" + "FF")]
responses = r + [fake_hidpp.Response("040000", 0x0000, "1C00"), fake_hidpp.Response("00", 0x450, f"{cid:04X}" + "FF")]
else:
responses = r + [hidpp.Response("040000", 0x0000, "1C00"), hidpp.Response("00", 0x440, f"{cid:04X}" + "FF" + remap)]
device = hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
responses = r + [
fake_hidpp.Response("040000", 0x0000, "1C00"),
fake_hidpp.Response("00", 0x440, f"{cid:04X}" + "FF" + remap),
]
device = fake_hidpp.Device("KEY", responses=responses, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
key = hidpp20.PersistentRemappableAction(device, index, cid, actionId, remapped, mask, status)
spy_request = mocker.spy(device, "request")
@ -312,7 +317,7 @@ def test_RemappableAction(r, index, cid, actionId, remapped, mask, status, actio
assert key.data_bytes.hex().upper() == (byts if int(remap, 16) == special_keys.KEYS_Default else remap)
if int(remap, 16) != special_keys.KEYS_Default:
hidpp.match_requests(1, responses, spy_request.call_args_list)
fake_hidpp.match_requests(1, responses, spy_request.call_args_list)
# KeysArray methods tested in KeysArrayV4
@ -378,7 +383,9 @@ def test_KeysArrayV4_index(key, index):
assert result == index
device_key = hidpp.Device("KEY", responses=hidpp.responses_key, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5)
device_key = fake_hidpp.Device(
"KEY", responses=fake_hidpp.responses_key, feature=hidpp20_constants.FEATURE.REPROG_CONTROLS_V4, offset=5
)
@pytest.mark.parametrize(
@ -434,13 +441,13 @@ def test_KeysArrayPersistent_index_error(device, index):
@pytest.mark.parametrize(
"responses, key, index, mapped_to, capabilities",
[
(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),
(fake_hidpp.responses_remap, special_keys.CONTROL.Left_Button, 0, common.NamedInt(0x01, "Mouse Button Left"), 0x41),
(fake_hidpp.responses_remap, special_keys.CONTROL.Right_Button, 1, common.NamedInt(0x01, "Mouse Button Left"), 0x41),
(fake_hidpp.responses_remap, special_keys.CONTROL.Middle_Button, 2, common.NamedInt(0x51, "DOWN"), 0x41),
],
)
def test_KeysArrayPersistent_key(responses, key, index, mapped_to, capabilities):
device = hidpp.Device("REMAP", responses=responses, feature=hidpp20_constants.FEATURE.PERSISTENT_REMAPPABLE_ACTION)
device = fake_hidpp.Device("REMAP", responses=responses, feature=hidpp20_constants.FEATURE.PERSISTENT_REMAPPABLE_ACTION)
device._remap_keys = _hidpp20.get_remap_keys(device)
device._remap_keys._ensure_all_keys_queried()
@ -494,13 +501,13 @@ def test_Gesture(device, low, high, next_index, next_diversion_index, name, cbe,
@pytest.mark.parametrize(
"responses, gest, enabled, diverted, set_result, unset_result, divert_result, undivert_result",
[
(hidpp.responses_gestures, 20, None, None, None, None, None, None),
(hidpp.responses_gestures, 1, True, False, "01", "00", "01", "00"),
(hidpp.responses_gestures, 45, False, None, "01", "00", None, None),
(fake_hidpp.responses_gestures, 20, None, None, None, None, None, None),
(fake_hidpp.responses_gestures, 1, True, False, "01", "00", "01", "00"),
(fake_hidpp.responses_gestures, 45, False, None, "01", "00", None, None),
],
)
def test_Gesture_set(responses, gest, enabled, diverted, set_result, unset_result, divert_result, undivert_result):
device = hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
device = fake_hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
gestures = _hidpp20.get_gestures(device)
gesture = gestures.gesture(gest)
@ -516,11 +523,11 @@ def test_Gesture_set(responses, gest, enabled, diverted, set_result, unset_resul
@pytest.mark.parametrize(
"responses, prm, id, index, size, value, default_value, write1, write2",
[
(hidpp.responses_gestures, 4, common.NamedInt(4, "ScaleFactor"), 0, 2, 256, 256, "0080", "0180"),
(fake_hidpp.responses_gestures, 4, common.NamedInt(4, "ScaleFactor"), 0, 2, 256, 256, "0080", "0180"),
],
)
def test_Param(responses, prm, id, index, size, value, default_value, write1, write2):
device = hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
device = fake_hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
gestures = _hidpp20.get_gestures(device)
param = gestures.param(prm)
@ -539,13 +546,13 @@ def test_Param(responses, prm, id, index, size, value, default_value, write1, wr
@pytest.mark.parametrize(
"responses, id, s, byte_count, value, string",
[
(hidpp.responses_gestures, 1, "DVI field width", 1, 8, "[DVI field width=8]"),
(hidpp.responses_gestures, 2, "field widths", 1, 8, "[field widths=8]"),
(hidpp.responses_gestures, 3, "period unit", 2, 2048, "[period unit=2048]"),
(fake_hidpp.responses_gestures, 1, "DVI field width", 1, 8, "[DVI field width=8]"),
(fake_hidpp.responses_gestures, 2, "field widths", 1, 8, "[field widths=8]"),
(fake_hidpp.responses_gestures, 3, "period unit", 2, 2048, "[period unit=2048]"),
],
)
def test_Spec(responses, id, s, byte_count, value, string):
device = hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
device = fake_hidpp.Device("GESTURE", responses=responses, feature=hidpp20_constants.FEATURE.GESTURE_2)
gestures = _hidpp20.get_gestures(device)
spec = gestures.specs[id]
@ -558,7 +565,9 @@ def test_Spec(responses, id, s, byte_count, value, string):
def test_Gestures():
device = hidpp.Device("GESTURES", responses=hidpp.responses_gestures, feature=hidpp20_constants.FEATURE.GESTURE_2)
device = fake_hidpp.Device(
"GESTURES", responses=fake_hidpp.responses_gestures, feature=hidpp20_constants.FEATURE.GESTURE_2
)
gestures = _hidpp20.get_gestures(device)
assert gestures
@ -584,11 +593,11 @@ def test_Gestures():
responses_backlight = [
hidpp.Response("010118000001020003000400", 0x0400),
hidpp.Response("0101FF00020003000400", 0x0410, "0101FF00020003000400"),
fake_hidpp.Response("010118000001020003000400", 0x0400),
fake_hidpp.Response("0101FF00020003000400", 0x0410, "0101FF00020003000400"),
]
device_backlight = hidpp.Device("BACKLIGHT", responses=responses_backlight, feature=hidpp20_constants.FEATURE.BACKLIGHT2)
device_backlight = fake_hidpp.Device("BACKLIGHT", responses=responses_backlight, feature=hidpp20_constants.FEATURE.BACKLIGHT2)
def test_Backlight():
@ -642,12 +651,26 @@ def test_LEDEffectSetting(hex, ID, color, speed, period, intensity, ramp, form):
@pytest.mark.parametrize(
"feature, function, response, ID, capabilities, period",
[
[hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x20, hidpp.Response("0102000300040005", 0x0420, "010200"), 3, 4, 5],
[hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x20, hidpp.Response("0102000700080009", 0x0420, "010200"), 7, 8, 9],
[
hidpp20_constants.FEATURE.COLOR_LED_EFFECTS,
0x20,
fake_hidpp.Response("0102000300040005", 0x0420, "010200"),
3,
4,
5,
],
[
hidpp20_constants.FEATURE.COLOR_LED_EFFECTS,
0x20,
fake_hidpp.Response("0102000700080009", 0x0420, "010200"),
7,
8,
9,
],
],
)
def test_LEDEffectInfo(feature, function, response, ID, capabilities, period):
device = hidpp.Device(feature=feature, responses=[response])
device = fake_hidpp.Device(feature=feature, responses=[response])
info = hidpp20.LEDEffectInfo(feature, function, device, 1, 2)
@ -661,12 +684,12 @@ def test_LEDEffectInfo(feature, function, response, ID, capabilities, period):
@pytest.mark.parametrize(
"feature, function, offset, effect_function, responses, index, location, count, id_1",
[
[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],
[hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, 0x10, 0, 0x20, fake_hidpp.zone_responses_1, 0, 1, 2, 0xB],
[hidpp20_constants.FEATURE.RGB_EFFECTS, 0x00, 1, 0x00, fake_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, offset=0x07)
device = fake_hidpp.Device(feature=feature, responses=responses, offset=0x07)
zone = hidpp20.LEDZoneInfo(feature, function, offset, effect_function, device, index)
@ -680,13 +703,17 @@ def test_LEDZoneInfo(feature, function, offset, effect_function, responses, inde
@pytest.mark.parametrize(
"responses, setting, expected_command",
[
[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"],
[fake_hidpp.zone_responses_1, hidpp20.LEDEffectSetting(ID=0), None],
[fake_hidpp.zone_responses_1, hidpp20.LEDEffectSetting(ID=3, period=0x20, intensity=0x50), "000000000000000020500000"],
[
fake_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, offset=0x07)
device = fake_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)
@ -697,12 +724,12 @@ def test_LEDZoneInfo_to_command(responses, setting, expected_command):
@pytest.mark.parametrize(
"feature, cls, responses, readable, count, count_0",
[
[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],
[hidpp20_constants.FEATURE.COLOR_LED_EFFECTS, hidpp20.LEDEffectsInfo, fake_hidpp.effects_responses_1, 1, 1, 2],
[hidpp20_constants.FEATURE.RGB_EFFECTS, hidpp20.RGBEffectsInfo, fake_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, offset=0x07)
device = fake_hidpp.Device(feature=feature, responses=responses, offset=0x07)
effects = cls(device)
@ -721,7 +748,7 @@ def test_LED_RGB_EffectsInfo(feature, cls, responses, readable, count, count_0):
("80020454", 0x8, None, None, 0x02, 0x54, 0x04, None, None),
("80030454", 0x8, None, None, 0x03, 0x0454, None, None, None),
("900AFF01", 0x9, None, None, None, 0x0A, None, 0x01, None),
("709090A0", 0x7, None, None, None, None, None, None, b"\x70\x90\x90\xA0"),
("709090A0", 0x7, None, None, None, None, None, None, b"\x70\x90\x90\xa0"),
],
)
def test_button_bytes(hex, behavior, sector, address, typ, val, modifiers, data, byt):
@ -820,13 +847,15 @@ def test_OnboardProfile_bytes(hex, name, sector, enabled, buttons, gbuttons, res
@pytest.mark.parametrize(
"responses, name, count, buttons, gbuttons, sectors, size",
[
(hidpp.responses_profiles, "ONB", 1, 2, 2, 1, 254),
(hidpp.responses_profiles_rom, "ONB", 1, 2, 2, 1, 254),
(hidpp.responses_profiles_rom_2, "ONB", 1, 2, 2, 1, 254),
(fake_hidpp.responses_profiles, "ONB", 1, 2, 2, 1, 254),
(fake_hidpp.responses_profiles_rom, "ONB", 1, 2, 2, 1, 254),
(fake_hidpp.responses_profiles_rom_2, "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, offset=0x9)
device = fake_hidpp.Device(
name, True, 4.5, responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES, offset=0x9
)
device._profiles = None
profiles = _hidpp20.get_profiles(device)

160
tests/logitech_receiver/test_hidpp20_simple.py
View File

@ -20,18 +20,18 @@ from logitech_receiver import common
from logitech_receiver import hidpp20
from logitech_receiver import hidpp20_constants
from . import hidpp
from . import fake_hidpp
_hidpp20 = hidpp20.Hidpp20()
def test_get_firmware():
responses = [
hidpp.Response("02FFFF", 0x0400),
hidpp.Response("01414243030401000101000102030405", 0x0410, "00"),
hidpp.Response("02414243030401000101000102030405", 0x0410, "01"),
fake_hidpp.Response("02FFFF", 0x0400),
fake_hidpp.Response("01414243030401000101000102030405", 0x0410, "00"),
fake_hidpp.Response("02414243030401000101000102030405", 0x0410, "01"),
]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FW_VERSION)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FW_VERSION)
result = _hidpp20.get_firmware(device)
@ -41,8 +41,8 @@ def test_get_firmware():
def test_get_ids():
responses = [hidpp.Response("FF12345678000D123456789ABC", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FW_VERSION)
responses = [fake_hidpp.Response("FF12345678000D123456789ABC", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FW_VERSION)
unitId, modelId, tid_map = _hidpp20.get_ids(device)
@ -52,8 +52,8 @@ def test_get_ids():
def test_get_kind():
responses = [hidpp.Response("00", 0x0420)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_NAME)
responses = [fake_hidpp.Response("00", 0x0420)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_NAME)
result = _hidpp20.get_kind(device)
@ -63,11 +63,11 @@ def test_get_kind():
def test_get_name():
responses = [
hidpp.Response("12", 0x0400),
hidpp.Response("4142434445464748494A4B4C4D4E4F", 0x0410, "00"),
hidpp.Response("505152530000000000000000000000", 0x0410, "0F"),
fake_hidpp.Response("12", 0x0400),
fake_hidpp.Response("4142434445464748494A4B4C4D4E4F", 0x0410, "00"),
fake_hidpp.Response("505152530000000000000000000000", 0x0410, "0F"),
]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_NAME)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_NAME)
result = _hidpp20.get_name(device)
@ -76,11 +76,11 @@ def test_get_name():
def test_get_friendly_name():
responses = [
hidpp.Response("12", 0x0400),
hidpp.Response("004142434445464748494A4B4C4D4E", 0x0410, "00"),
hidpp.Response("0E4F50515253000000000000000000", 0x0410, "0E"),
fake_hidpp.Response("12", 0x0400),
fake_hidpp.Response("004142434445464748494A4B4C4D4E", 0x0410, "00"),
fake_hidpp.Response("0E4F50515253000000000000000000", 0x0410, "0E"),
]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FRIENDLY_NAME)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.DEVICE_FRIENDLY_NAME)
result = _hidpp20.get_friendly_name(device)
@ -88,8 +88,8 @@ def test_get_friendly_name():
def test_get_battery_status():
responses = [hidpp.Response("502000FFFF", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_STATUS)
responses = [fake_hidpp.Response("502000FFFF", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_STATUS)
feature, battery = _hidpp20.get_battery_status(device)
@ -100,8 +100,8 @@ def test_get_battery_status():
def test_get_battery_voltage():
responses = [hidpp.Response("1000FFFFFF", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_VOLTAGE)
responses = [fake_hidpp.Response("1000FFFFFF", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_VOLTAGE)
feature, battery = _hidpp20.get_battery_voltage(device)
@ -112,8 +112,8 @@ def test_get_battery_voltage():
def test_get_battery_unified():
responses = [hidpp.Response("500100FFFF", 0x0410)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.UNIFIED_BATTERY)
responses = [fake_hidpp.Response("500100FFFF", 0x0410)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.UNIFIED_BATTERY)
feature, battery = _hidpp20.get_battery_unified(device)
@ -123,8 +123,8 @@ def test_get_battery_unified():
def test_get_adc_measurement():
responses = [hidpp.Response("100003", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ADC_MEASUREMENT)
responses = [fake_hidpp.Response("100003", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ADC_MEASUREMENT)
feature, battery = _hidpp20.get_adc_measurement(device)
@ -135,8 +135,8 @@ def test_get_adc_measurement():
def test_get_battery():
responses = [hidpp.Response("502000FFFF", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_STATUS)
responses = [fake_hidpp.Response("502000FFFF", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.BATTERY_STATUS)
feature, battery = _hidpp20.get_battery(device, hidpp20_constants.FEATURE.BATTERY_STATUS)
@ -148,11 +148,11 @@ def test_get_battery():
def test_get_battery_none():
responses = [
hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.BATTERY_STATUS:0>4X}"),
hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.BATTERY_VOLTAGE:0>4X}"),
hidpp.Response("500100ffff", 0x0410),
fake_hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.BATTERY_STATUS:0>4X}"),
fake_hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.BATTERY_VOLTAGE:0>4X}"),
fake_hidpp.Response("500100ffff", 0x0410),
]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.UNIFIED_BATTERY)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.UNIFIED_BATTERY)
feature, battery = _hidpp20.get_battery(device, None)
@ -169,8 +169,8 @@ def test_get_battery_none():
def test_get_mouse_pointer_info():
responses = [hidpp.Response("01000A", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.MOUSE_POINTER)
responses = [fake_hidpp.Response("01000A", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.MOUSE_POINTER)
result = _hidpp20.get_mouse_pointer_info(device)
@ -183,8 +183,8 @@ def test_get_mouse_pointer_info():
def test_get_vertical_scrolling_info():
responses = [hidpp.Response("01080C", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.VERTICAL_SCROLLING)
responses = [fake_hidpp.Response("01080C", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.VERTICAL_SCROLLING)
result = _hidpp20.get_vertical_scrolling_info(device)
@ -192,8 +192,8 @@ def test_get_vertical_scrolling_info():
def test_get_hi_res_scrolling_info():
responses = [hidpp.Response("0102", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HI_RES_SCROLLING)
responses = [fake_hidpp.Response("0102", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HI_RES_SCROLLING)
mode, resolution = _hidpp20.get_hi_res_scrolling_info(device)
@ -202,8 +202,8 @@ def test_get_hi_res_scrolling_info():
def test_get_pointer_speed_info():
responses = [hidpp.Response("0102", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.POINTER_SPEED)
responses = [fake_hidpp.Response("0102", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.POINTER_SPEED)
result = _hidpp20.get_pointer_speed_info(device)
@ -211,8 +211,8 @@ def test_get_pointer_speed_info():
def test_get_lowres_wheel_status():
responses = [hidpp.Response("01", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.LOWRES_WHEEL)
responses = [fake_hidpp.Response("01", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.LOWRES_WHEEL)
result = _hidpp20.get_lowres_wheel_status(device)
@ -221,11 +221,11 @@ def test_get_lowres_wheel_status():
def test_get_hires_wheel():
responses = [
hidpp.Response("010C", 0x0400),
hidpp.Response("05FF", 0x0410),
hidpp.Response("03FF", 0x0430),
fake_hidpp.Response("010C", 0x0400),
fake_hidpp.Response("05FF", 0x0410),
fake_hidpp.Response("03FF", 0x0430),
]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HIRES_WHEEL)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HIRES_WHEEL)
multi, has_invert, has_ratchet, inv, res, target, ratchet = _hidpp20.get_hires_wheel(device)
@ -239,8 +239,8 @@ def test_get_hires_wheel():
def test_get_new_fn_inversion():
responses = [hidpp.Response("0300", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.NEW_FN_INVERSION)
responses = [fake_hidpp.Response("0300", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.NEW_FN_INVERSION)
result = _hidpp20.get_new_fn_inversion(device)
@ -255,25 +255,25 @@ def mock_gethostname(mocker):
@pytest.mark.parametrize(
"responses, expected_result",
[
([hidpp.Response(None, 0x0400)], {}),
([hidpp.Response("02000000", 0x0400)], {}),
([fake_hidpp.Response(None, 0x0400)], {}),
([fake_hidpp.Response("02000000", 0x0400)], {}),
(
[
hidpp.Response("03000200", 0x0400),
hidpp.Response("FF01FFFF05FFFF", 0x0410, "00"),
hidpp.Response("0000414243444500FFFFFFFFFF", 0x0430, "0000"),
hidpp.Response("FF01FFFF10FFFF", 0x0410, "01"),
hidpp.Response("01004142434445464748494A4B4C4D", 0x0430, "0100"),
hidpp.Response("01134E4F5000FFFFFFFFFFFFFFFFFF", 0x0430, "010E"),
hidpp.Response("000000000008", 0x0410, "00"),
hidpp.Response("0208", 0x0440, "000041424344454647"),
fake_hidpp.Response("03000200", 0x0400),
fake_hidpp.Response("FF01FFFF05FFFF", 0x0410, "00"),
fake_hidpp.Response("0000414243444500FFFFFFFFFF", 0x0430, "0000"),
fake_hidpp.Response("FF01FFFF10FFFF", 0x0410, "01"),
fake_hidpp.Response("01004142434445464748494A4B4C4D", 0x0430, "0100"),
fake_hidpp.Response("01134E4F5000FFFFFFFFFFFFFFFFFF", 0x0430, "010E"),
fake_hidpp.Response("000000000008", 0x0410, "00"),
fake_hidpp.Response("0208", 0x0440, "000041424344454647"),
],
{0: (True, "ABCDEFG"), 1: (True, "ABCDEFGHIJKLMNO")},
),
],
)
def test_get_host_names(responses, expected_result, mock_gethostname):
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HOSTS_INFO)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HOSTS_INFO)
result = _hidpp20.get_host_names(device)
@ -283,28 +283,28 @@ def test_get_host_names(responses, expected_result, mock_gethostname):
@pytest.mark.parametrize(
"responses, expected_result",
[
([hidpp.Response(None, 0x0400)], None),
([fake_hidpp.Response(None, 0x0400)], None),
(
[
hidpp.Response("03000002", 0x0400),
hidpp.Response("000000000008", 0x0410, "02"),
hidpp.Response("020E", 0x0440, "02004142434445464748494A4B4C4D4E"),
fake_hidpp.Response("03000002", 0x0400),
fake_hidpp.Response("000000000008", 0x0410, "02"),
fake_hidpp.Response("020E", 0x0440, "02004142434445464748494A4B4C4D4E"),
],
True,
),
(
[
hidpp.Response("03000002", 0x0400),
hidpp.Response("000000000014", 0x0410, "02"),
hidpp.Response("020E", 0x0440, "02004142434445464748494A4B4C4D4E"),
hidpp.Response("0214", 0x0440, "020E4F505152535455565758"),
fake_hidpp.Response("03000002", 0x0400),
fake_hidpp.Response("000000000014", 0x0410, "02"),
fake_hidpp.Response("020E", 0x0440, "02004142434445464748494A4B4C4D4E"),
fake_hidpp.Response("0214", 0x0440, "020E4F505152535455565758"),
],
True,
),
],
)
def test_set_host_name(responses, expected_result):
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HOSTS_INFO)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.HOSTS_INFO)
result = _hidpp20.set_host_name(device, "ABCDEFGHIJKLMNOPQRSTUVWX")
@ -312,8 +312,8 @@ def test_set_host_name(responses, expected_result):
def test_get_onboard_mode():
responses = [hidpp.Response("03FFFFFFFF", 0x0420)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES)
responses = [fake_hidpp.Response("03FFFFFFFF", 0x0420)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES)
result = _hidpp20.get_onboard_mode(device)
@ -321,8 +321,8 @@ def test_get_onboard_mode():
def test_set_onboard_mode():
responses = [hidpp.Response("03FFFFFFFF", 0x0410, "03")]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES)
responses = [fake_hidpp.Response("03FFFFFFFF", 0x0410, "03")]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.ONBOARD_PROFILES)
res = _hidpp20.set_onboard_mode(device, 0x3)
@ -332,11 +332,11 @@ def test_set_onboard_mode():
@pytest.mark.parametrize(
"responses, expected_result",
[
([hidpp.Response("03FFFF", 0x0420)], "1ms"),
([fake_hidpp.Response("03FFFF", 0x0420)], "1ms"),
(
[
hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.REPORT_RATE:0>4X}"),
hidpp.Response("04FFFF", 0x0420),
fake_hidpp.Response(None, 0x0000, f"{hidpp20_constants.FEATURE.REPORT_RATE:0>4X}"),
fake_hidpp.Response("04FFFF", 0x0420),
],
"500us",
),
@ -346,7 +346,7 @@ def test_get_polling_rate(
responses,
expected_result,
):
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.EXTENDED_ADJUSTABLE_REPORT_RATE)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.EXTENDED_ADJUSTABLE_REPORT_RATE)
result = _hidpp20.get_polling_rate(device)
@ -354,8 +354,8 @@ def test_get_polling_rate(
def test_get_remaining_pairing():
responses = [hidpp.Response("03FFFF", 0x0400)]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.REMAINING_PAIRING)
responses = [fake_hidpp.Response("03FFFF", 0x0400)]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.REMAINING_PAIRING)
result = _hidpp20.get_remaining_pairing(device)
@ -363,8 +363,8 @@ def test_get_remaining_pairing():
def test_config_change():
responses = [hidpp.Response("03FFFF", 0x0410, "02")]
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.CONFIG_CHANGE)
responses = [fake_hidpp.Response("03FFFF", 0x0410, "02")]
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.CONFIG_CHANGE)
result = _hidpp20.config_change(device, 0x2)
@ -383,7 +383,7 @@ def test_decipher_battery_status():
def test_decipher_battery_voltage():
report = b"\x10\x00\xFF\xff\xff"
report = b"\x10\x00\xff\xff\xff"
feature, battery = hidpp20.decipher_battery_voltage(report)

70
tests/logitech_receiver/test_receiver.py
View File

@ -10,7 +10,7 @@ from logitech_receiver import common
from logitech_receiver import exceptions
from logitech_receiver import receiver
from . import hidpp
from . import fake_hidpp
@pytest.mark.parametrize(
@ -55,38 +55,38 @@ def mock_base():
responses_unifying = [
hidpp.Response("000000", 0x8003, "FF"),
hidpp.Response("000300", 0x8102),
hidpp.Response("0316CC9CB40506220000000000000000", 0x83B5, "03"),
hidpp.Response("20200840820402020700000000000000", 0x83B5, "20"),
hidpp.Response("21211420110400010D1A000000000000", 0x83B5, "21"),
hidpp.Response("22220840660402010700000000020000", 0x83B5, "22"),
hidpp.Response("30198E3EB80600000001000000000000", 0x83B5, "30"),
hidpp.Response("31811119511A40000002000000000000", 0x83B5, "31"),
hidpp.Response("32112C46EA1E40000003000000000000", 0x83B5, "32"),
hidpp.Response("400B4D58204D61737465722033000000", 0x83B5, "40"),
hidpp.Response("41044B35323020202020202020202020", 0x83B5, "41"),
hidpp.Response("42054372616674000000000000000000", 0x83B5, "42"),
hidpp.Response("012411", 0x81F1, "01"),
hidpp.Response("020036", 0x81F1, "02"),
hidpp.Response("03AAAC", 0x81F1, "03"),
hidpp.Response("040209", 0x81F1, "04"),
fake_hidpp.Response("000000", 0x8003, "FF"),
fake_hidpp.Response("000300", 0x8102),
fake_hidpp.Response("0316CC9CB40506220000000000000000", 0x83B5, "03"),
fake_hidpp.Response("20200840820402020700000000000000", 0x83B5, "20"),
fake_hidpp.Response("21211420110400010D1A000000000000", 0x83B5, "21"),
fake_hidpp.Response("22220840660402010700000000020000", 0x83B5, "22"),
fake_hidpp.Response("30198E3EB80600000001000000000000", 0x83B5, "30"),
fake_hidpp.Response("31811119511A40000002000000000000", 0x83B5, "31"),
fake_hidpp.Response("32112C46EA1E40000003000000000000", 0x83B5, "32"),
fake_hidpp.Response("400B4D58204D61737465722033000000", 0x83B5, "40"),
fake_hidpp.Response("41044B35323020202020202020202020", 0x83B5, "41"),
fake_hidpp.Response("42054372616674000000000000000000", 0x83B5, "42"),
fake_hidpp.Response("012411", 0x81F1, "01"),
fake_hidpp.Response("020036", 0x81F1, "02"),
fake_hidpp.Response("03AAAC", 0x81F1, "03"),
fake_hidpp.Response("040209", 0x81F1, "04"),
]
responses_c534 = [
hidpp.Response("000000", 0x8003, "FF", handle=0x12),
hidpp.Response("000209", 0x8102, handle=0x12),
hidpp.Response("0316CC9CB40502220000000000000000", 0x83B5, "03", handle=0x12),
hidpp.Response("00000445AB", 0x83B5, "04", handle=0x12),
fake_hidpp.Response("000000", 0x8003, "FF", handle=0x12),
fake_hidpp.Response("000209", 0x8102, handle=0x12),
fake_hidpp.Response("0316CC9CB40502220000000000000000", 0x83B5, "03", handle=0x12),
fake_hidpp.Response("00000445AB", 0x83B5, "04", handle=0x12),
]
responses_unusual = [
hidpp.Response("000000", 0x8003, "FF", handle=0x13),
hidpp.Response("000300", 0x8102, handle=0x13),
hidpp.Response("00000445AB", 0x83B5, "04", handle=0x13),
hidpp.Response("0326CC9CB40508220000000000000000", 0x83B5, "03", handle=0x13),
fake_hidpp.Response("000000", 0x8003, "FF", handle=0x13),
fake_hidpp.Response("000300", 0x8102, handle=0x13),
fake_hidpp.Response("00000445AB", 0x83B5, "04", handle=0x13),
fake_hidpp.Response("0326CC9CB40508220000000000000000", 0x83B5, "03", handle=0x13),
]
responses_lacking = [
hidpp.Response("000000", 0x8003, "FF", handle=0x14),
hidpp.Response("000300", 0x8102, handle=0x14),
fake_hidpp.Response("000000", 0x8003, "FF", handle=0x14),
fake_hidpp.Response("000300", 0x8102, handle=0x14),
]
mouse_info = {
@ -113,8 +113,8 @@ c534_info = {"kind": common.NamedInt(0, "unknown"), "polling": "", "power_switch
],
)
def test_ReceiverFactory_create_receiver(device_info, responses, handle, serial, max_devices, mock_base):
mock_base[0].side_effect = hidpp.open_path
mock_base[1].side_effect = partial(hidpp.request, responses)
mock_base[0].side_effect = fake_hidpp.open_path
mock_base[1].side_effect = partial(fake_hidpp.request, responses)
if handle is False:
with pytest.raises(Exception): # noqa: B017
@ -139,8 +139,8 @@ def test_ReceiverFactory_create_receiver(device_info, responses, handle, serial,
],
)
def test_ReceiverFactory_props(device_info, responses, firmware, codename, remaining_pairings, pairing_info, count, mock_base):
mock_base[0].side_effect = hidpp.open_path
mock_base[1].side_effect = partial(hidpp.request, responses)
mock_base[0].side_effect = fake_hidpp.open_path
mock_base[1].side_effect = partial(fake_hidpp.request, responses)
r = receiver.ReceiverFactory.create_receiver(device_info, lambda x: x)
@ -161,8 +161,8 @@ def test_ReceiverFactory_props(device_info, responses, firmware, codename, remai
],
)
def test_ReceiverFactory_string(device_info, responses, status_str, strng, mock_base):
mock_base[0].side_effect = hidpp.open_path
mock_base[1].side_effect = partial(hidpp.request, responses)
mock_base[0].side_effect = fake_hidpp.open_path
mock_base[1].side_effect = partial(fake_hidpp.request, responses)
r = receiver.ReceiverFactory.create_receiver(device_info, lambda x: x)
@ -179,8 +179,8 @@ def test_ReceiverFactory_string(device_info, responses, status_str, strng, mock_
],
)
def test_ReceiverFactory_nodevice(device_info, responses, mock_base):
mock_base[0].side_effect = hidpp.open_path
mock_base[1].side_effect = partial(hidpp.request, responses)
mock_base[0].side_effect = fake_hidpp.open_path
mock_base[1].side_effect = partial(fake_hidpp.request, responses)
r = receiver.ReceiverFactory.create_receiver(device_info, lambda x: x)

604
tests/logitech_receiver/test_setting_templates.py
View File

@ -29,7 +29,7 @@ from logitech_receiver import hidpp20_constants
from logitech_receiver import settings_templates
from logitech_receiver import special_keys
from . import hidpp
from . import fake_hidpp
# TODO action part of DpiSlidingXY, MouseGesturesXY
@ -37,8 +37,8 @@ from . import hidpp
class Setup:
def __init__(self, test, *params):
self.test = test
self.responses = [r for r in params if isinstance(r, hidpp.Response)]
self.choices = None if isinstance(params[0], hidpp.Response) else params[0]
self.responses = [r for r in params if isinstance(r, fake_hidpp.Response)]
self.choices = None if isinstance(params[0], fake_hidpp.Response) else params[0]
@dataclass
@ -52,42 +52,42 @@ class RegisterTest:
register_tests = [
Setup(
RegisterTest(settings_templates.RegisterHandDetection, False, True, [b"\x00\x00\x00"]),
hidpp.Response("000030", 0x8101), # keyboard_hand_detection
hidpp.Response("000000", 0x8001, "000000"),
fake_hidpp.Response("000030", 0x8101), # keyboard_hand_detection
fake_hidpp.Response("000000", 0x8001, "000000"),
),
Setup(
RegisterTest(settings_templates.RegisterHandDetection, True, False, [b"\x00\x00\x30"]),
hidpp.Response("000000", 0x8101), # keyboard_hand_detection
hidpp.Response("000030", 0x8001, "000030"),
fake_hidpp.Response("000000", 0x8101), # keyboard_hand_detection
fake_hidpp.Response("000030", 0x8001, "000030"),
),
Setup(
RegisterTest(settings_templates.RegisterSmoothScroll, False, True, [b"\x40"]),
hidpp.Response("00", 0x8101), # mouse_button_flags
hidpp.Response("40", 0x8001, "40"),
fake_hidpp.Response("00", 0x8101), # mouse_button_flags
fake_hidpp.Response("40", 0x8001, "40"),
),
Setup(
RegisterTest(settings_templates.RegisterSideScroll, True, False, [b"\x00"]),
hidpp.Response("02", 0x8101), # mouse_button_flags
hidpp.Response("00", 0x8001, "00"),
fake_hidpp.Response("02", 0x8101), # mouse_button_flags
fake_hidpp.Response("00", 0x8001, "00"),
),
Setup(
RegisterTest(settings_templates.RegisterFnSwap, False, True, [b"\x00\x01"]),
hidpp.Response("0000", 0x8109), # keyboard_fn_swap
hidpp.Response("0001", 0x8009, "0001"),
fake_hidpp.Response("0000", 0x8109), # keyboard_fn_swap
fake_hidpp.Response("0001", 0x8009, "0001"),
),
Setup(
RegisterTest(
settings_templates._PerformanceMXDpi, common.NamedInt(0x88, "800"), common.NamedInt(0x89, "900"), [b"\x89"]
),
hidpp.Response("88", 0x8163), # mouse_dpi
hidpp.Response("89", 0x8063, "89"),
fake_hidpp.Response("88", 0x8163), # mouse_dpi
fake_hidpp.Response("89", 0x8063, "89"),
),
]
@pytest.mark.parametrize("test", register_tests)
def test_register_template(test, mocker):
device = hidpp.Device(protocol=1.0, responses=test.responses)
device = fake_hidpp.Device(protocol=1.0, responses=test.responses)
spy_request = mocker.spy(device, "request")
setting = test.test.sclass.build(device)
@ -116,165 +116,165 @@ class FeatureTest:
simple_tests = [
Setup(
FeatureTest(settings_templates.K375sFnSwap, False, True, offset=0x06),
hidpp.Response("FF0001", 0x0600, "FF"),
hidpp.Response("FF0101", 0x0610, "FF01"),
fake_hidpp.Response("FF0001", 0x0600, "FF"),
fake_hidpp.Response("FF0101", 0x0610, "FF01"),
),
Setup(
FeatureTest(settings_templates.K375sFnSwap, False, True, offset=0x06),
hidpp.Response("050001", 0x0000, "1815"), # HOSTS_INFO
hidpp.Response("FF0001", 0x0600, "FF"),
hidpp.Response("FF0101", 0x0610, "FF01"),
fake_hidpp.Response("050001", 0x0000, "1815"), # HOSTS_INFO
fake_hidpp.Response("FF0001", 0x0600, "FF"),
fake_hidpp.Response("FF0101", 0x0610, "FF01"),
),
Setup(
FeatureTest(settings_templates.K375sFnSwap, False, True, offset=0x06),
hidpp.Response("050001", 0x0000, "1815"), # HOSTS_INFO
hidpp.Response("07050301", 0x0500), # current host is 0x01, i.e., host 2
hidpp.Response("010001", 0x0600, "01"),
hidpp.Response("010101", 0x0610, "0101"),
fake_hidpp.Response("050001", 0x0000, "1815"), # HOSTS_INFO
fake_hidpp.Response("07050301", 0x0500), # current host is 0x01, i.e., host 2
fake_hidpp.Response("010001", 0x0600, "01"),
fake_hidpp.Response("010101", 0x0610, "0101"),
),
Setup(
FeatureTest(settings_templates.FnSwap, True, False),
hidpp.Response("01", 0x0400),
hidpp.Response("00", 0x0410, "00"),
fake_hidpp.Response("01", 0x0400),
fake_hidpp.Response("00", 0x0410, "00"),
),
Setup(
FeatureTest(settings_templates.NewFnSwap, True, False),
hidpp.Response("01", 0x0400),
hidpp.Response("00", 0x0410, "00"),
fake_hidpp.Response("01", 0x0400),
fake_hidpp.Response("00", 0x0410, "00"),
),
# Setup( # Backlight has caused problems
# FeatureTest(settings_templates.Backlight, 0, 5, offset=0x06),
# hidpp.Response("00", 0x0600),
# hidpp.Response("05", 0x0610, "05"),
# fake_hidpp.Response("00", 0x0600),
# fake_hidpp.Response("05", 0x0610, "05"),
# ),
Setup(
FeatureTest(settings_templates.Backlight2DurationHandsOut, 80, 160, version=0x03),
hidpp.Response("011830000000100040006000", 0x0400),
hidpp.Response("0118FF00200040006000", 0x0410, "0118FF00200040006000"),
fake_hidpp.Response("011830000000100040006000", 0x0400),
fake_hidpp.Response("0118FF00200040006000", 0x0410, "0118FF00200040006000"),
),
Setup(
FeatureTest(settings_templates.Backlight2DurationHandsIn, 320, 160, version=0x03),
hidpp.Response("011830000000200040006000", 0x0400),
hidpp.Response("0118FF00200020006000", 0x0410, "0118FF00200020006000"),
fake_hidpp.Response("011830000000200040006000", 0x0400),
fake_hidpp.Response("0118FF00200020006000", 0x0410, "0118FF00200020006000"),
),
Setup(
FeatureTest(settings_templates.Backlight2DurationPowered, 480, 80, version=0x03),
hidpp.Response("011830000000200040006000", 0x0400),
hidpp.Response("0118FF00200040001000", 0x0410, "0118FF00200040001000"),
fake_hidpp.Response("011830000000200040006000", 0x0400),
fake_hidpp.Response("0118FF00200040001000", 0x0410, "0118FF00200040001000"),
),
Setup(
FeatureTest(settings_templates.Backlight3, 0x50, 0x70),
hidpp.Response("50", 0x0410),
hidpp.Response("70", 0x0420, "007009"),
fake_hidpp.Response("50", 0x0410),
fake_hidpp.Response("70", 0x0420, "007009"),
),
Setup(
FeatureTest(settings_templates.HiResScroll, True, False),
hidpp.Response("01", 0x0400),
hidpp.Response("00", 0x0410, "00"),
fake_hidpp.Response("01", 0x0400),
fake_hidpp.Response("00", 0x0410, "00"),
),
Setup(
FeatureTest(settings_templates.LowresMode, False, True),
hidpp.Response("00", 0x0400),
hidpp.Response("01", 0x0410, "01"),
fake_hidpp.Response("00", 0x0400),
fake_hidpp.Response("01", 0x0410, "01"),
),
Setup(
FeatureTest(settings_templates.HiresSmoothInvert, True, False),
hidpp.Response("06", 0x0410),
hidpp.Response("02", 0x0420, "02"),
fake_hidpp.Response("06", 0x0410),
fake_hidpp.Response("02", 0x0420, "02"),
),
Setup(
FeatureTest(settings_templates.HiresSmoothResolution, True, False),
hidpp.Response("06", 0x0410),
hidpp.Response("04", 0x0420, "04"),
fake_hidpp.Response("06", 0x0410),
fake_hidpp.Response("04", 0x0420, "04"),
),
Setup(
FeatureTest(settings_templates.HiresMode, False, True),
hidpp.Response("06", 0x0410),
hidpp.Response("07", 0x0420, "07"),
fake_hidpp.Response("06", 0x0410),
fake_hidpp.Response("07", 0x0420, "07"),
),
Setup(
FeatureTest(settings_templates.PointerSpeed, 0x0100, 0x0120),
hidpp.Response("0100", 0x0400),
hidpp.Response("0120", 0x0410, "0120"),
fake_hidpp.Response("0100", 0x0400),
fake_hidpp.Response("0120", 0x0410, "0120"),
),
Setup(
FeatureTest(settings_templates.ThumbMode, True, False),
hidpp.Response("0100", 0x0410),
hidpp.Response("0000", 0x0420, "0000"),
fake_hidpp.Response("0100", 0x0410),
fake_hidpp.Response("0000", 0x0420, "0000"),
),
Setup(
FeatureTest(settings_templates.ThumbInvert, False, True),
hidpp.Response("0100", 0x0410),
hidpp.Response("0101", 0x0420, "0101"),
fake_hidpp.Response("0100", 0x0410),
fake_hidpp.Response("0101", 0x0420, "0101"),
),
Setup(
FeatureTest(settings_templates.DivertCrown, False, True),
hidpp.Response("01", 0x0410),
hidpp.Response("02", 0x0420, "02"),
fake_hidpp.Response("01", 0x0410),
fake_hidpp.Response("02", 0x0420, "02"),
),
Setup(
FeatureTest(settings_templates.CrownSmooth, True, False),
hidpp.Response("0001", 0x0410),
hidpp.Response("0002", 0x0420, "0002"),
fake_hidpp.Response("0001", 0x0410),
fake_hidpp.Response("0002", 0x0420, "0002"),
),
Setup(
FeatureTest(settings_templates.DivertGkeys, False, True),
hidpp.Response("01", 0x0420, "01"),
fake_hidpp.Response("01", 0x0420, "01"),
),
Setup(
FeatureTest(settings_templates.ScrollRatchet, 2, 1),
hidpp.Response("02", 0x0400),
hidpp.Response("01", 0x0410, "01"),
fake_hidpp.Response("02", 0x0400),
fake_hidpp.Response("01", 0x0410, "01"),
),
Setup(
FeatureTest(settings_templates.SmartShift, 1, 10),
hidpp.Response("0100", 0x0400),
hidpp.Response("000A", 0x0410, "000A"),
fake_hidpp.Response("0100", 0x0400),
fake_hidpp.Response("000A", 0x0410, "000A"),
),
Setup(
FeatureTest(settings_templates.SmartShift, 5, 50),
hidpp.Response("0005", 0x0400),
hidpp.Response("00FF", 0x0410, "00FF"),
fake_hidpp.Response("0005", 0x0400),
fake_hidpp.Response("00FF", 0x0410, "00FF"),
),
Setup(
FeatureTest(settings_templates.SmartShiftEnhanced, 5, 50),
hidpp.Response("0005", 0x0410),
hidpp.Response("00FF", 0x0420, "00FF"),
fake_hidpp.Response("0005", 0x0410),
fake_hidpp.Response("00FF", 0x0420, "00FF"),
),
Setup(
FeatureTest(settings_templates.DisableKeyboardKeys, {1: True, 8: True}, {1: False, 8: True}),
hidpp.Response("09", 0x0400),
hidpp.Response("09", 0x0410),
hidpp.Response("08", 0x0420, "08"),
fake_hidpp.Response("09", 0x0400),
fake_hidpp.Response("09", 0x0410),
fake_hidpp.Response("08", 0x0420, "08"),
),
Setup(
FeatureTest(settings_templates.DualPlatform, 0, 1),
hidpp.Response("00", 0x0400),
hidpp.Response("01", 0x0420, "01"),
fake_hidpp.Response("00", 0x0400),
fake_hidpp.Response("01", 0x0420, "01"),
),
Setup(
FeatureTest(settings_templates.MKeyLEDs, {1: False, 2: False, 4: False}, {1: False, 2: True, 4: True}),
hidpp.Response("03", 0x0400),
hidpp.Response("06", 0x0410, "06"),
fake_hidpp.Response("03", 0x0400),
fake_hidpp.Response("06", 0x0410, "06"),
),
Setup(
FeatureTest(settings_templates.MRKeyLED, False, True),
hidpp.Response("01", 0x0400, "01"),
fake_hidpp.Response("01", 0x0400, "01"),
),
Setup(
FeatureTest(settings_templates.Sidetone, 5, 0xA),
hidpp.Response("05", 0x0400),
hidpp.Response("0A", 0x0410, "0A"),
fake_hidpp.Response("05", 0x0400),
fake_hidpp.Response("0A", 0x0410, "0A"),
),
Setup(
FeatureTest(settings_templates.ADCPower, 5, 0xA),
hidpp.Response("05", 0x0410),
hidpp.Response("0A", 0x0420, "0A"),
fake_hidpp.Response("05", 0x0410),
fake_hidpp.Response("0A", 0x0420, "0A"),
),
Setup(
FeatureTest(settings_templates.LEDControl, 0, 1),
hidpp.Response("00", 0x0470),
hidpp.Response("01", 0x0480, "01"),
fake_hidpp.Response("00", 0x0470),
fake_hidpp.Response("01", 0x0480, "01"),
),
Setup(
FeatureTest(
@ -282,17 +282,17 @@ simple_tests = [
hidpp20.LEDEffectSetting(ID=3, intensity=0x50, period=0x100),
hidpp20.LEDEffectSetting(ID=3, intensity=0x50, period=0x101),
),
hidpp.Response("0100000001", 0x0400),
hidpp.Response("00000102", 0x0410, "00FF00"),
hidpp.Response("0000000300040005", 0x0420, "000000"),
hidpp.Response("0001000B00080009", 0x0420, "000100"),
hidpp.Response("000000000000010050", 0x04E0, "00"),
hidpp.Response("000000000000000101500000", 0x0430, "000000000000000101500000"),
fake_hidpp.Response("0100000001", 0x0400),
fake_hidpp.Response("00000102", 0x0410, "00FF00"),
fake_hidpp.Response("0000000300040005", 0x0420, "000000"),
fake_hidpp.Response("0001000B00080009", 0x0420, "000100"),
fake_hidpp.Response("000000000000010050", 0x04E0, "00"),
fake_hidpp.Response("000000000000000101500000", 0x0430, "000000000000000101500000"),
),
Setup(
FeatureTest(settings_templates.RGBControl, 0, 1),
hidpp.Response("0000", 0x0450),
hidpp.Response("010100", 0x0450, "0101"),
fake_hidpp.Response("0000", 0x0450),
fake_hidpp.Response("010100", 0x0450, "0101"),
),
Setup(
FeatureTest(
@ -300,181 +300,181 @@ simple_tests = [
hidpp20.LEDEffectSetting(ID=3, intensity=0x50, period=0x100),
hidpp20.LEDEffectSetting(ID=2, color=0x505050, speed=0x50),
),
hidpp.Response("FFFF0100000001", 0x0400, "FFFF00"),
hidpp.Response("0000000102", 0x0400, "00FF00"),
hidpp.Response("0000000300040005", 0x0400, "000000"),
hidpp.Response("0001000200080009", 0x0400, "000100"),
hidpp.Response("000000000000010050", 0x04E0, "00"),
hidpp.Response("00015050505000000000000001", 0x0410, "00015050505000000000000001"),
fake_hidpp.Response("FFFF0100000001", 0x0400, "FFFF00"),
fake_hidpp.Response("0000000102", 0x0400, "00FF00"),
fake_hidpp.Response("0000000300040005", 0x0400, "000000"),
fake_hidpp.Response("0001000200080009", 0x0400, "000100"),
fake_hidpp.Response("000000000000010050", 0x04E0, "00"),
fake_hidpp.Response("00015050505000000000000001", 0x0410, "00015050505000000000000001"),
),
Setup(
FeatureTest(settings_templates.RGBEffectSetting, None, hidpp20.LEDEffectSetting(ID=3, intensity=0x60, period=0x101)),
hidpp.Response("FFFF0100000001", 0x0400, "FFFF00"),
hidpp.Response("0000000102", 0x0400, "00FF00"),
hidpp.Response("0000000300040005", 0x0400, "000000"),
hidpp.Response("0001000200080009", 0x0400, "000100"),
hidpp.Response("00000000000000010160000001", 0x0410, "00000000000000010160000001"),
fake_hidpp.Response("FFFF0100000001", 0x0400, "FFFF00"),
fake_hidpp.Response("0000000102", 0x0400, "00FF00"),
fake_hidpp.Response("0000000300040005", 0x0400, "000000"),
fake_hidpp.Response("0001000200080009", 0x0400, "000100"),
fake_hidpp.Response("00000000000000010160000001", 0x0410, "00000000000000010160000001"),
),
Setup(
FeatureTest(settings_templates.RGBEffectSetting, None, hidpp20.LEDEffectSetting(ID=3, intensity=0x60, period=0x101)),
hidpp.Response("FF000200020004000000000000000000", 0x0400, "FFFF00"),
hidpp.Response("00000002040000000000000000000000", 0x0400, "00FF00"),
hidpp.Response("00000000000000000000000000000000", 0x0400, "000000"),
hidpp.Response("00010001000000000000000000000000", 0x0400, "000100"),
hidpp.Response("00020003C00503E00000000000000000", 0x0400, "000200"),
hidpp.Response("0003000AC0011E0B0000000000000000", 0x0400, "000300"),
hidpp.Response("01000001070000000000000000000000", 0x0400, "01FF00"),
hidpp.Response("01000000000000000000000000000000", 0x0400, "010000"),
hidpp.Response("01010001000000000000000000000000", 0x0400, "010100"),
hidpp.Response("0102000AC0011E0B0000000000000000", 0x0400, "010200"),
hidpp.Response("01030003C00503E00000000000000000", 0x0400, "010300"),
hidpp.Response("01040004DCE1001E0000000000000000", 0x0400, "010400"),
hidpp.Response("0105000B000000320000000000000000", 0x0400, "010500"),
hidpp.Response("0106000C001B02340000000000000000", 0x0400, "010600"),
hidpp.Response("00020000000000010160000001", 0x0410, "00020000000000010160000001"),
fake_hidpp.Response("FF000200020004000000000000000000", 0x0400, "FFFF00"),
fake_hidpp.Response("00000002040000000000000000000000", 0x0400, "00FF00"),
fake_hidpp.Response("00000000000000000000000000000000", 0x0400, "000000"),
fake_hidpp.Response("00010001000000000000000000000000", 0x0400, "000100"),
fake_hidpp.Response("00020003C00503E00000000000000000", 0x0400, "000200"),
fake_hidpp.Response("0003000AC0011E0B0000000000000000", 0x0400, "000300"),
fake_hidpp.Response("01000001070000000000000000000000", 0x0400, "01FF00"),
fake_hidpp.Response("01000000000000000000000000000000", 0x0400, "010000"),
fake_hidpp.Response("01010001000000000000000000000000", 0x0400, "010100"),
fake_hidpp.Response("0102000AC0011E0B0000000000000000", 0x0400, "010200"),
fake_hidpp.Response("01030003C00503E00000000000000000", 0x0400, "010300"),
fake_hidpp.Response("01040004DCE1001E0000000000000000", 0x0400, "010400"),
fake_hidpp.Response("0105000B000000320000000000000000", 0x0400, "010500"),
fake_hidpp.Response("0106000C001B02340000000000000000", 0x0400, "010600"),
fake_hidpp.Response("00020000000000010160000001", 0x0410, "00020000000000010160000001"),
),
Setup(
FeatureTest(settings_templates.Backlight2, 0xFF, 0x00),
common.NamedInts(Disabled=0xFF, Enabled=0x00),
hidpp.Response("000201000000000000000000", 0x0400),
hidpp.Response("010201", 0x0410, "0102FF00000000000000"),
fake_hidpp.Response("000201000000000000000000", 0x0400),
fake_hidpp.Response("010201", 0x0410, "0102FF00000000000000"),
),
Setup(
FeatureTest(settings_templates.Backlight2, 0x03, 0xFF),
common.NamedInts(Disabled=0xFF, Automatic=0x01, Manual=0x03),
hidpp.Response("011838000000000000000000", 0x0400),
hidpp.Response("001801", 0x0410, "0018FF00000000000000"),
fake_hidpp.Response("011838000000000000000000", 0x0400),
fake_hidpp.Response("001801", 0x0410, "0018FF00000000000000"),
),
Setup(
FeatureTest(settings_templates.Backlight2Level, 0, 3, version=0x03),
[0, 4],
hidpp.Response("011830000000000000000000", 0x0400),
hidpp.Response("05", 0x0420),
hidpp.Response("01180103000000000000", 0x0410, "0118FF03000000000000"),
fake_hidpp.Response("011830000000000000000000", 0x0400),
fake_hidpp.Response("05", 0x0420),
fake_hidpp.Response("01180103000000000000", 0x0410, "0118FF03000000000000"),
),
Setup(
FeatureTest(settings_templates.Backlight2Level, 0, 2, version=0x03),
[0, 4],
hidpp.Response("011830000000000000000000", 0x0400),
hidpp.Response("05", 0x0420),
hidpp.Response("01180102000000000000", 0x0410, "0118FF02000000000000"),
fake_hidpp.Response("011830000000000000000000", 0x0400),
fake_hidpp.Response("05", 0x0420),
fake_hidpp.Response("01180102000000000000", 0x0410, "0118FF02000000000000"),
),
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"),
hidpp.Response("02", 0x0C20),
hidpp.Response("01", 0x0C10, "01"),
hidpp.Response("0001", 0x0C30, "0001"),
fake_hidpp.Response("01030001010101000101", 0x0C00),
fake_hidpp.Response("00010100000201FFFFFFFFFFFFFFFFFF", 0x0C50, "00000000"),
fake_hidpp.Response("000201FFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000004"),
fake_hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000008"),
fake_hidpp.Response("02", 0x0C20),
fake_hidpp.Response("01", 0x0C10, "01"),
fake_hidpp.Response("0001", 0x0C30, "0001"),
),
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"),
hidpp.Response("01", 0x0C20),
hidpp.Response("0001", 0x0C40),
hidpp.Response("02", 0x0C10, "02"),
fake_hidpp.Response("01030001010101000101", 0x0C00),
fake_hidpp.Response("00010100000201FFFFFFFFFFFFFFFFFF", 0x0C50, "00000000"),
fake_hidpp.Response("000201FFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000004"),
fake_hidpp.Response("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0x0C50, "00000008"),
fake_hidpp.Response("01", 0x0C20),
fake_hidpp.Response("0001", 0x0C40),
fake_hidpp.Response("02", 0x0C10, "02"),
),
Setup(
FeatureTest(settings_templates.ReportRate, 1, 5, offset=0x0C),
common.NamedInts(**{"1ms": 1, "2ms": 2, "5ms": 5, "6ms": 6}),
hidpp.Response("33", 0x0C00),
hidpp.Response("01", 0x0C10),
hidpp.Response("05", 0x0C20, "05"),
fake_hidpp.Response("33", 0x0C00),
fake_hidpp.Response("01", 0x0C10),
fake_hidpp.Response("05", 0x0C20, "05"),
),
Setup(
FeatureTest(settings_templates.ExtendedReportRate, 1, 5, offset=0x0C),
common.NamedInts(**{"8ms": 0, "4ms": 1, "500us": 4, "250us": 5}),
hidpp.Response("33", 0x0C10),
hidpp.Response("01", 0x0C20),
hidpp.Response("05", 0x0C30, "05"),
fake_hidpp.Response("33", 0x0C10),
fake_hidpp.Response("01", 0x0C20),
fake_hidpp.Response("05", 0x0C30, "05"),
),
Setup(
FeatureTest(settings_templates.AdjustableDpi, 800, 400, version=0x03),
common.NamedInts.list([400, 800, 1600]),
hidpp.Response("000190032006400000", 0x0410, "000000"),
hidpp.Response("000320", 0x0420),
hidpp.Response("000190", 0x0430, "000190"),
fake_hidpp.Response("000190032006400000", 0x0410, "000000"),
fake_hidpp.Response("000320", 0x0420),
fake_hidpp.Response("000190", 0x0430, "000190"),
),
Setup(
FeatureTest(settings_templates.AdjustableDpi, 256, 512, version=0x03),
common.NamedInts.list([256, 512]),
hidpp.Response("000100e10002000000", 0x0410, "000000"),
hidpp.Response("000100", 0x0420),
hidpp.Response("000200", 0x0430, "000200"),
fake_hidpp.Response("000100e10002000000", 0x0410, "000000"),
fake_hidpp.Response("000100", 0x0420),
fake_hidpp.Response("000200", 0x0430, "000200"),
),
Setup(
FeatureTest(settings_templates.AdjustableDpi, 400, 800, version=0x03),
common.NamedInts.list([400, 800, 1200, 1600]),
hidpp.Response("000190E19006400000000000000000", 0x0410, "000000"),
hidpp.Response("000190", 0x0420),
hidpp.Response("000320", 0x0430, "000320"),
fake_hidpp.Response("000190E19006400000000000000000", 0x0410, "000000"),
fake_hidpp.Response("000190", 0x0420),
fake_hidpp.Response("000320", 0x0430, "000320"),
),
Setup(
FeatureTest(settings_templates.Multiplatform, 0, 1),
common.NamedInts(**{"MacOS 0.1-0.5": 0, "iOS 0.1-0.7": 1, "Linux 0.2-0.9": 2, "Windows 0.3-0.9": 3}),
hidpp.Response("020004000001", 0x0400),
hidpp.Response("00FF200000010005", 0x0410, "00"),
hidpp.Response("01FF400000010007", 0x0410, "01"),
hidpp.Response("02FF040000020009", 0x0410, "02"),
hidpp.Response("03FF010000030009", 0x0410, "03"),
hidpp.Response("FF01", 0x0430, "FF01"),
fake_hidpp.Response("020004000001", 0x0400),
fake_hidpp.Response("00FF200000010005", 0x0410, "00"),
fake_hidpp.Response("01FF400000010007", 0x0410, "01"),
fake_hidpp.Response("02FF040000020009", 0x0410, "02"),
fake_hidpp.Response("03FF010000030009", 0x0410, "03"),
fake_hidpp.Response("FF01", 0x0430, "FF01"),
),
Setup(
FeatureTest(settings_templates.ChangeHost, 1, 0),
common.NamedInts(**{"1:ABCDEF": 0, "2:GHIJKL": 1}),
hidpp.Response("050003", 0x0000, "1815"), # HOSTS_INFO
hidpp.Response("01000200", 0x0500),
hidpp.Response("000100000600", 0x0510, "00"),
hidpp.Response("000041424344454600", 0x0530, "0000"),
hidpp.Response("000100000600", 0x0510, "01"),
hidpp.Response("00004748494A4B4C00", 0x0530, "0100"),
hidpp.Response("0201", 0x0400),
hidpp.Response(True, 0x0410, "00"),
fake_hidpp.Response("050003", 0x0000, "1815"), # HOSTS_INFO
fake_hidpp.Response("01000200", 0x0500),
fake_hidpp.Response("000100000600", 0x0510, "00"),
fake_hidpp.Response("000041424344454600", 0x0530, "0000"),
fake_hidpp.Response("000100000600", 0x0510, "01"),
fake_hidpp.Response("00004748494A4B4C00", 0x0530, "0100"),
fake_hidpp.Response("0201", 0x0400),
fake_hidpp.Response(True, 0x0410, "00"),
),
Setup(
FeatureTest(settings_templates.BrightnessControl, 0x10, 0x20),
[0, 80],
hidpp.Response("00505100000000", 0x0400), # 0 to 80, all acceptable, no separate on/off
hidpp.Response("10", 0x0410), # brightness 16
hidpp.Response("0020", 0x0420, "0020"), # set brightness 32
fake_hidpp.Response("00505100000000", 0x0400), # 0 to 80, all acceptable, no separate on/off
fake_hidpp.Response("10", 0x0410), # brightness 16
fake_hidpp.Response("0020", 0x0420, "0020"), # set brightness 32
),
Setup(
FeatureTest(settings_templates.BrightnessControl, 0x10, 0x00),
[0, 80],
hidpp.Response("00505104000000", 0x0400), # 0 to 80, all acceptable, separate on/off
hidpp.Response("10", 0x0410), # brightness 16
hidpp.Response("01", 0x0430), # on
hidpp.Response("00", 0x0440), # set off
hidpp.Response("0000", 0x0420, "0000"), # set brightness 0
fake_hidpp.Response("00505104000000", 0x0400), # 0 to 80, all acceptable, separate on/off
fake_hidpp.Response("10", 0x0410), # brightness 16
fake_hidpp.Response("01", 0x0430), # on
fake_hidpp.Response("00", 0x0440), # set off
fake_hidpp.Response("0000", 0x0420, "0000"), # set brightness 0
),
Setup(
FeatureTest(settings_templates.BrightnessControl, 0x00, 0x20),
[0, 80],
hidpp.Response("00505104000000", 0x0400), # 0 to 80, all acceptable, separate on/off
hidpp.Response("10", 0x0410), # brightness 16
hidpp.Response("00", 0x0430), # off
hidpp.Response("01", 0x0440), # set on
hidpp.Response("0020", 0x0420, "0020"), # set brightness 32
fake_hidpp.Response("00505104000000", 0x0400), # 0 to 80, all acceptable, separate on/off
fake_hidpp.Response("10", 0x0410), # brightness 16
fake_hidpp.Response("00", 0x0430), # off
fake_hidpp.Response("01", 0x0440), # set on
fake_hidpp.Response("0020", 0x0420, "0020"), # set brightness 32
),
Setup(
FeatureTest(settings_templates.BrightnessControl, 0x20, 0x08),
[0, 80],
hidpp.Response("00504104001000", 0x0400), # 16 to 80, all acceptable, separate on/off
hidpp.Response("20", 0x0410), # brightness 32
hidpp.Response("01", 0x0430), # on
hidpp.Response("00", 0x0440, "00"), # set off
fake_hidpp.Response("00504104001000", 0x0400), # 16 to 80, all acceptable, separate on/off
fake_hidpp.Response("20", 0x0410), # brightness 32
fake_hidpp.Response("01", 0x0430), # on
fake_hidpp.Response("00", 0x0440, "00"), # set off
),
Setup(
FeatureTest(settings_templates.SpeedChange, 0, None, 0), # need to set up all settings to successfully write
common.NamedInts(**{"Off": 0, "DPI Change": 0xED}),
*hidpp.responses_speedchange,
*fake_hidpp.responses_speedchange,
),
]
@ -488,7 +488,7 @@ def mock_gethostname(mocker):
def test_simple_template(test, mocker, mock_gethostname):
tst = test.test
print("TEST", tst.sclass.feature)
device = hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
device = fake_hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
spy_request = mocker.spy(device, "request")
setting = settings_templates.check_feature(device, tst.sclass)
@ -510,20 +510,20 @@ def test_simple_template(test, mocker, mock_gethostname):
write_value = setting.write(tst.write_value) if tst.write_value is not None else None
assert write_value == tst.write_value
hidpp.match_requests(tst.matched_calls, test.responses, spy_request.call_args_list)
fake_hidpp.match_requests(tst.matched_calls, test.responses, spy_request.call_args_list)
responses_reprog_controls = [
hidpp.Response("03", 0x0500),
hidpp.Response("00500038010001010400000000000000", 0x0510, "00"), # left button
hidpp.Response("00510039010001010400000000000000", 0x0510, "01"), # right button
hidpp.Response("00C4009D310003070500000000000000", 0x0510, "02"), # smart shift
hidpp.Response("00500000000000000000000000000000", 0x0520, "0050"), # left button current
hidpp.Response("00510000500000000000000000000000", 0x0520, "0051"), # right button current
hidpp.Response("00C40000000000000000000000000000", 0x0520, "00C4"), # smart shift current
hidpp.Response("00500005000000000000000000000000", 0x0530, "0050000050"), # left button write
hidpp.Response("00510005000000000000000000000000", 0x0530, "0051000050"), # right button write
hidpp.Response("00C4000C400000000000000000000000", 0x0530, "00C40000C4"), # smart shift write
fake_hidpp.Response("03", 0x0500),
fake_hidpp.Response("00500038010001010400000000000000", 0x0510, "00"), # left button
fake_hidpp.Response("00510039010001010400000000000000", 0x0510, "01"), # right button
fake_hidpp.Response("00C4009D310003070500000000000000", 0x0510, "02"), # smart shift
fake_hidpp.Response("00500000000000000000000000000000", 0x0520, "0050"), # left button current
fake_hidpp.Response("00510000500000000000000000000000", 0x0520, "0051"), # right button current
fake_hidpp.Response("00C40000000000000000000000000000", 0x0520, "00C4"), # smart shift current
fake_hidpp.Response("00500005000000000000000000000000", 0x0530, "0050000050"), # left button write
fake_hidpp.Response("00510005000000000000000000000000", 0x0530, "0051000050"), # right button write
fake_hidpp.Response("00C4000C400000000000000000000000", 0x0530, "00C40000C4"), # smart shift write
]
key_tests = [
@ -535,22 +535,22 @@ key_tests = [
common.NamedInt(0xC4, "Smart Shift"): common.UnsortedNamedInts(Smart_Shift=0xC4, Left_Click=80, Right_Click=81),
},
*responses_reprog_controls,
hidpp.Response("0051000051", 0x0530, "0051000051"), # right button set write
fake_hidpp.Response("0051000051", 0x0530, "0051000051"), # right button set write
),
Setup(
FeatureTest(settings_templates.DivertKeys, {0xC4: 0}, {0xC4: 1}, 2, offset=0x05),
{common.NamedInt(0xC4, "Smart Shift"): common.NamedInts(Regular=0, Diverted=1, Mouse_Gestures=2)},
*responses_reprog_controls,
hidpp.Response("00C4020000", 0x0530, "00C4020000"), # Smart Shift write
hidpp.Response("00C4030000", 0x0530, "00C4030000"), # Smart Shift divert write
fake_hidpp.Response("00C4020000", 0x0530, "00C4020000"), # Smart Shift write
fake_hidpp.Response("00C4030000", 0x0530, "00C4030000"), # Smart Shift divert write
),
Setup(
FeatureTest(settings_templates.DivertKeys, {0xC4: 0}, {0xC4: 2}, 2, offset=0x05),
{common.NamedInt(0xC4, "Smart Shift"): common.NamedInts(Regular=0, Diverted=1, Mouse_Gestures=2, Sliding_DPI=3)},
*responses_reprog_controls,
hidpp.Response("0A0001", 0x0000, "2201"), # ADJUSTABLE_DPI
hidpp.Response("00C4300000", 0x0530, "00C4300000"), # Smart Shift write
hidpp.Response("00C4030000", 0x0530, "00C4030000"), # Smart Shift divert write
fake_hidpp.Response("0A0001", 0x0000, "2201"), # ADJUSTABLE_DPI
fake_hidpp.Response("00C4300000", 0x0530, "00C4300000"), # Smart Shift write
fake_hidpp.Response("00C4030000", 0x0530, "00C4030000"), # Smart Shift divert write
),
Setup(
FeatureTest(settings_templates.PersistentRemappableAction, {80: 16797696, 81: 16797696}, {0x51: 16797952}, 3),
@ -558,18 +558,18 @@ key_tests = [
common.NamedInt(80, "Left Button"): special_keys.KEYS_KEYS_CONSUMER,
common.NamedInt(81, "Right Button"): special_keys.KEYS_KEYS_CONSUMER,
},
hidpp.Response("050001", 0x0000, "1B04"), # REPROG_CONTROLS_V4
fake_hidpp.Response("050001", 0x0000, "1B04"), # REPROG_CONTROLS_V4
*responses_reprog_controls,
hidpp.Response("0041", 0x0400),
hidpp.Response("0201", 0x0410),
hidpp.Response("02", 0x0400),
hidpp.Response("0050", 0x0420, "00FF"), # left button
hidpp.Response("0051", 0x0420, "01FF"), # right button
hidpp.Response("0050000100500000", 0x0430, "0050FF"), # left button current
hidpp.Response("0051000100500001", 0x0430, "0051FF"), # right button current
hidpp.Response("0050FF01005000", 0x0440, "0050FF01005000"), # left button write
hidpp.Response("0051FF01005000", 0x0440, "0051FF01005000"), # right button write
hidpp.Response("0051FF01005100", 0x0440, "0051FF01005100"), # right button set write
fake_hidpp.Response("0041", 0x0400),
fake_hidpp.Response("0201", 0x0410),
fake_hidpp.Response("02", 0x0400),
fake_hidpp.Response("0050", 0x0420, "00FF"), # left button
fake_hidpp.Response("0051", 0x0420, "01FF"), # right button
fake_hidpp.Response("0050000100500000", 0x0430, "0050FF"), # left button current
fake_hidpp.Response("0051000100500001", 0x0430, "0051FF"), # right button current
fake_hidpp.Response("0050FF01005000", 0x0440, "0050FF01005000"), # left button write
fake_hidpp.Response("0051FF01005000", 0x0440, "0051FF01005000"), # right button write
fake_hidpp.Response("0051FF01005100", 0x0440, "0051FF01005100"), # right button set write
),
Setup(
FeatureTest(
@ -591,11 +591,11 @@ key_tests = [
{45: True},
4,
),
*hidpp.responses_gestures,
hidpp.Response("0001FF6F", 0x0420, "0001FF6F"), # write
hidpp.Response("01010F04", 0x0420, "01010F04"),
hidpp.Response("0001FF7F", 0x0420, "0001FF7F"), # write 45
hidpp.Response("01010F04", 0x0420, "01010F04"),
*fake_hidpp.responses_gestures,
fake_hidpp.Response("0001FF6F", 0x0420, "0001FF6F"), # write
fake_hidpp.Response("01010F04", 0x0420, "01010F04"),
fake_hidpp.Response("0001FF7F", 0x0420, "0001FF7F"), # write 45
fake_hidpp.Response("01010F04", 0x0420, "01010F04"),
),
Setup(
FeatureTest(
@ -604,26 +604,26 @@ key_tests = [
{44: True},
4,
),
*hidpp.responses_gestures,
hidpp.Response("0001FF00", 0x0440, "0001FF00"), # write
hidpp.Response("01010300", 0x0440, "01010300"),
hidpp.Response("0001FF08", 0x0440, "0001FF08"), # write 44
hidpp.Response("01010300", 0x0440, "01010300"),
*fake_hidpp.responses_gestures,
fake_hidpp.Response("0001FF00", 0x0440, "0001FF00"), # write
fake_hidpp.Response("01010300", 0x0440, "01010300"),
fake_hidpp.Response("0001FF08", 0x0440, "0001FF08"), # write 44
fake_hidpp.Response("01010300", 0x0440, "01010300"),
),
Setup(
FeatureTest(settings_templates.Gesture2Params, {4: {"scale": 256}}, {4: {"scale": 128}}, 2),
*hidpp.responses_gestures,
hidpp.Response("000100FF000000000000000000000000", 0x0480, "000100FF"),
hidpp.Response("000080FF000000000000000000000000", 0x0480, "000080FF"),
*fake_hidpp.responses_gestures,
fake_hidpp.Response("000100FF000000000000000000000000", 0x0480, "000100FF"),
fake_hidpp.Response("000080FF000000000000000000000000", 0x0480, "000080FF"),
),
Setup(
FeatureTest(settings_templates.Equalizer, {0: -0x20, 1: 0x10}, {1: 0x18}, 2),
[-32, 32],
hidpp.Response("0220000000", 0x0400),
hidpp.Response("0000800100000000000000", 0x0410, "00"),
hidpp.Response("E010", 0x0420, "00"),
hidpp.Response("E010", 0x0430, "02E010"),
hidpp.Response("E018", 0x0430, "02E018"),
fake_hidpp.Response("0220000000", 0x0400),
fake_hidpp.Response("0000800100000000000000", 0x0410, "00"),
fake_hidpp.Response("E010", 0x0420, "00"),
fake_hidpp.Response("E010", 0x0430, "02E010"),
fake_hidpp.Response("E018", 0x0430, "02E018"),
),
Setup(
FeatureTest(settings_templates.PerKeyLighting, {1: -1, 2: -1, 9: -1, 10: -1, 113: -1}, {2: 0xFF0000}, 4, 4, 0, 1),
@ -634,13 +634,13 @@ key_tests = [
common.NamedInt(10, "J"): special_keys.COLORSPLUS,
common.NamedInt(113, "KEY 113"): special_keys.COLORSPLUS,
},
hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
hidpp.Response("00000200000000000000000000000000", 0x0400, "0001"), # second group of keys
hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
fake_hidpp.Response("00000200000000000000000000000000", 0x0400, "0001"), # second group of keys
fake_hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
fake_hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
),
Setup(
FeatureTest(
@ -659,17 +659,17 @@ key_tests = [
common.NamedInt(10, "J"): special_keys.COLORSPLUS,
common.NamedInt(113, "KEY 113"): special_keys.COLORSPLUS,
},
hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
hidpp.Response("00000200000000000000000000000000", 0x0400, "0001"), # second group of keys
hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("09FF0000", 0x0410, "09FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("0AFF0000", 0x0410, "0AFF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("02FF000009FF00000AFF0000", 0x0410, "02FF000009FF00000AFF0000"), # write three values
hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
fake_hidpp.Response("00000200000000000000000000000000", 0x0400, "0001"), # second group of keys
fake_hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
fake_hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("09FF0000", 0x0410, "09FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("0AFF0000", 0x0410, "0AFF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("02FF000009FF00000AFF0000", 0x0410, "02FF000009FF00000AFF0000"), # write three values
fake_hidpp.Response("00", 0x0470, "00"), # finish
),
Setup(
FeatureTest(
@ -689,33 +689,33 @@ key_tests = [
common.NamedInt(113, "KEY 113"): special_keys.COLORSPLUS,
common.NamedInt(114, "KEY 114"): special_keys.COLORSPLUS,
},
hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
hidpp.Response("00000600000000000000000000000000", 0x0400, "0001"), # second group of keys
hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
hidpp.Response("01FF0000", 0x0410, "01FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("09FF0000", 0x0410, "09FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("0AFF0000", 0x0410, "0AFF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("7100FF00", 0x0410, "7100FF00"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("72FF0000", 0x0410, "72FF0000"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
hidpp.Response("FF00000102090A72", 0x460, "FF00000102090A72"), # write one value for five keys
hidpp.Response("7100FF00", 0x0410, "7100FF00"), # write one value
hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("00000606000000000000000000000000", 0x0400, "0000"), # first group of keys
fake_hidpp.Response("00000600000000000000000000000000", 0x0400, "0001"), # second group of keys
fake_hidpp.Response("00000000000000000000000000000000", 0x0400, "0002"), # last group of keys
fake_hidpp.Response("01FF0000", 0x0410, "01FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("02FF0000", 0x0410, "02FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("09FF0000", 0x0410, "09FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("0AFF0000", 0x0410, "0AFF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("7100FF00", 0x0410, "7100FF00"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("72FF0000", 0x0410, "72FF0000"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
fake_hidpp.Response("FF00000102090A72", 0x460, "FF00000102090A72"), # write one value for five keys
fake_hidpp.Response("7100FF00", 0x0410, "7100FF00"), # write one value
fake_hidpp.Response("00", 0x0470, "00"), # finish
),
Setup(
FeatureTest(settings_templates.ExtendedAdjustableDpi, {0: 256}, {0: 512}, 2, offset=0x9),
{common.NamedInt(0, "X"): common.NamedInts.list([256, 512])},
hidpp.Response("000000", 0x0910, "00"), # no y direction, no lod
hidpp.Response("0000000100e10002000000", 0x0920, "000000"),
hidpp.Response("00010000000000000000", 0x0950),
hidpp.Response("000100000000", 0x0960, "000100000000"),
hidpp.Response("000200000000", 0x0960, "000200000000"),
fake_hidpp.Response("000000", 0x0910, "00"), # no y direction, no lod
fake_hidpp.Response("0000000100e10002000000", 0x0920, "000000"),
fake_hidpp.Response("00010000000000000000", 0x0950),
fake_hidpp.Response("000100000000", 0x0960, "000100000000"),
fake_hidpp.Response("000200000000", 0x0960, "000200000000"),
),
Setup(
FeatureTest(settings_templates.ExtendedAdjustableDpi, {0: 0x64, 1: 0xE4}, {0: 0x164}, 2, offset=0x9),
@ -723,15 +723,15 @@ key_tests = [
common.NamedInt(0, "X"): common.NamedInts.list([0x064, 0x074, 0x084, 0x0A4, 0x0C4, 0x0E4, 0x0124, 0x0164, 0x01C4]),
common.NamedInt(1, "Y"): common.NamedInts.list([0x064, 0x074, 0x084, 0x0A4, 0x0C4, 0x0E4, 0x0124, 0x0164]),
},
hidpp.Response("000001", 0x0910, "00"), # supports y direction, no lod
hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000000"),
hidpp.Response("000001E4E0400124E0400164E06001C4", 0x0920, "000001"),
hidpp.Response("00000000000000000000000000000000", 0x0920, "000002"),
hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000100"),
hidpp.Response("000001E4E0400124E040016400000000", 0x0920, "000101"),
hidpp.Response("000064007400E4007400", 0x0950),
hidpp.Response("00006400E400", 0x0960, "00006400E400"),
hidpp.Response("00016400E400", 0x0960, "00016400E400"),
fake_hidpp.Response("000001", 0x0910, "00"), # supports y direction, no lod
fake_hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000000"),
fake_hidpp.Response("000001E4E0400124E0400164E06001C4", 0x0920, "000001"),
fake_hidpp.Response("00000000000000000000000000000000", 0x0920, "000002"),
fake_hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000100"),
fake_hidpp.Response("000001E4E0400124E040016400000000", 0x0920, "000101"),
fake_hidpp.Response("000064007400E4007400", 0x0950),
fake_hidpp.Response("00006400E400", 0x0960, "00006400E400"),
fake_hidpp.Response("00016400E400", 0x0960, "00016400E400"),
),
Setup(
FeatureTest(settings_templates.ExtendedAdjustableDpi, {0: 0x64, 1: 0xE4, 2: 1}, {1: 0x164}, 2, offset=0x9),
@ -740,15 +740,15 @@ key_tests = [
common.NamedInt(1, "Y"): common.NamedInts.list([0x064, 0x074, 0x084, 0x0A4, 0x0C4, 0x0E4, 0x0124, 0x0164]),
common.NamedInt(2, "LOD"): common.NamedInts(LOW=0, MEDIUM=1, HIGH=2),
},
hidpp.Response("000003", 0x0910, "00"), # supports y direction and lod
hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000000"),
hidpp.Response("000001E4E0400124E0400164E06001C4", 0x0920, "000001"),
hidpp.Response("00000000000000000000000000000000", 0x0920, "000002"),
hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000100"),
hidpp.Response("000001E4E0400124E040016400000000", 0x0920, "000101"),
hidpp.Response("000064007400E4007401", 0x0950),
hidpp.Response("00006400E401", 0x0960, "00006400E401"),
hidpp.Response("000064016401", 0x0960, "000064016401"),
fake_hidpp.Response("000003", 0x0910, "00"), # supports y direction and lod
fake_hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000000"),
fake_hidpp.Response("000001E4E0400124E0400164E06001C4", 0x0920, "000001"),
fake_hidpp.Response("00000000000000000000000000000000", 0x0920, "000002"),
fake_hidpp.Response("0000000064E0100084E02000C4E02000", 0x0920, "000100"),
fake_hidpp.Response("000001E4E0400124E040016400000000", 0x0920, "000101"),
fake_hidpp.Response("000064007400E4007401", 0x0950),
fake_hidpp.Response("00006400E401", 0x0960, "00006400E401"),
fake_hidpp.Response("000064016401", 0x0960, "000064016401"),
),
]
@ -756,7 +756,7 @@ key_tests = [
@pytest.mark.parametrize("test", key_tests)
def test_key_template(test, mocker):
tst = test.test
device = hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
device = fake_hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
spy_request = mocker.spy(device, "request")
print("FEATURE", tst.sclass.feature)
@ -784,18 +784,18 @@ def test_key_template(test, mocker):
if tst.rewrite:
write_value = setting.write(value)
hidpp.match_requests(tst.matched_calls, test.responses, spy_request.call_args_list)
fake_hidpp.match_requests(tst.matched_calls, test.responses, spy_request.call_args_list)
@pytest.mark.parametrize(
"responses, currentSpeed, newSpeed",
[
(hidpp.responses_speedchange, 100, 200),
(hidpp.responses_speedchange, None, 250),
(fake_hidpp.responses_speedchange, 100, 200),
(fake_hidpp.responses_speedchange, None, 250),
],
)
def test_SpeedChange_action(responses, currentSpeed, newSpeed, mocker):
device = hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.POINTER_SPEED)
device = fake_hidpp.Device(responses=responses, feature=hidpp20_constants.FEATURE.POINTER_SPEED)
spy_setting_callback = mocker.spy(device, "setting_callback")
settings_templates.check_feature_settings(device, device.settings) # need to set up all the settings
device.persister = {"pointer_speed": currentSpeed, "_speed-change": newSpeed}
@ -814,7 +814,7 @@ def test_SpeedChange_action(responses, currentSpeed, newSpeed, mocker):
@pytest.mark.parametrize("test", simple_tests + key_tests)
def test_check_feature_settings(test, mocker):
tst = test.test
device = hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
device = fake_hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
already_known = []
setting = settings_templates.check_feature_settings(device, already_known)
@ -828,14 +828,14 @@ def test_check_feature_settings(test, mocker):
[
Setup(
FeatureTest(settings_templates.K375sFnSwap, False, True, offset=0x06),
hidpp.Response("FF0001", 0x0600, "FF"),
hidpp.Response("FF0101", 0x0610, "FF01"),
fake_hidpp.Response("FF0001", 0x0600, "FF"),
fake_hidpp.Response("FF0101", 0x0610, "FF01"),
)
],
)
def test_check_feature_setting(test, mocker):
tst = test.test
device = hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
device = fake_hidpp.Device(responses=test.responses, feature=tst.sclass.feature, offset=tst.offset, version=tst.version)
setting = settings_templates.check_feature_setting(device, tst.sclass.name)