#!/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)