978 lines
42 KiB
Python
978 lines
42 KiB
Python
#!/bin/env python3
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (c) 2017 Benjamin Tissoires <benjamin.tissoires@gmail.com>
|
|
# Copyright (c) 2017 Red Hat, Inc.
|
|
#
|
|
|
|
from . import base
|
|
import hidtools.hid
|
|
from hidtools.util import BusType
|
|
import libevdev
|
|
import logging
|
|
import pytest
|
|
|
|
logger = logging.getLogger("hidtools.test.mouse")
|
|
|
|
# workaround https://gitlab.freedesktop.org/libevdev/python-libevdev/issues/6
|
|
try:
|
|
libevdev.EV_REL.REL_WHEEL_HI_RES
|
|
except AttributeError:
|
|
libevdev.EV_REL.REL_WHEEL_HI_RES = libevdev.EV_REL.REL_0B
|
|
libevdev.EV_REL.REL_HWHEEL_HI_RES = libevdev.EV_REL.REL_0C
|
|
|
|
|
|
class InvalidHIDCommunication(Exception):
|
|
pass
|
|
|
|
|
|
class MouseData(object):
|
|
pass
|
|
|
|
|
|
class BaseMouse(base.UHIDTestDevice):
|
|
def __init__(self, rdesc, name=None, input_info=None):
|
|
assert rdesc is not None
|
|
super().__init__(name, "Mouse", input_info=input_info, rdesc=rdesc)
|
|
self.left = False
|
|
self.right = False
|
|
self.middle = False
|
|
|
|
def create_report(self, x, y, buttons=None, wheels=None, reportID=None):
|
|
"""
|
|
Return an input report for this device.
|
|
|
|
:param x: relative x
|
|
:param y: relative y
|
|
:param buttons: a (l, r, m) tuple of bools for the button states,
|
|
where ``None`` is "leave unchanged"
|
|
:param wheels: a single value for the vertical wheel or a (vertical, horizontal) tuple for
|
|
the two wheels
|
|
:param reportID: the numeric report ID for this report, if needed
|
|
"""
|
|
if buttons is not None:
|
|
l, r, m = buttons
|
|
if l is not None:
|
|
self.left = l
|
|
if r is not None:
|
|
self.right = r
|
|
if m is not None:
|
|
self.middle = m
|
|
left = self.left
|
|
right = self.right
|
|
middle = self.middle
|
|
# Note: the BaseMouse doesn't actually have a wheel but the
|
|
# create_report magic only fills in those fields exist, so let's
|
|
# make this generic here.
|
|
wheel, acpan = 0, 0
|
|
if wheels is not None:
|
|
if isinstance(wheels, tuple):
|
|
wheel = wheels[0]
|
|
acpan = wheels[1]
|
|
else:
|
|
wheel = wheels
|
|
|
|
reportID = reportID or self.default_reportID
|
|
|
|
mouse = MouseData()
|
|
mouse.b1 = int(left)
|
|
mouse.b2 = int(right)
|
|
mouse.b3 = int(middle)
|
|
mouse.x = x
|
|
mouse.y = y
|
|
mouse.wheel = wheel
|
|
mouse.acpan = acpan
|
|
return super().create_report(mouse, reportID=reportID)
|
|
|
|
def event(self, x, y, buttons=None, wheels=None):
|
|
"""
|
|
Send an input event on the default report ID.
|
|
|
|
:param x: relative x
|
|
:param y: relative y
|
|
:param buttons: a (l, r, m) tuple of bools for the button states,
|
|
where ``None`` is "leave unchanged"
|
|
:param wheels: a single value for the vertical wheel or a (vertical, horizontal) tuple for
|
|
the two wheels
|
|
"""
|
|
r = self.create_report(x, y, buttons, wheels)
|
|
self.call_input_event(r)
|
|
return [r]
|
|
|
|
|
|
class ButtonMouse(BaseMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # .Usage Page (Generic Desktop) 0
|
|
0x09, 0x02, # .Usage (Mouse) 2
|
|
0xa1, 0x01, # .Collection (Application) 4
|
|
0x09, 0x02, # ..Usage (Mouse) 6
|
|
0xa1, 0x02, # ..Collection (Logical) 8
|
|
0x09, 0x01, # ...Usage (Pointer) 10
|
|
0xa1, 0x00, # ...Collection (Physical) 12
|
|
0x05, 0x09, # ....Usage Page (Button) 14
|
|
0x19, 0x01, # ....Usage Minimum (1) 16
|
|
0x29, 0x03, # ....Usage Maximum (3) 18
|
|
0x15, 0x00, # ....Logical Minimum (0) 20
|
|
0x25, 0x01, # ....Logical Maximum (1) 22
|
|
0x75, 0x01, # ....Report Size (1) 24
|
|
0x95, 0x03, # ....Report Count (3) 26
|
|
0x81, 0x02, # ....Input (Data,Var,Abs) 28
|
|
0x75, 0x05, # ....Report Size (5) 30
|
|
0x95, 0x01, # ....Report Count (1) 32
|
|
0x81, 0x03, # ....Input (Cnst,Var,Abs) 34
|
|
0x05, 0x01, # ....Usage Page (Generic Desktop) 36
|
|
0x09, 0x30, # ....Usage (X) 38
|
|
0x09, 0x31, # ....Usage (Y) 40
|
|
0x15, 0x81, # ....Logical Minimum (-127) 42
|
|
0x25, 0x7f, # ....Logical Maximum (127) 44
|
|
0x75, 0x08, # ....Report Size (8) 46
|
|
0x95, 0x02, # ....Report Count (2) 48
|
|
0x81, 0x06, # ....Input (Data,Var,Rel) 50
|
|
0xc0, # ...End Collection 52
|
|
0xc0, # ..End Collection 53
|
|
0xc0, # .End Collection 54
|
|
]
|
|
# fmt: on
|
|
|
|
def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
|
|
super().__init__(rdesc, name, input_info)
|
|
|
|
def fake_report(self, x, y, buttons):
|
|
if buttons is not None:
|
|
left, right, middle = buttons
|
|
if left is None:
|
|
left = self.left
|
|
if right is None:
|
|
right = self.right
|
|
if middle is None:
|
|
middle = self.middle
|
|
else:
|
|
left = self.left
|
|
right = self.right
|
|
middle = self.middle
|
|
|
|
button_mask = sum(1 << i for i, b in enumerate([left, right, middle]) if b)
|
|
x = max(-127, min(127, x))
|
|
y = max(-127, min(127, y))
|
|
x = hidtools.util.to_twos_comp(x, 8)
|
|
y = hidtools.util.to_twos_comp(y, 8)
|
|
return [button_mask, x, y]
|
|
|
|
|
|
class WheelMouse(ButtonMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # Usage Page (Generic Desktop) 0
|
|
0x09, 0x02, # Usage (Mouse) 2
|
|
0xa1, 0x01, # Collection (Application) 4
|
|
0x05, 0x09, # .Usage Page (Button) 6
|
|
0x19, 0x01, # .Usage Minimum (1) 8
|
|
0x29, 0x03, # .Usage Maximum (3) 10
|
|
0x15, 0x00, # .Logical Minimum (0) 12
|
|
0x25, 0x01, # .Logical Maximum (1) 14
|
|
0x95, 0x03, # .Report Count (3) 16
|
|
0x75, 0x01, # .Report Size (1) 18
|
|
0x81, 0x02, # .Input (Data,Var,Abs) 20
|
|
0x95, 0x01, # .Report Count (1) 22
|
|
0x75, 0x05, # .Report Size (5) 24
|
|
0x81, 0x03, # .Input (Cnst,Var,Abs) 26
|
|
0x05, 0x01, # .Usage Page (Generic Desktop) 28
|
|
0x09, 0x01, # .Usage (Pointer) 30
|
|
0xa1, 0x00, # .Collection (Physical) 32
|
|
0x09, 0x30, # ..Usage (X) 34
|
|
0x09, 0x31, # ..Usage (Y) 36
|
|
0x15, 0x81, # ..Logical Minimum (-127) 38
|
|
0x25, 0x7f, # ..Logical Maximum (127) 40
|
|
0x75, 0x08, # ..Report Size (8) 42
|
|
0x95, 0x02, # ..Report Count (2) 44
|
|
0x81, 0x06, # ..Input (Data,Var,Rel) 46
|
|
0xc0, # .End Collection 48
|
|
0x09, 0x38, # .Usage (Wheel) 49
|
|
0x15, 0x81, # .Logical Minimum (-127) 51
|
|
0x25, 0x7f, # .Logical Maximum (127) 53
|
|
0x75, 0x08, # .Report Size (8) 55
|
|
0x95, 0x01, # .Report Count (1) 57
|
|
0x81, 0x06, # .Input (Data,Var,Rel) 59
|
|
0xc0, # End Collection 61
|
|
]
|
|
# fmt: on
|
|
|
|
def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
|
|
super().__init__(rdesc, name, input_info)
|
|
self.wheel_multiplier = 1
|
|
|
|
|
|
class TwoWheelMouse(WheelMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # Usage Page (Generic Desktop) 0
|
|
0x09, 0x02, # Usage (Mouse) 2
|
|
0xa1, 0x01, # Collection (Application) 4
|
|
0x09, 0x01, # .Usage (Pointer) 6
|
|
0xa1, 0x00, # .Collection (Physical) 8
|
|
0x05, 0x09, # ..Usage Page (Button) 10
|
|
0x19, 0x01, # ..Usage Minimum (1) 12
|
|
0x29, 0x10, # ..Usage Maximum (16) 14
|
|
0x15, 0x00, # ..Logical Minimum (0) 16
|
|
0x25, 0x01, # ..Logical Maximum (1) 18
|
|
0x95, 0x10, # ..Report Count (16) 20
|
|
0x75, 0x01, # ..Report Size (1) 22
|
|
0x81, 0x02, # ..Input (Data,Var,Abs) 24
|
|
0x05, 0x01, # ..Usage Page (Generic Desktop) 26
|
|
0x16, 0x01, 0x80, # ..Logical Minimum (-32767) 28
|
|
0x26, 0xff, 0x7f, # ..Logical Maximum (32767) 31
|
|
0x75, 0x10, # ..Report Size (16) 34
|
|
0x95, 0x02, # ..Report Count (2) 36
|
|
0x09, 0x30, # ..Usage (X) 38
|
|
0x09, 0x31, # ..Usage (Y) 40
|
|
0x81, 0x06, # ..Input (Data,Var,Rel) 42
|
|
0x15, 0x81, # ..Logical Minimum (-127) 44
|
|
0x25, 0x7f, # ..Logical Maximum (127) 46
|
|
0x75, 0x08, # ..Report Size (8) 48
|
|
0x95, 0x01, # ..Report Count (1) 50
|
|
0x09, 0x38, # ..Usage (Wheel) 52
|
|
0x81, 0x06, # ..Input (Data,Var,Rel) 54
|
|
0x05, 0x0c, # ..Usage Page (Consumer Devices) 56
|
|
0x0a, 0x38, 0x02, # ..Usage (AC Pan) 58
|
|
0x95, 0x01, # ..Report Count (1) 61
|
|
0x81, 0x06, # ..Input (Data,Var,Rel) 63
|
|
0xc0, # .End Collection 65
|
|
0xc0, # End Collection 66
|
|
]
|
|
# fmt: on
|
|
|
|
def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
|
|
super().__init__(rdesc, name, input_info)
|
|
self.hwheel_multiplier = 1
|
|
|
|
|
|
class MIDongleMIWirelessMouse(TwoWheelMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # Usage Page (Generic Desktop)
|
|
0x09, 0x02, # Usage (Mouse)
|
|
0xa1, 0x01, # Collection (Application)
|
|
0x85, 0x01, # .Report ID (1)
|
|
0x09, 0x01, # .Usage (Pointer)
|
|
0xa1, 0x00, # .Collection (Physical)
|
|
0x95, 0x05, # ..Report Count (5)
|
|
0x75, 0x01, # ..Report Size (1)
|
|
0x05, 0x09, # ..Usage Page (Button)
|
|
0x19, 0x01, # ..Usage Minimum (1)
|
|
0x29, 0x05, # ..Usage Maximum (5)
|
|
0x15, 0x00, # ..Logical Minimum (0)
|
|
0x25, 0x01, # ..Logical Maximum (1)
|
|
0x81, 0x02, # ..Input (Data,Var,Abs)
|
|
0x95, 0x01, # ..Report Count (1)
|
|
0x75, 0x03, # ..Report Size (3)
|
|
0x81, 0x01, # ..Input (Cnst,Arr,Abs)
|
|
0x75, 0x08, # ..Report Size (8)
|
|
0x95, 0x01, # ..Report Count (1)
|
|
0x05, 0x01, # ..Usage Page (Generic Desktop)
|
|
0x09, 0x38, # ..Usage (Wheel)
|
|
0x15, 0x81, # ..Logical Minimum (-127)
|
|
0x25, 0x7f, # ..Logical Maximum (127)
|
|
0x81, 0x06, # ..Input (Data,Var,Rel)
|
|
0x05, 0x0c, # ..Usage Page (Consumer Devices)
|
|
0x0a, 0x38, 0x02, # ..Usage (AC Pan)
|
|
0x95, 0x01, # ..Report Count (1)
|
|
0x81, 0x06, # ..Input (Data,Var,Rel)
|
|
0xc0, # .End Collection
|
|
0x85, 0x02, # .Report ID (2)
|
|
0x09, 0x01, # .Usage (Consumer Control)
|
|
0xa1, 0x00, # .Collection (Physical)
|
|
0x75, 0x0c, # ..Report Size (12)
|
|
0x95, 0x02, # ..Report Count (2)
|
|
0x05, 0x01, # ..Usage Page (Generic Desktop)
|
|
0x09, 0x30, # ..Usage (X)
|
|
0x09, 0x31, # ..Usage (Y)
|
|
0x16, 0x01, 0xf8, # ..Logical Minimum (-2047)
|
|
0x26, 0xff, 0x07, # ..Logical Maximum (2047)
|
|
0x81, 0x06, # ..Input (Data,Var,Rel)
|
|
0xc0, # .End Collection
|
|
0xc0, # End Collection
|
|
0x05, 0x0c, # Usage Page (Consumer Devices)
|
|
0x09, 0x01, # Usage (Consumer Control)
|
|
0xa1, 0x01, # Collection (Application)
|
|
0x85, 0x03, # .Report ID (3)
|
|
0x15, 0x00, # .Logical Minimum (0)
|
|
0x25, 0x01, # .Logical Maximum (1)
|
|
0x75, 0x01, # .Report Size (1)
|
|
0x95, 0x01, # .Report Count (1)
|
|
0x09, 0xcd, # .Usage (Play/Pause)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x0a, 0x83, 0x01, # .Usage (AL Consumer Control Config)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x09, 0xb5, # .Usage (Scan Next Track)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x09, 0xb6, # .Usage (Scan Previous Track)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x09, 0xea, # .Usage (Volume Down)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x09, 0xe9, # .Usage (Volume Up)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x0a, 0x25, 0x02, # .Usage (AC Forward)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0x0a, 0x24, 0x02, # .Usage (AC Back)
|
|
0x81, 0x06, # .Input (Data,Var,Rel)
|
|
0xc0, # End Collection
|
|
]
|
|
# fmt: on
|
|
device_input_info = (BusType.USB, 0x2717, 0x003B)
|
|
device_name = "uhid test MI Dongle MI Wireless Mouse"
|
|
|
|
def __init__(
|
|
self, rdesc=report_descriptor, name=device_name, input_info=device_input_info
|
|
):
|
|
super().__init__(rdesc, name, input_info)
|
|
|
|
def event(self, x, y, buttons=None, wheels=None):
|
|
# this mouse spreads the relative pointer and the mouse buttons
|
|
# onto 2 distinct reports
|
|
rs = []
|
|
r = self.create_report(x, y, buttons, wheels, reportID=1)
|
|
self.call_input_event(r)
|
|
rs.append(r)
|
|
r = self.create_report(x, y, buttons, reportID=2)
|
|
self.call_input_event(r)
|
|
rs.append(r)
|
|
return rs
|
|
|
|
|
|
class ResolutionMultiplierMouse(TwoWheelMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # Usage Page (Generic Desktop) 83
|
|
0x09, 0x02, # Usage (Mouse) 85
|
|
0xa1, 0x01, # Collection (Application) 87
|
|
0x05, 0x01, # .Usage Page (Generic Desktop) 89
|
|
0x09, 0x02, # .Usage (Mouse) 91
|
|
0xa1, 0x02, # .Collection (Logical) 93
|
|
0x85, 0x11, # ..Report ID (17) 95
|
|
0x09, 0x01, # ..Usage (Pointer) 97
|
|
0xa1, 0x00, # ..Collection (Physical) 99
|
|
0x05, 0x09, # ...Usage Page (Button) 101
|
|
0x19, 0x01, # ...Usage Minimum (1) 103
|
|
0x29, 0x03, # ...Usage Maximum (3) 105
|
|
0x95, 0x03, # ...Report Count (3) 107
|
|
0x75, 0x01, # ...Report Size (1) 109
|
|
0x25, 0x01, # ...Logical Maximum (1) 111
|
|
0x81, 0x02, # ...Input (Data,Var,Abs) 113
|
|
0x95, 0x01, # ...Report Count (1) 115
|
|
0x81, 0x01, # ...Input (Cnst,Arr,Abs) 117
|
|
0x09, 0x05, # ...Usage (Vendor Usage 0x05) 119
|
|
0x81, 0x02, # ...Input (Data,Var,Abs) 121
|
|
0x95, 0x03, # ...Report Count (3) 123
|
|
0x81, 0x01, # ...Input (Cnst,Arr,Abs) 125
|
|
0x05, 0x01, # ...Usage Page (Generic Desktop) 127
|
|
0x09, 0x30, # ...Usage (X) 129
|
|
0x09, 0x31, # ...Usage (Y) 131
|
|
0x95, 0x02, # ...Report Count (2) 133
|
|
0x75, 0x08, # ...Report Size (8) 135
|
|
0x15, 0x81, # ...Logical Minimum (-127) 137
|
|
0x25, 0x7f, # ...Logical Maximum (127) 139
|
|
0x81, 0x06, # ...Input (Data,Var,Rel) 141
|
|
0xa1, 0x02, # ...Collection (Logical) 143
|
|
0x85, 0x12, # ....Report ID (18) 145
|
|
0x09, 0x48, # ....Usage (Resolution Multiplier) 147
|
|
0x95, 0x01, # ....Report Count (1) 149
|
|
0x75, 0x02, # ....Report Size (2) 151
|
|
0x15, 0x00, # ....Logical Minimum (0) 153
|
|
0x25, 0x01, # ....Logical Maximum (1) 155
|
|
0x35, 0x01, # ....Physical Minimum (1) 157
|
|
0x45, 0x04, # ....Physical Maximum (4) 159
|
|
0xb1, 0x02, # ....Feature (Data,Var,Abs) 161
|
|
0x35, 0x00, # ....Physical Minimum (0) 163
|
|
0x45, 0x00, # ....Physical Maximum (0) 165
|
|
0x75, 0x06, # ....Report Size (6) 167
|
|
0xb1, 0x01, # ....Feature (Cnst,Arr,Abs) 169
|
|
0x85, 0x11, # ....Report ID (17) 171
|
|
0x09, 0x38, # ....Usage (Wheel) 173
|
|
0x15, 0x81, # ....Logical Minimum (-127) 175
|
|
0x25, 0x7f, # ....Logical Maximum (127) 177
|
|
0x75, 0x08, # ....Report Size (8) 179
|
|
0x81, 0x06, # ....Input (Data,Var,Rel) 181
|
|
0xc0, # ...End Collection 183
|
|
0x05, 0x0c, # ...Usage Page (Consumer Devices) 184
|
|
0x75, 0x08, # ...Report Size (8) 186
|
|
0x0a, 0x38, 0x02, # ...Usage (AC Pan) 188
|
|
0x81, 0x06, # ...Input (Data,Var,Rel) 191
|
|
0xc0, # ..End Collection 193
|
|
0xc0, # .End Collection 194
|
|
0xc0, # End Collection 195
|
|
]
|
|
# fmt: on
|
|
|
|
def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
|
|
super().__init__(rdesc, name, input_info)
|
|
self.default_reportID = 0x11
|
|
|
|
# Feature Report 12, multiplier Feature value must be set to 0b01,
|
|
# i.e. 1. We should extract that from the descriptor instead
|
|
# of hardcoding it here, but meanwhile this will do.
|
|
self.set_feature_report = [0x12, 0x1]
|
|
|
|
def set_report(self, req, rnum, rtype, data):
|
|
if rtype != self.UHID_FEATURE_REPORT:
|
|
raise InvalidHIDCommunication(f"Unexpected report type: {rtype}")
|
|
if rnum != 0x12:
|
|
raise InvalidHIDCommunication(f"Unexpected report number: {rnum}")
|
|
|
|
if data != self.set_feature_report:
|
|
raise InvalidHIDCommunication(
|
|
f"Unexpected data: {data}, expected {self.set_feature_report}"
|
|
)
|
|
|
|
self.wheel_multiplier = 4
|
|
|
|
return 0
|
|
|
|
|
|
class BadResolutionMultiplierMouse(ResolutionMultiplierMouse):
|
|
def set_report(self, req, rnum, rtype, data):
|
|
super().set_report(req, rnum, rtype, data)
|
|
|
|
self.wheel_multiplier = 1
|
|
self.hwheel_multiplier = 1
|
|
return 32 # EPIPE
|
|
|
|
|
|
class ResolutionMultiplierHWheelMouse(TwoWheelMouse):
|
|
# fmt: off
|
|
report_descriptor = [
|
|
0x05, 0x01, # Usage Page (Generic Desktop) 0
|
|
0x09, 0x02, # Usage (Mouse) 2
|
|
0xa1, 0x01, # Collection (Application) 4
|
|
0x05, 0x01, # .Usage Page (Generic Desktop) 6
|
|
0x09, 0x02, # .Usage (Mouse) 8
|
|
0xa1, 0x02, # .Collection (Logical) 10
|
|
0x85, 0x1a, # ..Report ID (26) 12
|
|
0x09, 0x01, # ..Usage (Pointer) 14
|
|
0xa1, 0x00, # ..Collection (Physical) 16
|
|
0x05, 0x09, # ...Usage Page (Button) 18
|
|
0x19, 0x01, # ...Usage Minimum (1) 20
|
|
0x29, 0x05, # ...Usage Maximum (5) 22
|
|
0x95, 0x05, # ...Report Count (5) 24
|
|
0x75, 0x01, # ...Report Size (1) 26
|
|
0x15, 0x00, # ...Logical Minimum (0) 28
|
|
0x25, 0x01, # ...Logical Maximum (1) 30
|
|
0x81, 0x02, # ...Input (Data,Var,Abs) 32
|
|
0x75, 0x03, # ...Report Size (3) 34
|
|
0x95, 0x01, # ...Report Count (1) 36
|
|
0x81, 0x01, # ...Input (Cnst,Arr,Abs) 38
|
|
0x05, 0x01, # ...Usage Page (Generic Desktop) 40
|
|
0x09, 0x30, # ...Usage (X) 42
|
|
0x09, 0x31, # ...Usage (Y) 44
|
|
0x95, 0x02, # ...Report Count (2) 46
|
|
0x75, 0x10, # ...Report Size (16) 48
|
|
0x16, 0x01, 0x80, # ...Logical Minimum (-32767) 50
|
|
0x26, 0xff, 0x7f, # ...Logical Maximum (32767) 53
|
|
0x81, 0x06, # ...Input (Data,Var,Rel) 56
|
|
0xa1, 0x02, # ...Collection (Logical) 58
|
|
0x85, 0x12, # ....Report ID (18) 60
|
|
0x09, 0x48, # ....Usage (Resolution Multiplier) 62
|
|
0x95, 0x01, # ....Report Count (1) 64
|
|
0x75, 0x02, # ....Report Size (2) 66
|
|
0x15, 0x00, # ....Logical Minimum (0) 68
|
|
0x25, 0x01, # ....Logical Maximum (1) 70
|
|
0x35, 0x01, # ....Physical Minimum (1) 72
|
|
0x45, 0x0c, # ....Physical Maximum (12) 74
|
|
0xb1, 0x02, # ....Feature (Data,Var,Abs) 76
|
|
0x85, 0x1a, # ....Report ID (26) 78
|
|
0x09, 0x38, # ....Usage (Wheel) 80
|
|
0x35, 0x00, # ....Physical Minimum (0) 82
|
|
0x45, 0x00, # ....Physical Maximum (0) 84
|
|
0x95, 0x01, # ....Report Count (1) 86
|
|
0x75, 0x10, # ....Report Size (16) 88
|
|
0x16, 0x01, 0x80, # ....Logical Minimum (-32767) 90
|
|
0x26, 0xff, 0x7f, # ....Logical Maximum (32767) 93
|
|
0x81, 0x06, # ....Input (Data,Var,Rel) 96
|
|
0xc0, # ...End Collection 98
|
|
0xa1, 0x02, # ...Collection (Logical) 99
|
|
0x85, 0x12, # ....Report ID (18) 101
|
|
0x09, 0x48, # ....Usage (Resolution Multiplier) 103
|
|
0x75, 0x02, # ....Report Size (2) 105
|
|
0x15, 0x00, # ....Logical Minimum (0) 107
|
|
0x25, 0x01, # ....Logical Maximum (1) 109
|
|
0x35, 0x01, # ....Physical Minimum (1) 111
|
|
0x45, 0x0c, # ....Physical Maximum (12) 113
|
|
0xb1, 0x02, # ....Feature (Data,Var,Abs) 115
|
|
0x35, 0x00, # ....Physical Minimum (0) 117
|
|
0x45, 0x00, # ....Physical Maximum (0) 119
|
|
0x75, 0x04, # ....Report Size (4) 121
|
|
0xb1, 0x01, # ....Feature (Cnst,Arr,Abs) 123
|
|
0x85, 0x1a, # ....Report ID (26) 125
|
|
0x05, 0x0c, # ....Usage Page (Consumer Devices) 127
|
|
0x95, 0x01, # ....Report Count (1) 129
|
|
0x75, 0x10, # ....Report Size (16) 131
|
|
0x16, 0x01, 0x80, # ....Logical Minimum (-32767) 133
|
|
0x26, 0xff, 0x7f, # ....Logical Maximum (32767) 136
|
|
0x0a, 0x38, 0x02, # ....Usage (AC Pan) 139
|
|
0x81, 0x06, # ....Input (Data,Var,Rel) 142
|
|
0xc0, # ...End Collection 144
|
|
0xc0, # ..End Collection 145
|
|
0xc0, # .End Collection 146
|
|
0xc0, # End Collection 147
|
|
]
|
|
# fmt: on
|
|
|
|
def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
|
|
super().__init__(rdesc, name, input_info)
|
|
self.default_reportID = 0x1A
|
|
|
|
# Feature Report 12, multiplier Feature value must be set to 0b0101,
|
|
# i.e. 5. We should extract that from the descriptor instead
|
|
# of hardcoding it here, but meanwhile this will do.
|
|
self.set_feature_report = [0x12, 0x5]
|
|
|
|
def set_report(self, req, rnum, rtype, data):
|
|
super().set_report(req, rnum, rtype, data)
|
|
|
|
self.wheel_multiplier = 12
|
|
self.hwheel_multiplier = 12
|
|
|
|
return 0
|
|
|
|
|
|
class BaseTest:
|
|
class TestMouse(base.BaseTestCase.TestUhid):
|
|
def test_buttons(self):
|
|
"""check for button reliability."""
|
|
uhdev = self.uhdev
|
|
evdev = uhdev.get_evdev()
|
|
syn_event = self.syn_event
|
|
|
|
r = uhdev.event(0, 0, (None, True, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_RIGHT, 1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_RIGHT] == 1
|
|
|
|
r = uhdev.event(0, 0, (None, False, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_RIGHT, 0)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_RIGHT] == 0
|
|
|
|
r = uhdev.event(0, 0, (None, None, True))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_MIDDLE, 1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_MIDDLE] == 1
|
|
|
|
r = uhdev.event(0, 0, (None, None, False))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_MIDDLE, 0)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_MIDDLE] == 0
|
|
|
|
r = uhdev.event(0, 0, (True, None, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_LEFT, 1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_LEFT] == 1
|
|
|
|
r = uhdev.event(0, 0, (False, None, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_LEFT, 0)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_LEFT] == 0
|
|
|
|
r = uhdev.event(0, 0, (True, True, None))
|
|
expected_event0 = libevdev.InputEvent(libevdev.EV_KEY.BTN_LEFT, 1)
|
|
expected_event1 = libevdev.InputEvent(libevdev.EV_KEY.BTN_RIGHT, 1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn(
|
|
(syn_event, expected_event0, expected_event1), events
|
|
)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_RIGHT] == 1
|
|
assert evdev.value[libevdev.EV_KEY.BTN_LEFT] == 1
|
|
|
|
r = uhdev.event(0, 0, (False, None, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_LEFT, 0)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_RIGHT] == 1
|
|
assert evdev.value[libevdev.EV_KEY.BTN_LEFT] == 0
|
|
|
|
r = uhdev.event(0, 0, (None, False, None))
|
|
expected_event = libevdev.InputEvent(libevdev.EV_KEY.BTN_RIGHT, 0)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEventsIn((syn_event, expected_event), events)
|
|
assert evdev.value[libevdev.EV_KEY.BTN_RIGHT] == 0
|
|
assert evdev.value[libevdev.EV_KEY.BTN_LEFT] == 0
|
|
|
|
def test_relative(self):
|
|
"""Check for relative events."""
|
|
uhdev = self.uhdev
|
|
|
|
syn_event = self.syn_event
|
|
|
|
r = uhdev.event(0, -1)
|
|
expected_event = libevdev.InputEvent(libevdev.EV_REL.REL_Y, -1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents((syn_event, expected_event), events)
|
|
|
|
r = uhdev.event(1, 0)
|
|
expected_event = libevdev.InputEvent(libevdev.EV_REL.REL_X, 1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents((syn_event, expected_event), events)
|
|
|
|
r = uhdev.event(-1, 2)
|
|
expected_event0 = libevdev.InputEvent(libevdev.EV_REL.REL_X, -1)
|
|
expected_event1 = libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(
|
|
(syn_event, expected_event0, expected_event1), events
|
|
)
|
|
|
|
|
|
class TestSimpleMouse(BaseTest.TestMouse):
|
|
def create_device(self):
|
|
return ButtonMouse()
|
|
|
|
def test_rdesc(self):
|
|
"""Check that the testsuite actually manages to format the
|
|
reports according to the report descriptors.
|
|
No kernel device is used here"""
|
|
uhdev = self.uhdev
|
|
|
|
event = (0, 0, (None, None, None))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (0, 0, (None, True, None))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (0, 0, (True, True, None))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (0, 0, (False, False, False))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (1, 0, (True, False, True))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (-1, 0, (True, False, True))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (-5, 5, (True, False, True))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (-127, 127, (True, False, True))
|
|
assert uhdev.fake_report(*event) == uhdev.create_report(*event)
|
|
|
|
event = (0, -128, (True, False, True))
|
|
with pytest.raises(hidtools.hid.RangeError):
|
|
uhdev.create_report(*event)
|
|
|
|
|
|
class TestWheelMouse(BaseTest.TestMouse):
|
|
def create_device(self):
|
|
return WheelMouse()
|
|
|
|
def is_wheel_highres(self, uhdev):
|
|
evdev = uhdev.get_evdev()
|
|
assert evdev.has(libevdev.EV_REL.REL_WHEEL)
|
|
return evdev.has(libevdev.EV_REL.REL_WHEEL_HI_RES)
|
|
|
|
def test_wheel(self):
|
|
uhdev = self.uhdev
|
|
|
|
# check if the kernel is high res wheel compatible
|
|
high_res_wheel = self.is_wheel_highres(uhdev)
|
|
|
|
syn_event = self.syn_event
|
|
# The Resolution Multiplier is applied to the HID reports, so we
|
|
# need to pre-multiply too.
|
|
mult = uhdev.wheel_multiplier
|
|
|
|
r = uhdev.event(0, 0, wheels=1 * mult)
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, 1))
|
|
if high_res_wheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 120))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(0, 0, wheels=-1 * mult)
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, -1))
|
|
if high_res_wheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, -120))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(-1, 2, wheels=3 * mult)
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, -1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, 3))
|
|
if high_res_wheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 360))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
|
|
class TestTwoWheelMouse(TestWheelMouse):
|
|
def create_device(self):
|
|
return TwoWheelMouse()
|
|
|
|
def is_hwheel_highres(self, uhdev):
|
|
evdev = uhdev.get_evdev()
|
|
assert evdev.has(libevdev.EV_REL.REL_HWHEEL)
|
|
return evdev.has(libevdev.EV_REL.REL_HWHEEL_HI_RES)
|
|
|
|
def test_ac_pan(self):
|
|
uhdev = self.uhdev
|
|
|
|
# check if the kernel is high res wheel compatible
|
|
high_res_wheel = self.is_wheel_highres(uhdev)
|
|
high_res_hwheel = self.is_hwheel_highres(uhdev)
|
|
assert high_res_wheel == high_res_hwheel
|
|
|
|
syn_event = self.syn_event
|
|
# The Resolution Multiplier is applied to the HID reports, so we
|
|
# need to pre-multiply too.
|
|
hmult = uhdev.hwheel_multiplier
|
|
vmult = uhdev.wheel_multiplier
|
|
|
|
r = uhdev.event(0, 0, wheels=(0, 1 * hmult))
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL, 1))
|
|
if high_res_hwheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, 120))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(0, 0, wheels=(0, -1 * hmult))
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL, -1))
|
|
if high_res_hwheel:
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, -120)
|
|
)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(-1, 2, wheels=(0, 3 * hmult))
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, -1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL, 3))
|
|
if high_res_hwheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, 360))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(-1, 2, wheels=(-3 * vmult, 4 * hmult))
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, -1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, -3))
|
|
if high_res_wheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, -360))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL, 4))
|
|
if high_res_wheel:
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, 480))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
|
|
class TestResolutionMultiplierMouse(TestTwoWheelMouse):
|
|
def create_device(self):
|
|
return ResolutionMultiplierMouse()
|
|
|
|
def is_wheel_highres(self, uhdev):
|
|
high_res = super().is_wheel_highres(uhdev)
|
|
|
|
if not high_res:
|
|
# the kernel doesn't seem to support the high res wheel mice,
|
|
# make sure we haven't triggered the feature
|
|
assert uhdev.wheel_multiplier == 1
|
|
|
|
return high_res
|
|
|
|
def test_resolution_multiplier_wheel(self):
|
|
uhdev = self.uhdev
|
|
|
|
if not self.is_wheel_highres(uhdev):
|
|
pytest.skip("Kernel not compatible, we can not trigger the conditions")
|
|
|
|
assert uhdev.wheel_multiplier > 1
|
|
assert 120 % uhdev.wheel_multiplier == 0
|
|
|
|
def test_wheel_with_multiplier(self):
|
|
uhdev = self.uhdev
|
|
|
|
if not self.is_wheel_highres(uhdev):
|
|
pytest.skip("Kernel not compatible, we can not trigger the conditions")
|
|
|
|
assert uhdev.wheel_multiplier > 1
|
|
|
|
syn_event = self.syn_event
|
|
mult = uhdev.wheel_multiplier
|
|
|
|
r = uhdev.event(0, 0, wheels=1)
|
|
expected = [syn_event]
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 120 / mult)
|
|
)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(0, 0, wheels=-1)
|
|
expected = [syn_event]
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, -120 / mult)
|
|
)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, 1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, -2))
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 120 / mult)
|
|
)
|
|
|
|
for _ in range(mult - 1):
|
|
r = uhdev.event(1, -2, wheels=1)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(1, -2, wheels=1)
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, 1))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
|
|
class TestBadResolutionMultiplierMouse(TestTwoWheelMouse):
|
|
def create_device(self):
|
|
return BadResolutionMultiplierMouse()
|
|
|
|
def is_wheel_highres(self, uhdev):
|
|
high_res = super().is_wheel_highres(uhdev)
|
|
|
|
assert uhdev.wheel_multiplier == 1
|
|
|
|
return high_res
|
|
|
|
def test_resolution_multiplier_wheel(self):
|
|
uhdev = self.uhdev
|
|
|
|
assert uhdev.wheel_multiplier == 1
|
|
|
|
|
|
class TestResolutionMultiplierHWheelMouse(TestResolutionMultiplierMouse):
|
|
def create_device(self):
|
|
return ResolutionMultiplierHWheelMouse()
|
|
|
|
def is_hwheel_highres(self, uhdev):
|
|
high_res = super().is_hwheel_highres(uhdev)
|
|
|
|
if not high_res:
|
|
# the kernel doesn't seem to support the high res wheel mice,
|
|
# make sure we haven't triggered the feature
|
|
assert uhdev.hwheel_multiplier == 1
|
|
|
|
return high_res
|
|
|
|
def test_resolution_multiplier_ac_pan(self):
|
|
uhdev = self.uhdev
|
|
|
|
if not self.is_hwheel_highres(uhdev):
|
|
pytest.skip("Kernel not compatible, we can not trigger the conditions")
|
|
|
|
assert uhdev.hwheel_multiplier > 1
|
|
assert 120 % uhdev.hwheel_multiplier == 0
|
|
|
|
def test_ac_pan_with_multiplier(self):
|
|
uhdev = self.uhdev
|
|
|
|
if not self.is_hwheel_highres(uhdev):
|
|
pytest.skip("Kernel not compatible, we can not trigger the conditions")
|
|
|
|
assert uhdev.hwheel_multiplier > 1
|
|
|
|
syn_event = self.syn_event
|
|
hmult = uhdev.hwheel_multiplier
|
|
|
|
r = uhdev.event(0, 0, wheels=(0, 1))
|
|
expected = [syn_event]
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, 120 / hmult)
|
|
)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(0, 0, wheels=(0, -1))
|
|
expected = [syn_event]
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, -120 / hmult)
|
|
)
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
expected = [syn_event]
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, 1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, -2))
|
|
expected.append(
|
|
libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL_HI_RES, 120 / hmult)
|
|
)
|
|
|
|
for _ in range(hmult - 1):
|
|
r = uhdev.event(1, -2, wheels=(0, 1))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
r = uhdev.event(1, -2, wheels=(0, 1))
|
|
expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_HWHEEL, 1))
|
|
events = uhdev.next_sync_events()
|
|
self.debug_reports(r, uhdev, events)
|
|
self.assertInputEvents(expected, events)
|
|
|
|
|
|
class TestMiMouse(TestWheelMouse):
|
|
def create_device(self):
|
|
return MIDongleMIWirelessMouse()
|
|
|
|
def assertInputEvents(self, expected_events, effective_events):
|
|
# Buttons and x/y are spread over two HID reports, so we can get two
|
|
# event frames for this device.
|
|
remaining = self.assertInputEventsIn(expected_events, effective_events)
|
|
try:
|
|
remaining.remove(libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0))
|
|
except ValueError:
|
|
# If there's no SYN_REPORT in the list, continue and let the
|
|
# assert below print out the real error
|
|
pass
|
|
assert remaining == []
|