CoCalc -- test_keyboard.py

GitHub Repository: torvalds/linux
Path: blob/master/tools/testing/selftests/hid/tests/test_keyboard.py
²⁶³⁰⁸ views
1
#!/bin/env python3
2
# SPDX-License-Identifier: GPL-2.0
3
# -*- coding: utf-8 -*-
4
#
5
# Copyright (c) 2018 Benjamin Tissoires <[email protected]>
6
# Copyright (c) 2018 Red Hat, Inc.
7
#
8

9
from . import base
10
import hidtools.hid
11
import libevdev
12
import logging
13

14
logger = logging.getLogger("hidtools.test.keyboard")
15

16

17
class InvalidHIDCommunication(Exception):
18
    pass
19

20

21
class KeyboardData(object):
22
    pass
23

24

25
class BaseKeyboard(base.UHIDTestDevice):
26
    def __init__(self, rdesc, name=None, input_info=None):
27
        assert rdesc is not None
28
        super().__init__(name, "Key", input_info=input_info, rdesc=rdesc)
29
        self.keystates = {}
30

31
    def _update_key_state(self, keys):
32
        """
33
        Update the internal state of keys with the new state given.
34

35
        :param key: a tuple of chars for the currently pressed keys.
36
        """
37
        # First remove the already released keys
38
        unused_keys = [k for k, v in self.keystates.items() if not v]
39
        for key in unused_keys:
40
            del self.keystates[key]
41

42
        # self.keystates contains now the list of currently pressed keys,
43
        # release them...
44
        for key in self.keystates.keys():
45
            self.keystates[key] = False
46

47
        # ...and press those that are in parameter
48
        for key in keys:
49
            self.keystates[key] = True
50

51
    def _create_report_data(self):
52
        keyboard = KeyboardData()
53
        for key, value in self.keystates.items():
54
            key = key.replace(" ", "").lower()
55
            setattr(keyboard, key, value)
56
        return keyboard
57

58
    def create_array_report(self, keys, reportID=None, application=None):
59
        """
60
        Return an input report for this device.
61

62
        :param keys: a tuple of chars for the pressed keys. The class maintains
63
            the list of currently pressed keys, so to release a key, the caller
64
            needs to call again this function without the key in this tuple.
65
        :param reportID: the numeric report ID for this report, if needed
66
        """
67
        self._update_key_state(keys)
68
        reportID = reportID or self.default_reportID
69

70
        keyboard = self._create_report_data()
71
        return self.create_report(keyboard, reportID=reportID, application=application)
72

73
    def event(self, keys, reportID=None, application=None):
74
        """
75
        Send an input event on the default report ID.
76

77
        :param keys: a tuple of chars for the pressed keys. The class maintains
78
            the list of currently pressed keys, so to release a key, the caller
79
            needs to call again this function without the key in this tuple.
80
        """
81
        r = self.create_array_report(keys, reportID, application)
82
        self.call_input_event(r)
83
        return [r]
84

85

86
class PlainKeyboard(BaseKeyboard):
87
    # fmt: off
88
    report_descriptor = [
89
        0x05, 0x01,                    # Usage Page (Generic Desktop)
90
        0x09, 0x06,                    # Usage (Keyboard)
91
        0xa1, 0x01,                    # Collection (Application)
92
        0x85, 0x01,                    # .Report ID (1)
93
        0x05, 0x07,                    # .Usage Page (Keyboard)
94
        0x19, 0xe0,                    # .Usage Minimum (224)
95
        0x29, 0xe7,                    # .Usage Maximum (231)
96
        0x15, 0x00,                    # .Logical Minimum (0)
97
        0x25, 0x01,                    # .Logical Maximum (1)
98
        0x75, 0x01,                    # .Report Size (1)
99
        0x95, 0x08,                    # .Report Count (8)
100
        0x81, 0x02,                    # .Input (Data,Var,Abs)
101
        0x19, 0x00,                    # .Usage Minimum (0)
102
        0x29, 0x97,                    # .Usage Maximum (151)
103
        0x15, 0x00,                    # .Logical Minimum (0)
104
        0x25, 0x01,                    # .Logical Maximum (1)
105
        0x75, 0x01,                    # .Report Size (1)
106
        0x95, 0x98,                    # .Report Count (152)
107
        0x81, 0x02,                    # .Input (Data,Var,Abs)
108
        0xc0,                          # End Collection
109
    ]
110
    # fmt: on
111

112
    def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
113
        super().__init__(rdesc, name, input_info)
114
        self.default_reportID = 1
115

116

117
class ArrayKeyboard(BaseKeyboard):
118
    # fmt: off
119
    report_descriptor = [
120
        0x05, 0x01,                    # Usage Page (Generic Desktop)
121
        0x09, 0x06,                    # Usage (Keyboard)
122
        0xa1, 0x01,                    # Collection (Application)
123
        0x05, 0x07,                    # .Usage Page (Keyboard)
124
        0x19, 0xe0,                    # .Usage Minimum (224)
125
        0x29, 0xe7,                    # .Usage Maximum (231)
126
        0x15, 0x00,                    # .Logical Minimum (0)
127
        0x25, 0x01,                    # .Logical Maximum (1)
128
        0x75, 0x01,                    # .Report Size (1)
129
        0x95, 0x08,                    # .Report Count (8)
130
        0x81, 0x02,                    # .Input (Data,Var,Abs)
131
        0x95, 0x06,                    # .Report Count (6)
132
        0x75, 0x08,                    # .Report Size (8)
133
        0x15, 0x00,                    # .Logical Minimum (0)
134
        0x26, 0xa4, 0x00,              # .Logical Maximum (164)
135
        0x05, 0x07,                    # .Usage Page (Keyboard)
136
        0x19, 0x00,                    # .Usage Minimum (0)
137
        0x29, 0xa4,                    # .Usage Maximum (164)
138
        0x81, 0x00,                    # .Input (Data,Arr,Abs)
139
        0xc0,                          # End Collection
140
    ]
141
    # fmt: on
142

143
    def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
144
        super().__init__(rdesc, name, input_info)
145

146
    def _create_report_data(self):
147
        data = KeyboardData()
148
        array = []
149

150
        hut = hidtools.hut.HUT
151

152
        # strip modifiers from the array
153
        for k, v in self.keystates.items():
154
            # we ignore depressed keys
155
            if not v:
156
                continue
157

158
            usage = hut[0x07].from_name[k].usage
159
            if usage >= 224 and usage <= 231:
160
                # modifier
161
                setattr(data, k.lower(), 1)
162
            else:
163
                array.append(k)
164

165
        # if array length is bigger than 6, report ErrorRollOver
166
        if len(array) > 6:
167
            array = ["ErrorRollOver"] * 6
168

169
        data.keyboard = array
170
        return data
171

172

173
class LEDKeyboard(ArrayKeyboard):
174
    # fmt: off
175
    report_descriptor = [
176
        0x05, 0x01,                    # Usage Page (Generic Desktop)
177
        0x09, 0x06,                    # Usage (Keyboard)
178
        0xa1, 0x01,                    # Collection (Application)
179
        0x05, 0x07,                    # .Usage Page (Keyboard)
180
        0x19, 0xe0,                    # .Usage Minimum (224)
181
        0x29, 0xe7,                    # .Usage Maximum (231)
182
        0x15, 0x00,                    # .Logical Minimum (0)
183
        0x25, 0x01,                    # .Logical Maximum (1)
184
        0x75, 0x01,                    # .Report Size (1)
185
        0x95, 0x08,                    # .Report Count (8)
186
        0x81, 0x02,                    # .Input (Data,Var,Abs)
187
        0x95, 0x01,                    # .Report Count (1)
188
        0x75, 0x08,                    # .Report Size (8)
189
        0x81, 0x01,                    # .Input (Cnst,Arr,Abs)
190
        0x95, 0x05,                    # .Report Count (5)
191
        0x75, 0x01,                    # .Report Size (1)
192
        0x05, 0x08,                    # .Usage Page (LEDs)
193
        0x19, 0x01,                    # .Usage Minimum (1)
194
        0x29, 0x05,                    # .Usage Maximum (5)
195
        0x91, 0x02,                    # .Output (Data,Var,Abs)
196
        0x95, 0x01,                    # .Report Count (1)
197
        0x75, 0x03,                    # .Report Size (3)
198
        0x91, 0x01,                    # .Output (Cnst,Arr,Abs)
199
        0x95, 0x06,                    # .Report Count (6)
200
        0x75, 0x08,                    # .Report Size (8)
201
        0x15, 0x00,                    # .Logical Minimum (0)
202
        0x26, 0xa4, 0x00,              # .Logical Maximum (164)
203
        0x05, 0x07,                    # .Usage Page (Keyboard)
204
        0x19, 0x00,                    # .Usage Minimum (0)
205
        0x29, 0xa4,                    # .Usage Maximum (164)
206
        0x81, 0x00,                    # .Input (Data,Arr,Abs)
207
        0xc0,                          # End Collection
208
    ]
209
    # fmt: on
210

211
    def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
212
        super().__init__(rdesc, name, input_info)
213

214

215
# Some Primax manufactured keyboards set the Usage Page after having defined
216
# some local Usages. It relies on the fact that the specification states that
217
# Usages are to be concatenated with Usage Pages upon finding a Main item (see
218
# 6.2.2.8). This test covers this case.
219
class PrimaxKeyboard(ArrayKeyboard):
220
    # fmt: off
221
    report_descriptor = [
222
        0x05, 0x01,                    # Usage Page (Generic Desktop)
223
        0x09, 0x06,                    # Usage (Keyboard)
224
        0xA1, 0x01,                    # Collection (Application)
225
        0x05, 0x07,                    # .Usage Page (Keyboard)
226
        0x19, 0xE0,                    # .Usage Minimum (224)
227
        0x29, 0xE7,                    # .Usage Maximum (231)
228
        0x15, 0x00,                    # .Logical Minimum (0)
229
        0x25, 0x01,                    # .Logical Maximum (1)
230
        0x75, 0x01,                    # .Report Size (1)
231
        0x95, 0x08,                    # .Report Count (8)
232
        0x81, 0x02,                    # .Input (Data,Var,Abs)
233
        0x75, 0x08,                    # .Report Size (8)
234
        0x95, 0x01,                    # .Report Count (1)
235
        0x81, 0x01,                    # .Input (Data,Var,Abs)
236
        0x05, 0x08,                    # .Usage Page (LEDs)
237
        0x19, 0x01,                    # .Usage Minimum (1)
238
        0x29, 0x03,                    # .Usage Maximum (3)
239
        0x75, 0x01,                    # .Report Size (1)
240
        0x95, 0x03,                    # .Report Count (3)
241
        0x91, 0x02,                    # .Output (Data,Var,Abs)
242
        0x95, 0x01,                    # .Report Count (1)
243
        0x75, 0x05,                    # .Report Size (5)
244
        0x91, 0x01,                    # .Output (Constant)
245
        0x15, 0x00,                    # .Logical Minimum (0)
246
        0x26, 0xFF, 0x00,              # .Logical Maximum (255)
247
        0x19, 0x00,                    # .Usage Minimum (0)
248
        0x2A, 0xFF, 0x00,              # .Usage Maximum (255)
249
        0x05, 0x07,                    # .Usage Page (Keyboard)
250
        0x75, 0x08,                    # .Report Size (8)
251
        0x95, 0x06,                    # .Report Count (6)
252
        0x81, 0x00,                    # .Input (Data,Arr,Abs)
253
        0xC0,                          # End Collection
254
    ]
255
    # fmt: on
256

257
    def __init__(self, rdesc=report_descriptor, name=None, input_info=None):
258
        super().__init__(rdesc, name, input_info)
259

260

261
class BaseTest:
262
    class TestKeyboard(base.BaseTestCase.TestUhid):
263
        def test_single_key(self):
264
            """check for key reliability."""
265
            uhdev = self.uhdev
266
            evdev = uhdev.get_evdev()
267
            syn_event = self.syn_event
268

269
            r = uhdev.event(["a and A"])
270
            expected = [syn_event]
271
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 1))
272
            events = uhdev.next_sync_events()
273
            self.debug_reports(r, uhdev, events)
274
            self.assertInputEventsIn(expected, events)
275
            assert evdev.value[libevdev.EV_KEY.KEY_A] == 1
276

277
            r = uhdev.event([])
278
            expected = [syn_event]
279
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 0))
280
            events = uhdev.next_sync_events()
281
            self.debug_reports(r, uhdev, events)
282
            self.assertInputEventsIn(expected, events)
283
            assert evdev.value[libevdev.EV_KEY.KEY_A] == 0
284

285
        def test_two_keys(self):
286
            uhdev = self.uhdev
287
            evdev = uhdev.get_evdev()
288
            syn_event = self.syn_event
289

290
            r = uhdev.event(["a and A", "q and Q"])
291
            expected = [syn_event]
292
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 1))
293
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 1))
294
            events = uhdev.next_sync_events()
295
            self.debug_reports(r, uhdev, events)
296
            self.assertInputEventsIn(expected, events)
297
            assert evdev.value[libevdev.EV_KEY.KEY_A] == 1
298

299
            r = uhdev.event([])
300
            expected = [syn_event]
301
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 0))
302
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 0))
303
            events = uhdev.next_sync_events()
304
            self.debug_reports(r, uhdev, events)
305
            self.assertInputEventsIn(expected, events)
306
            assert evdev.value[libevdev.EV_KEY.KEY_A] == 0
307
            assert evdev.value[libevdev.EV_KEY.KEY_Q] == 0
308

309
            r = uhdev.event(["c and C"])
310
            expected = [syn_event]
311
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 1))
312
            events = uhdev.next_sync_events()
313
            self.debug_reports(r, uhdev, events)
314
            self.assertInputEventsIn(expected, events)
315
            assert evdev.value[libevdev.EV_KEY.KEY_C] == 1
316

317
            r = uhdev.event(["c and C", "Spacebar"])
318
            expected = [syn_event]
319
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 1))
320
            events = uhdev.next_sync_events()
321
            self.debug_reports(r, uhdev, events)
322
            assert libevdev.InputEvent(libevdev.EV_KEY.KEY_C) not in events
323
            self.assertInputEventsIn(expected, events)
324
            assert evdev.value[libevdev.EV_KEY.KEY_C] == 1
325
            assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 1
326

327
            r = uhdev.event(["Spacebar"])
328
            expected = [syn_event]
329
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 0))
330
            events = uhdev.next_sync_events()
331
            self.debug_reports(r, uhdev, events)
332
            assert libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE) not in events
333
            self.assertInputEventsIn(expected, events)
334
            assert evdev.value[libevdev.EV_KEY.KEY_C] == 0
335
            assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 1
336

337
            r = uhdev.event([])
338
            expected = [syn_event]
339
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 0))
340
            events = uhdev.next_sync_events()
341
            self.debug_reports(r, uhdev, events)
342
            self.assertInputEventsIn(expected, events)
343
            assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 0
344

345
        def test_modifiers(self):
346
            # ctrl-alt-del would be very nice :)
347
            uhdev = self.uhdev
348
            syn_event = self.syn_event
349

350
            r = uhdev.event(["LeftControl", "LeftShift", "= and +"])
351
            expected = [syn_event]
352
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_LEFTCTRL, 1))
353
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_LEFTSHIFT, 1))
354
            expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_EQUAL, 1))
355
            events = uhdev.next_sync_events()
356
            self.debug_reports(r, uhdev, events)
357
            self.assertInputEventsIn(expected, events)
358

359

360
class TestPlainKeyboard(BaseTest.TestKeyboard):
361
    def create_device(self):
362
        return PlainKeyboard()
363

364
    def test_10_keys(self):
365
        uhdev = self.uhdev
366
        syn_event = self.syn_event
367

368
        r = uhdev.event(
369
            [
370
                "1 and !",
371
                "2 and @",
372
                "3 and #",
373
                "4 and $",
374
                "5 and %",
375
                "6 and ^",
376
                "7 and &",
377
                "8 and *",
378
                "9 and (",
379
                "0 and )",
380
            ]
381
        )
382
        expected = [syn_event]
383
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_0, 1))
384
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_1, 1))
385
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_2, 1))
386
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_3, 1))
387
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_4, 1))
388
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_5, 1))
389
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_6, 1))
390
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_7, 1))
391
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_8, 1))
392
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_9, 1))
393
        events = uhdev.next_sync_events()
394
        self.debug_reports(r, uhdev, events)
395
        self.assertInputEventsIn(expected, events)
396

397
        r = uhdev.event([])
398
        expected = [syn_event]
399
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_0, 0))
400
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_1, 0))
401
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_2, 0))
402
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_3, 0))
403
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_4, 0))
404
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_5, 0))
405
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_6, 0))
406
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_7, 0))
407
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_8, 0))
408
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_9, 0))
409
        events = uhdev.next_sync_events()
410
        self.debug_reports(r, uhdev, events)
411
        self.assertInputEventsIn(expected, events)
412

413

414
class TestArrayKeyboard(BaseTest.TestKeyboard):
415
    def create_device(self):
416
        return ArrayKeyboard()
417

418
    def test_10_keys(self):
419
        uhdev = self.uhdev
420
        syn_event = self.syn_event
421

422
        r = uhdev.event(
423
            [
424
                "1 and !",
425
                "2 and @",
426
                "3 and #",
427
                "4 and $",
428
                "5 and %",
429
                "6 and ^",
430
            ]
431
        )
432
        expected = [syn_event]
433
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_1, 1))
434
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_2, 1))
435
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_3, 1))
436
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_4, 1))
437
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_5, 1))
438
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_6, 1))
439
        events = uhdev.next_sync_events()
440

441
        self.debug_reports(r, uhdev, events)
442
        self.assertInputEventsIn(expected, events)
443

444
        # ErrRollOver
445
        r = uhdev.event(
446
            [
447
                "1 and !",
448
                "2 and @",
449
                "3 and #",
450
                "4 and $",
451
                "5 and %",
452
                "6 and ^",
453
                "7 and &",
454
                "8 and *",
455
                "9 and (",
456
                "0 and )",
457
            ]
458
        )
459
        events = uhdev.next_sync_events()
460

461
        self.debug_reports(r, uhdev, events)
462

463
        assert len(events) == 0
464

465
        r = uhdev.event([])
466
        expected = [syn_event]
467
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_1, 0))
468
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_2, 0))
469
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_3, 0))
470
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_4, 0))
471
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_5, 0))
472
        expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_6, 0))
473
        events = uhdev.next_sync_events()
474
        self.debug_reports(r, uhdev, events)
475
        self.assertInputEventsIn(expected, events)
476

477

478
class TestLEDKeyboard(BaseTest.TestKeyboard):
479
    def create_device(self):
480
        return LEDKeyboard()
481

482

483
class TestPrimaxKeyboard(BaseTest.TestKeyboard):
484
    def create_device(self):
485
        return PrimaxKeyboard()
486

487
Product

Resources

Company
