mirror of
https://gitlab.freedesktop.org/libinput/libinput.git
synced 2025-12-20 08:00:08 +01:00
1dbdef8fdb
Let's enforce a consistent (and verifiable) style everywhere. Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
688 lines
24 KiB
Python
Executable file
688 lines
24 KiB
Python
Executable file
#!/usr/bin/env 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)
|