mirror of
https://gitlab.freedesktop.org/libinput/libinput.git
synced 2025-12-20 08:00:08 +01:00
667 lines
24 KiB
Python
Executable file
667 lines
24 KiB
Python
Executable file
#!/usr/bin/python3
|
|
# vim: set expandtab shiftwidth=4:
|
|
# -*- Mode: python; coding: utf-8; indent-tabs-mode: nil -*- */
|
|
#
|
|
# Copyright © 2018 Red Hat, Inc.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a
|
|
# copy of this software and associated documentation files (the "Software"),
|
|
# to deal in the Software without restriction, including without limitation
|
|
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
# and/or sell copies of the Software, and to permit persons to whom the
|
|
# Software is furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice (including the next
|
|
# paragraph) shall be included in all copies or substantial portions of the
|
|
# Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
# DEALINGS IN THE SOFTWARE.
|
|
|
|
import argparse
|
|
import os
|
|
import sys
|
|
import unittest
|
|
import yaml
|
|
import re
|
|
|
|
from pkg_resources import parse_version
|
|
|
|
|
|
class TestYaml(unittest.TestCase):
|
|
filename = ''
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
with open(cls.filename) as f:
|
|
cls.yaml = yaml.safe_load(f)
|
|
|
|
def dict_key_crosscheck(self, d, keys):
|
|
'''Check that each key in d is in keys, and that each key is in d'''
|
|
self.assertEqual(sorted(d.keys()), sorted(keys))
|
|
|
|
def libinput_events(self, filter=None):
|
|
'''Returns all libinput events in the recording, regardless of the
|
|
device'''
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
try:
|
|
libinput = e['libinput']
|
|
except KeyError:
|
|
continue
|
|
|
|
for ev in libinput:
|
|
if (filter is None or ev['type'] == filter or
|
|
isinstance(filter, list) and ev['type'] in filter):
|
|
yield ev
|
|
|
|
def test_sections_exist(self):
|
|
sections = ['version', 'ndevices', 'libinput', 'system', 'devices']
|
|
for section in sections:
|
|
self.assertIn(section, self.yaml)
|
|
|
|
def test_version(self):
|
|
version = self.yaml['version']
|
|
self.assertTrue(isinstance(version, int))
|
|
self.assertEqual(version, 1)
|
|
|
|
def test_ndevices(self):
|
|
ndevices = self.yaml['ndevices']
|
|
self.assertTrue(isinstance(ndevices, int))
|
|
self.assertGreaterEqual(ndevices, 1)
|
|
self.assertEqual(ndevices, len(self.yaml['devices']))
|
|
|
|
def test_libinput(self):
|
|
libinput = self.yaml['libinput']
|
|
version = libinput['version']
|
|
self.assertTrue(isinstance(version, str))
|
|
self.assertGreaterEqual(parse_version(version),
|
|
parse_version('1.10.0'))
|
|
git = libinput['git']
|
|
self.assertTrue(isinstance(git, str))
|
|
self.assertNotEqual(git, 'unknown')
|
|
|
|
def test_system(self):
|
|
system = self.yaml['system']
|
|
kernel = system['kernel']
|
|
self.assertTrue(isinstance(kernel, str))
|
|
self.assertEqual(kernel, os.uname().release)
|
|
|
|
dmi = system['dmi']
|
|
self.assertTrue(isinstance(dmi, str))
|
|
with open('/sys/class/dmi/id/modalias') as f:
|
|
sys_dmi = f.read()[:-1] # trailing newline
|
|
self.assertEqual(dmi, sys_dmi)
|
|
|
|
def test_devices_sections_exist(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
self.assertIn('node', d)
|
|
self.assertIn('evdev', d)
|
|
self.assertIn('udev', d)
|
|
|
|
def test_evdev_sections_exist(self):
|
|
sections = ['name', 'id', 'codes', 'properties']
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
evdev = d['evdev']
|
|
for s in sections:
|
|
self.assertIn(s, evdev)
|
|
|
|
def test_evdev_name(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
evdev = d['evdev']
|
|
name = evdev['name']
|
|
self.assertTrue(isinstance(name, str))
|
|
self.assertGreaterEqual(len(name), 5)
|
|
|
|
def test_evdev_id(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
evdev = d['evdev']
|
|
id = evdev['id']
|
|
self.assertTrue(isinstance(id, list))
|
|
self.assertEqual(len(id), 4)
|
|
self.assertGreater(id[0], 0)
|
|
self.assertGreater(id[1], 0)
|
|
|
|
def test_evdev_properties(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
evdev = d['evdev']
|
|
properties = evdev['properties']
|
|
self.assertTrue(isinstance(properties, list))
|
|
|
|
def test_hid(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
hid = d['hid']
|
|
self.assertTrue(isinstance(hid, list))
|
|
for byte in hid:
|
|
self.assertGreaterEqual(byte, 0)
|
|
self.assertLessEqual(byte, 255)
|
|
|
|
def test_udev_sections_exist(self):
|
|
sections = ['properties']
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
udev = d['udev']
|
|
for s in sections:
|
|
self.assertIn(s, udev)
|
|
|
|
def test_udev_properties(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
udev = d['udev']
|
|
properties = udev['properties']
|
|
self.assertTrue(isinstance(properties, list))
|
|
self.assertGreater(len(properties), 0)
|
|
|
|
self.assertIn('ID_INPUT=1', properties)
|
|
for p in properties:
|
|
self.assertTrue(re.match('[A-Z0-9_]+=.+', p))
|
|
|
|
def test_udev_id_inputs(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
udev = d['udev']
|
|
properties = udev['properties']
|
|
id_inputs = [p for p in properties if p.startswith('ID_INPUT')]
|
|
# We expect ID_INPUT and ID_INPUT_something, but might get more
|
|
# than one of the latter
|
|
self.assertGreaterEqual(len(id_inputs), 2)
|
|
|
|
def test_events_have_section(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
self.assertTrue('evdev' in e or 'libinput' in e)
|
|
|
|
def test_events_evdev(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
try:
|
|
evdev = e['evdev']
|
|
except KeyError:
|
|
continue
|
|
|
|
for ev in evdev:
|
|
self.assertEqual(len(ev), 5)
|
|
|
|
# Last event in each frame is SYN_REPORT
|
|
ev_syn = evdev[-1]
|
|
self.assertEqual(ev_syn[2], 0)
|
|
self.assertEqual(ev_syn[3], 0)
|
|
# SYN_REPORT value is 1 in case of some key repeats
|
|
self.assertLessEqual(ev_syn[4], 1)
|
|
|
|
def test_events_evdev_syn_report(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
try:
|
|
evdev = e['evdev']
|
|
except KeyError:
|
|
continue
|
|
for ev in evdev[:-1]:
|
|
self.assertFalse(ev[2] == 0 and ev[3] == 0)
|
|
|
|
def test_events_libinput(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
try:
|
|
libinput = e['libinput']
|
|
except KeyError:
|
|
continue
|
|
|
|
self.assertTrue(isinstance(libinput, list))
|
|
for ev in libinput:
|
|
self.assertTrue(isinstance(ev, dict))
|
|
|
|
def test_events_libinput_type(self):
|
|
types = ['POINTER_MOTION', 'POINTER_MOTION_ABSOLUTE', 'POINTER_AXIS',
|
|
'POINTER_BUTTON', 'DEVICE_ADDED', 'KEYBOARD_KEY',
|
|
'TOUCH_DOWN', 'TOUCH_MOTION', 'TOUCH_UP', 'TOUCH_FRAME',
|
|
'GESTURE_SWIPE_BEGIN', 'GESTURE_SWIPE_UPDATE',
|
|
'GESTURE_SWIPE_END', 'GESTURE_PINCH_BEGIN',
|
|
'GESTURE_PINCH_UPDATE', 'GESTURE_PINCH_END',
|
|
'TABLET_TOOL_AXIS', 'TABLET_TOOL_PROXIMITY',
|
|
'TABLET_TOOL_BUTTON', 'TABLET_TOOL_TIP',
|
|
'TABLET_PAD_STRIP', 'TABLET_PAD_RING',
|
|
'TABLET_PAD_BUTTON', 'SWITCH_TOGGLE',
|
|
]
|
|
for e in self.libinput_events():
|
|
self.assertIn('type', e)
|
|
self.assertIn(e['type'], types)
|
|
|
|
def test_events_libinput_time(self):
|
|
# DEVICE_ADDED has no time
|
|
# first event may have 0.0 time if the first frame generates a
|
|
# libinput event.
|
|
try:
|
|
for e in list(self.libinput_events())[2:]:
|
|
self.assertIn('time', e)
|
|
self.assertGreater(e['time'], 0.0)
|
|
self.assertLess(e['time'], 60.0)
|
|
except IndexError:
|
|
pass
|
|
|
|
def test_events_libinput_device_added(self):
|
|
keys = ['type', 'seat', 'logical_seat']
|
|
for e in self.libinput_events('DEVICE_ADDED'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
self.assertEqual(e['seat'], 'seat0')
|
|
self.assertEqual(e['logical_seat'], 'default')
|
|
|
|
def test_events_libinput_pointer_motion(self):
|
|
keys = ['type', 'time', 'delta', 'unaccel']
|
|
for e in self.libinput_events('POINTER_MOTION'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
delta = e['delta']
|
|
self.assertTrue(isinstance(delta, list))
|
|
self.assertEqual(len(delta), 2)
|
|
for d in delta:
|
|
self.assertTrue(isinstance(d, float))
|
|
unaccel = e['unaccel']
|
|
self.assertTrue(isinstance(unaccel, list))
|
|
self.assertEqual(len(unaccel), 2)
|
|
for d in unaccel:
|
|
self.assertTrue(isinstance(d, float))
|
|
|
|
def test_events_libinput_pointer_button(self):
|
|
keys = ['type', 'time', 'button', 'state', 'seat_count']
|
|
for e in self.libinput_events('POINTER_BUTTON'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
button = e['button']
|
|
self.assertGreater(button, 0x100) # BTN_0
|
|
self.assertLess(button, 0x160) # KEY_OK
|
|
state = e['state']
|
|
self.assertIn(state, ['pressed', 'released'])
|
|
scount = e['seat_count']
|
|
self.assertGreaterEqual(scount, 0)
|
|
|
|
def test_events_libinput_pointer_absolute(self):
|
|
keys = ['type', 'time', 'point', 'transformed']
|
|
for e in self.libinput_events('POINTER_MOTION_ABSOLUTE'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
point = e['point']
|
|
self.assertTrue(isinstance(point, list))
|
|
self.assertEqual(len(point), 2)
|
|
for p in point:
|
|
self.assertTrue(isinstance(p, float))
|
|
self.assertGreater(p, 0.0)
|
|
self.assertLess(p, 300.0)
|
|
|
|
transformed = e['transformed']
|
|
self.assertTrue(isinstance(transformed, list))
|
|
self.assertEqual(len(transformed), 2)
|
|
for t in transformed:
|
|
self.assertTrue(isinstance(t, float))
|
|
self.assertGreater(t, 0.0)
|
|
self.assertLess(t, 100.0)
|
|
|
|
def test_events_libinput_touch(self):
|
|
keys = ['type', 'time', 'slot', 'seat_slot']
|
|
for e in self.libinput_events():
|
|
if (not e['type'].startswith('TOUCH_') or
|
|
e['type'] == 'TOUCH_FRAME'):
|
|
continue
|
|
|
|
for k in keys:
|
|
self.assertIn(k, e.keys())
|
|
slot = e['slot']
|
|
seat_slot = e['seat_slot']
|
|
|
|
self.assertGreaterEqual(slot, 0)
|
|
self.assertGreaterEqual(seat_slot, 0)
|
|
|
|
def test_events_libinput_touch_down(self):
|
|
keys = ['type', 'time', 'slot', 'seat_slot', 'point', 'transformed']
|
|
for e in self.libinput_events('TOUCH_DOWN'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
point = e['point']
|
|
self.assertTrue(isinstance(point, list))
|
|
self.assertEqual(len(point), 2)
|
|
for p in point:
|
|
self.assertTrue(isinstance(p, float))
|
|
self.assertGreater(p, 0.0)
|
|
self.assertLess(p, 300.0)
|
|
|
|
transformed = e['transformed']
|
|
self.assertTrue(isinstance(transformed, list))
|
|
self.assertEqual(len(transformed), 2)
|
|
for t in transformed:
|
|
self.assertTrue(isinstance(t, float))
|
|
self.assertGreater(t, 0.0)
|
|
self.assertLess(t, 100.0)
|
|
|
|
def test_events_libinput_touch_motion(self):
|
|
keys = ['type', 'time', 'slot', 'seat_slot', 'point', 'transformed']
|
|
for e in self.libinput_events('TOUCH_MOTION'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
point = e['point']
|
|
self.assertTrue(isinstance(point, list))
|
|
self.assertEqual(len(point), 2)
|
|
for p in point:
|
|
self.assertTrue(isinstance(p, float))
|
|
self.assertGreater(p, 0.0)
|
|
self.assertLess(p, 300.0)
|
|
|
|
transformed = e['transformed']
|
|
self.assertTrue(isinstance(transformed, list))
|
|
self.assertEqual(len(transformed), 2)
|
|
for t in transformed:
|
|
self.assertTrue(isinstance(t, float))
|
|
self.assertGreater(t, 0.0)
|
|
self.assertLess(t, 100.0)
|
|
|
|
def test_events_libinput_touch_frame(self):
|
|
devices = self.yaml['devices']
|
|
for d in devices:
|
|
events = d['events']
|
|
if not events:
|
|
raise unittest.SkipTest()
|
|
for e in events:
|
|
try:
|
|
evdev = e['libinput']
|
|
except KeyError:
|
|
continue
|
|
|
|
need_frame = False
|
|
for ev in evdev:
|
|
t = ev['type']
|
|
if not t.startswith('TOUCH_'):
|
|
self.assertFalse(need_frame)
|
|
continue
|
|
|
|
if t == 'TOUCH_FRAME':
|
|
self.assertTrue(need_frame)
|
|
need_frame = False
|
|
else:
|
|
need_frame = True
|
|
|
|
self.assertFalse(need_frame)
|
|
|
|
def test_events_libinput_gesture_pinch(self):
|
|
keys = ['type', 'time', 'nfingers', 'delta',
|
|
'unaccel', 'angle_delta', 'scale']
|
|
for e in self.libinput_events(['GESTURE_PINCH_BEGIN',
|
|
'GESTURE_PINCH_UPDATE',
|
|
'GESTURE_PINCH_END']):
|
|
self.dict_key_crosscheck(e, keys)
|
|
delta = e['delta']
|
|
self.assertTrue(isinstance(delta, list))
|
|
self.assertEqual(len(delta), 2)
|
|
for d in delta:
|
|
self.assertTrue(isinstance(d, float))
|
|
unaccel = e['unaccel']
|
|
self.assertTrue(isinstance(unaccel, list))
|
|
self.assertEqual(len(unaccel), 2)
|
|
for d in unaccel:
|
|
self.assertTrue(isinstance(d, float))
|
|
|
|
adelta = e['angle_delta']
|
|
self.assertTrue(isinstance(adelta, list))
|
|
self.assertEqual(len(adelta), 2)
|
|
for d in adelta:
|
|
self.assertTrue(isinstance(d, float))
|
|
|
|
scale = e['scale']
|
|
self.assertTrue(isinstance(scale, list))
|
|
self.assertEqual(len(scale), 2)
|
|
for d in scale:
|
|
self.assertTrue(isinstance(d, float))
|
|
|
|
def test_events_libinput_gesture_swipe(self):
|
|
keys = ['type', 'time', 'nfingers', 'delta',
|
|
'unaccel']
|
|
for e in self.libinput_events(['GESTURE_SWIPE_BEGIN',
|
|
'GESTURE_SWIPE_UPDATE',
|
|
'GESTURE_SWIPE_END']):
|
|
self.dict_key_crosscheck(e, keys)
|
|
delta = e['delta']
|
|
self.assertTrue(isinstance(delta, list))
|
|
self.assertEqual(len(delta), 2)
|
|
for d in delta:
|
|
self.assertTrue(isinstance(d, float))
|
|
unaccel = e['unaccel']
|
|
self.assertTrue(isinstance(unaccel, list))
|
|
self.assertEqual(len(unaccel), 2)
|
|
for d in unaccel:
|
|
self.assertTrue(isinstance(d, float))
|
|
|
|
def test_events_libinput_tablet_pad_button(self):
|
|
keys = ['type', 'time', 'button', 'state', 'mode', 'is-toggle']
|
|
|
|
for e in self.libinput_events('TABLET_PAD_BUTTON'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
|
|
b = e['button']
|
|
self.assertTrue(isinstance(b, int))
|
|
self.assertGreaterEqual(b, 0)
|
|
self.assertLessEqual(b, 16)
|
|
|
|
state = e['state']
|
|
self.assertIn(state, ['pressed', 'released'])
|
|
|
|
m = e['mode']
|
|
self.assertTrue(isinstance(m, int))
|
|
self.assertGreaterEqual(m, 0)
|
|
self.assertLessEqual(m, 3)
|
|
|
|
t = e['is-toggle']
|
|
self.assertTrue(isinstance(t, bool))
|
|
|
|
def test_events_libinput_tablet_pad_ring(self):
|
|
keys = ['type', 'time', 'number', 'position', 'source', 'mode']
|
|
|
|
for e in self.libinput_events('TABLET_PAD_RING'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
|
|
n = e['number']
|
|
self.assertTrue(isinstance(n, int))
|
|
self.assertGreaterEqual(n, 0)
|
|
self.assertLessEqual(n, 4)
|
|
|
|
p = e['position']
|
|
self.assertTrue(isinstance(p, float))
|
|
if p != -1.0: # special 'end' case
|
|
self.assertGreaterEqual(p, 0.0)
|
|
self.assertLess(p, 360.0)
|
|
|
|
m = e['mode']
|
|
self.assertTrue(isinstance(m, int))
|
|
self.assertGreaterEqual(m, 0)
|
|
self.assertLessEqual(m, 3)
|
|
|
|
s = e['source']
|
|
self.assertIn(s, ['finger', 'unknown'])
|
|
|
|
def test_events_libinput_tablet_pad_strip(self):
|
|
keys = ['type', 'time', 'number', 'position', 'source', 'mode']
|
|
|
|
for e in self.libinput_events('TABLET_PAD_STRIP'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
|
|
n = e['number']
|
|
self.assertTrue(isinstance(n, int))
|
|
self.assertGreaterEqual(n, 0)
|
|
self.assertLessEqual(n, 4)
|
|
|
|
p = e['position']
|
|
self.assertTrue(isinstance(p, float))
|
|
if p != -1.0: # special 'end' case
|
|
self.assertGreaterEqual(p, 0.0)
|
|
self.assertLessEqual(p, 1.0)
|
|
|
|
m = e['mode']
|
|
self.assertTrue(isinstance(m, int))
|
|
self.assertGreaterEqual(m, 0)
|
|
self.assertLessEqual(m, 3)
|
|
|
|
s = e['source']
|
|
self.assertIn(s, ['finger', 'unknown'])
|
|
|
|
def test_events_libinput_tablet_tool_proximity(self):
|
|
keys = ['type', 'time', 'proximity', 'tool-type', 'serial', 'axes']
|
|
|
|
for e in self.libinput_events('TABLET_TOOL_PROXIMITY'):
|
|
for k in keys:
|
|
self.assertIn(k, e)
|
|
|
|
p = e['proximity']
|
|
self.assertIn(p, ['in', 'out'])
|
|
|
|
p = e['tool-type']
|
|
self.assertIn(p, ['pen', 'eraser', 'brush', 'airbrush', 'mouse',
|
|
'lens', 'unknown'])
|
|
|
|
s = e['serial']
|
|
self.assertTrue(isinstance(s, int))
|
|
self.assertGreaterEqual(s, 0)
|
|
|
|
a = e['axes']
|
|
for ax in e['axes']:
|
|
self.assertIn(a, 'pdtrsw')
|
|
|
|
def test_events_libinput_tablet_tool(self):
|
|
keys = ['type', 'time', 'tip']
|
|
|
|
for e in self.libinput_events(['TABLET_TOOL_AXIS',
|
|
'TABLET_TOOL_TIP']):
|
|
for k in keys:
|
|
self.assertIn(k, e)
|
|
|
|
t = e['tip']
|
|
self.assertIn(t, ['down', 'up'])
|
|
|
|
def test_events_libinput_tablet_tool_button(self):
|
|
keys = ['type', 'time', 'button', 'state']
|
|
|
|
for e in self.libinput_events('TABLET_TOOL_BUTTON'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
|
|
b = e['button']
|
|
# STYLUS, STYLUS2, STYLUS3
|
|
self.assertIn(b, [0x14b, 0x14c, 0x139])
|
|
|
|
s = e['state']
|
|
self.assertIn(s, ['pressed', 'released'])
|
|
|
|
def test_events_libinput_tablet_tool_axes(self):
|
|
for e in self.libinput_events(['TABLET_TOOL_PROXIMITY',
|
|
'TABLET_TOOL_AXIS',
|
|
'TABLET_TOOL_TIP']):
|
|
|
|
point = e['point']
|
|
self.assertTrue(isinstance(point, list))
|
|
self.assertEqual(len(point), 2)
|
|
for p in point:
|
|
self.assertTrue(isinstance(p, float))
|
|
self.assertGreater(p, 0.0)
|
|
|
|
try:
|
|
tilt = e['tilt']
|
|
self.assertTrue(isinstance(tilt, list))
|
|
self.assertEqual(len(tilt), 2)
|
|
for t in tilt:
|
|
self.assertTrue(isinstance(t, float))
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
d = e['distance']
|
|
self.assertTrue(isinstance(d, float))
|
|
self.assertGreaterEqual(d, 0.0)
|
|
self.assertNotIn('pressure', e)
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
p = e['pressure']
|
|
self.assertTrue(isinstance(p, float))
|
|
self.assertGreaterEqual(p, 0.0)
|
|
self.assertNotIn('distance', e)
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
r = e['rotation']
|
|
self.assertTrue(isinstance(r, float))
|
|
self.assertGreaterEqual(r, 0.0)
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
s = e['slider']
|
|
self.assertTrue(isinstance(s, float))
|
|
self.assertGreaterEqual(s, 0.0)
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
w = e['wheel']
|
|
self.assertTrue(isinstance(w, float))
|
|
self.assertGreaterEqual(w, 0.0)
|
|
self.assertIn('wheel-discrete', e)
|
|
wd = e['wheel-discrete']
|
|
self.assertTrue(isinstance(wd, 1))
|
|
self.assertGreaterEqual(wd, 0.0)
|
|
|
|
def sign(x): (1, -1)[x < 0]
|
|
self.assertTrue(sign(w), sign(wd))
|
|
except KeyError:
|
|
pass
|
|
|
|
def test_events_libinput_switch(self):
|
|
keys = ['type', 'time', 'switch', 'state']
|
|
|
|
for e in self.libinput_events('SWITCH_TOGGLE'):
|
|
self.dict_key_crosscheck(e, keys)
|
|
|
|
s = e['switch']
|
|
self.assertTrue(isinstance(s, int))
|
|
self.assertIn(s, [0x00, 0x01])
|
|
|
|
# yaml converts on/off to true/false
|
|
state = e['state']
|
|
self.assertTrue(isinstance(state, bool))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser(description='Verify a YAML recording')
|
|
parser.add_argument('recording', metavar='recorded-file.yaml',
|
|
type=str, help='Path to device recording')
|
|
parser.add_argument('--verbose', action='store_true')
|
|
args, remainder = parser.parse_known_args()
|
|
TestYaml.filename = args.recording
|
|
verbosity = 1
|
|
if args.verbose:
|
|
verbosity = 3
|
|
|
|
argv = [sys.argv[0], *remainder]
|
|
unittest.main(argv=argv, verbosity=verbosity)
|