One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""capture_x11 against a fake X connection: names, the raw-event parser, XTEST and absolute
filtering, buttons and the wheel as Windows messages, the grab taken and let go as the predicate
says, which side of a grab an event came from, events handed back played here, and the safety net
under a stuck thread. tools/x11_proof.sh runs the same module against a real X server."""
import struct
import sys
import threading
import time
import unittest
from pathlib import Path
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
sys.path.append(str(Path(__file__).resolve().parent.parent.parent))
import capture_x11 # noqa: E402
import sender # noqa: E402
from capture_x11 import Device # noqa: E402
from core.return_edge import Rect, ReturnEdge # noqa: E402
POINTER = Device(2, capture_x11.XI_MASTER_POINTER, "Virtual core pointer")
KEYBOARD = Device(3, capture_x11.XI_MASTER_KEYBOARD, "Virtual core keyboard")
XTEST_POINTER = Device(4, capture_x11.XI_SLAVE_POINTER, "Virtual core XTEST pointer")
XTEST_KEYBOARD = Device(5, 4, "Virtual core XTEST keyboard")
MOUSE = Device(6, capture_x11.XI_SLAVE_POINTER, "Logitech USB Receiver Mouse", scrolls={2: (False, 15.0), 3: (True, 15.0)})
TABLET = Device(7, capture_x11.XI_SLAVE_POINTER, "Wacom Intuos Pen", absolute=True)
KEYS = Device(8, 4, "AT Translated Set 2 keyboard")
U = 0x01000000
# keycode to its groups, each [level 1, level 2]
KEYMAP = {
38: [[ord("a"), ord("A")], [U | 0x444, U | 0x424], [ord("a"), ord("A")], [U | 0x3B1, U | 0x391]], # a; ф; a; α
10: [[ord("1"), ord("!")]],
48: [[ord("'"), ord('"')]],
87: [[0xFF9C, 0xFFB1]], # KP_End, KP_1
65: [[ord(" "), ord(" ")]],
34: [[0xFE52, 0xFE52]], # dead circumflex
}
class FakeKeymap:
"""XKB as far as these tests need it: Shift picks level 2, Caps Lock flips a letter, Num Lock
flips a keypad key, and a group the key does not have wraps."""
min_keycode, max_keycode = 8, 255
def keysym(self, keycode, mods, group):
groups = KEYMAP.get(keycode)
if not groups:
return 0
levels = groups[group % len(groups)]
level = 1 if mods & capture_x11.SHIFT_MASK else 0
upper = capture_x11.keysym_text(levels[1]) or ""
if mods & capture_x11.LOCK_MASK and upper.isalpha():
level ^= 1
if mods & capture_x11.NUM_LOCK_MASK and 0xFFAA <= levels[1] <= 0xFFB9:
level ^= 1
return levels[level]
def text(self, keysym):
return capture_x11.keysym_text(keysym)
def empty(self, keycode):
return keycode not in KEYMAP
def reload(self):
pass
def raw_bytes(detail=0, sourceid=6, flags=0, raw=None, deviceid=2):
"""An XI2 raw event's bytes after its first ten, as python-xlib hands them over."""
raw = raw or {}
numbers = sorted(raw)
mask_len = 1 if not numbers else max(numbers) // 32 + 1
mask = bytearray(mask_len * 4)
for number in numbers:
mask[number // 8] |= 1 << (number % 8)
data = struct.pack("=HIIHHI4x", deviceid, 1234, detail, sourceid, mask_len, flags) + bytes(mask)
for number in numbers: # accelerated, then raw: the accelerated ones doubled so a mix-up shows
value = raw[number] * 2
data += struct.pack("=iI", int(value // 1), int((value % 1) * 2 ** 32))
for number in numbers:
value = raw[number]
data += struct.pack("=iI", int(value // 1), int((value % 1) * 2 ** 32))
return data
class FakeConnection:
def __init__(self, devices=None):
self.device_list = devices or [POINTER, KEYBOARD, XTEST_POINTER, XTEST_KEYBOARD, MOUSE, TABLET, KEYS]
self.queue = []
self.grabs = []
self.refuse = set()
self.calls = []
self.seam_configs = []
self.mods, self.group = 0, 0
self.mapping = list(range(1, 11))
self.closed = False
self.aborted = False
self.raise_in_events = None
self.keymap = FakeKeymap()
self.serial = 100
self.lock = threading.Lock()
def next_serial(self):
self.serial += 1
return self.serial
def events(self, timeout):
if self.aborted:
raise ConnectionError("aborted")
if self.raise_in_events is not None:
raise self.raise_in_events
with self.lock:
found, self.queue = self.queue, []
if not found:
time.sleep(timeout / 10)
return found
def push(self, *events):
with self.lock:
self.queue.extend(events)
def devices(self):
return list(self.device_list)
def grab(self, device):
self.calls.append(("grab", device.deviceid))
if device.deviceid in self.refuse:
return None
self.grabs.append(device.deviceid)
return self.next_serial()
def ungrab(self, device):
self.calls.append(("ungrab", device.deviceid, self.held_while_ungrabbing()))
self.grabs.remove(device.deviceid)
return self.next_serial()
def fake_key(self, keycode, down):
self.calls.append(("fake_key", keycode, down, tuple(self.grabs)))
def fake_button(self, button, down):
self.calls.append(("fake_button", button, down, tuple(self.grabs)))
def pointer_mapping(self):
return list(self.mapping)
def state(self):
self.calls.append(("state",))
return self.mods, self.group
def configure_seams(self, monitors, resistance_px, enabled=True, display_map=None, models=()):
self.seam_configs.append((list(monitors), resistance_px, enabled, dict(display_map or {}), list(models)))
def abort(self):
self.aborted = True
held_while_ungrabbing = staticmethod(lambda: None)
def close(self):
self.closed = True
def raw(evtype, detail=0, sourceid=6, values=None, flags=0, sequence=0, master=None):
if master is None:
master = 3 if evtype in (capture_x11.XI_RAW_KEY_PRESS, capture_x11.XI_RAW_KEY_RELEASE) else 2
_deviceid, detail, sourceid, flags, parsed = capture_x11.parse_raw(raw_bytes(detail, sourceid, flags, values))
return ("raw", evtype, detail, sourceid, flags, parsed, master, sequence)
def key(down, keycode, mods=0, group=0, sourceid=8, flags=0, sequence=0):
return ("key", down, keycode, sourceid, flags, mods, group, 3, sequence)
class Recorder:
def __init__(self):
self.keys, self.mice, self.motions = [], [], []
self.answer = True
def on_key(self, name, down, vk, us):
self.keys.append((name, down, vk, us))
return self.answer
def on_mouse(self, message, x, y, data):
self.mice.append((message, data))
return self.answer
def on_motion(self, dx, dy):
self.motions.append((dx, dy))
class Harness(unittest.TestCase):
"""Drives Hooks' handlers directly on a fake connection, with no thread."""
def setUp(self):
self.connection = FakeConnection()
self.seen = Recorder()
self.hooks = capture_x11.Hooks(self.seen.on_key, self.seen.on_mouse, self.seen.on_motion, connect=lambda: self.connection)
self.hooks._connection = self.connection
self.hooks._read_devices()
self.hooks._buttons = self.connection.pointer_mapping()
def feed(self, *events):
for event in events:
self.hooks._handle(event)
def messages(self):
return [capture_x11.mouse_event(message, data) for message, data in self.seen.mice]
class ParseRawTest(unittest.TestCase):
def test_reads_the_raw_values_not_the_accelerated_ones(self):
deviceid, detail, sourceid, flags, values = capture_x11.parse_raw(raw_bytes(0, 6, 0, {0: 3.5, 1: -2.25}))
self.assertEqual((deviceid, detail, sourceid, flags), (2, 0, 6, 0))
self.assertEqual(values, {0: 3.5, 1: -2.25})
def test_reads_a_sparse_mask(self):
self.assertEqual(capture_x11.parse_raw(raw_bytes(raw={1: 4.0, 3: -1.0}))[4], {1: 4.0, 3: -1.0})
def test_a_key_event_has_no_valuators(self):
self.assertEqual(capture_x11.parse_raw(raw_bytes(detail=38, sourceid=8))[1:], (38, 8, 0, {}))
class NamesTest(unittest.TestCase):
def test_modifiers_are_named_as_windows_names_them(self):
names = capture_x11.VK_TO_NAME
self.assertEqual((names[29], names[97]), ("cmd", "cmd_r")) # Ctrl is "cmd", as on Windows
self.assertEqual((names[125], names[126]), ("ctrl", "ctrl_r")) # Super is "ctrl"
self.assertEqual((names[56], names[100], names[42], names[54]), ("alt", "alt_r", "shift", "shift_r"))
self.assertEqual((names[1], names[28], names[96], names[59], names[88], names[194]), ("esc", "enter", "numpad_enter", "f1", "f12", "f24"))
def test_the_trigger_names_and_titles_cover_the_default(self):
self.assertEqual(capture_x11.VK_TITLES[97], "Right Ctrl")
self.assertEqual(capture_x11.VK_TITLES[125], "Left Super")
self.assertNotIn(163, set(capture_x11.VK_TO_NAME) - capture_x11.NOT_TRIGGER_VKS) # media keys are not triggers
self.assertIn(57, capture_x11.UNRECORDABLE_TRIGGER_VKS)
self.assertEqual((capture_x11.VK_TO_NAME[122], capture_x11.VK_TO_NAME[123]), ("hangul", "hanja"))
self.assertEqual((capture_x11.VK_TITLES[122], capture_x11.VK_TITLES[123]), ("Han/Yeong", "Hanja"))
self.assertTrue({122, 123} <= capture_x11.NOT_TRIGGER_VKS)
self.assertFalse({"hangul", "hanja"} & capture_x11.MODIFIER_NAMES)
def test_hook_vk_is_the_keycode_less_eight(self):
self.assertEqual(capture_x11.hook_vk(0xFFE4, 105), 97)
self.assertEqual(capture_x11.hook_vk(0, 0), 0)
def test_input_titles(self):
self.assertEqual(capture_x11.input_title("key:97"), "Right Ctrl")
self.assertEqual(capture_x11.input_title("key:30"), "A")
self.assertEqual(capture_x11.input_title("key:240"), "Key 240")
self.assertEqual(capture_x11.input_title("button:back"), "Back button")
def test_keysym_text(self):
self.assertEqual(capture_x11.keysym_text(ord("a")), "a")
self.assertEqual(capture_x11.keysym_text(0xE9), "é")
self.assertEqual(capture_x11.keysym_text(0x010020AC), "€")
self.assertIsNone(capture_x11.keysym_text(0))
class CharacterTest(unittest.TestCase):
def char(self, keycode, mods=0, group=0):
return capture_x11.character(keycode, mods, group, FakeKeymap())
def test_shift_and_caps_lock(self):
self.assertEqual(self.char(38), "a")
self.assertEqual(self.char(38, capture_x11.SHIFT_MASK), "A")
self.assertEqual(self.char(38, capture_x11.LOCK_MASK), "A")
self.assertEqual(self.char(38, capture_x11.LOCK_MASK | capture_x11.SHIFT_MASK), "a")
self.assertEqual(self.char(10, capture_x11.SHIFT_MASK), "!")
self.assertEqual(self.char(10, capture_x11.LOCK_MASK), "1")
def test_a_chord_sends_the_plain_key(self):
self.assertEqual(self.char(38, capture_x11.CONTROL_MASK | capture_x11.SHIFT_MASK), "a")
self.assertEqual(self.char(38, capture_x11.MOD1_MASK | capture_x11.LOCK_MASK), "a")
self.assertEqual(self.char(10, capture_x11.MOD4_MASK | capture_x11.SHIFT_MASK), "1")
def test_every_group_the_layout_has(self):
self.assertEqual(self.char(38, 0, 1), "ф")
self.assertEqual(self.char(38, capture_x11.SHIFT_MASK, 1), "Ф")
self.assertEqual(self.char(38, 0, 3), "α") # a fourth group is read, not folded onto the first
self.assertEqual(self.char(10, 0, 1), "1") # a key without the group wraps
def test_the_keypad(self):
self.assertEqual(self.char(87), "end") # Num Lock off: it moves, as Windows' VK_END
self.assertEqual(self.char(87, capture_x11.NUM_LOCK_MASK), "1")
self.assertEqual(self.char(87, capture_x11.NUM_LOCK_MASK | capture_x11.CONTROL_MASK), "1")
def test_a_dead_key_types_nothing(self):
self.assertIsNone(self.char(34))
class KeyTest(Harness):
def make_sender(self, messages, ignored=()):
class Owner:
away = True
on = b"synthetic-peer"
def input(self, message):
messages.append(message)
return []
link_sender = sender.LinkSender.__new__(sender.LinkSender)
link_sender._owner = Owner()
link_sender.links = type("Links", (), {"live": lambda _self, _peer: True})()
link_sender._ignore_gate = sender.ignored.Gate(ignored)
link_sender._input_method_tap_releases = set()
link_sender._lock = threading.RLock()
link_sender._queue = lambda _actions: None
link_sender._report = lambda _actions: None
self.hooks._on_key = link_sender.on_key
def test_flagged_ime_repeat_makes_one_sender_tap_but_a_later_press_still_taps(self):
for keycode, name in ((130, "hangul"), (131, "hanja")):
with self.subTest(name=name):
messages = []
self.make_sender(messages)
self.feed(key(True, keycode), key(True, keycode, flags=capture_x11.XI_KEY_REPEAT),
key(False, keycode), key(True, keycode), key(False, keycode))
self.assertEqual(messages, [
{"type": "keydown", "data": {"key": name}},
{"type": "keyup", "data": {"key": name}},
{"type": "keydown", "data": {"key": name}},
{"type": "keyup", "data": {"key": name}},
])
def test_flagged_ime_repeat_still_replays_a_locally_ignored_press(self):
messages = []
self.make_sender(messages, ("key:122",))
self.feed(key(True, 130), key(True, 130, flags=capture_x11.XI_KEY_REPEAT), key(False, 130))
self.assertEqual(messages, [])
self.assertEqual([call for call in self.connection.calls if call[0] == "fake_key"], [
("fake_key", 130, True, ()),
("fake_key", 130, True, ()),
("fake_key", 130, False, ()),
])
def test_a_named_key_outside_a_grab_from_a_raw_event(self):
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=8), raw(capture_x11.XI_RAW_KEY_RELEASE, 105, sourceid=8))
self.assertEqual(self.seen.keys, [("cmd_r", True, 97, None), ("cmd_r", False, 97, None)])
self.assertNotIn(("state",), self.connection.calls)
def test_a_character_outside_a_grab_reads_the_state_once(self):
self.connection.mods = capture_x11.SHIFT_MASK
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 38, sourceid=8))
self.assertEqual(self.seen.keys, [("A", True, 30, "a")])
self.assertEqual(self.connection.calls.count(("state",)), 1)
def test_a_release_goes_out_under_its_press_s_name(self):
self.connection.mods = capture_x11.NUM_LOCK_MASK
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 87, sourceid=8))
self.connection.mods = 0 # Num Lock turned off while 1 is held
self.feed(raw(capture_x11.XI_RAW_KEY_RELEASE, 87, sourceid=8))
self.assertEqual(self.seen.keys, [("numpad_1", True, 79, None), ("numpad_1", False, 79, None)])
def test_keys_from_inside_a_grab_come_from_the_grab(self):
self.hooks.grab_while(lambda: True)
self.hooks._tick()
inside = self.connection.serial
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 38, sourceid=8, sequence=inside), key(True, 38, capture_x11.SHIFT_MASK, sequence=inside),
key(True, 38, capture_x11.SHIFT_MASK, flags=capture_x11.XI_KEY_REPEAT, sequence=inside),
raw(capture_x11.XI_RAW_KEY_RELEASE, 38, sourceid=8, sequence=inside), key(False, 38, sequence=inside))
self.assertEqual(self.seen.keys, [("A", True, 30, "a"), ("A", True, 30, "a"), ("A", False, 30, "a")])
self.assertNotIn(("state",), self.connection.calls)
def test_a_raw_key_from_before_the_grab_still_counts_after_it(self):
# Hold style, a quick tap: the release is queued before the grab and read after it.
before = self.connection.serial
self.hooks.grab_while(lambda: True)
self.hooks._tick()
self.feed(raw(capture_x11.XI_RAW_KEY_RELEASE, 105, sourceid=8, sequence=before))
self.assertEqual(self.seen.keys, [("cmd_r", False, 97, None)])
def test_a_raw_key_from_inside_a_grab_read_after_it_is_not_read_twice(self):
away = [True]
self.hooks.grab_while(lambda: away[0])
self.hooks._tick()
inside = self.connection.serial
away[0] = False
self.hooks._tick()
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=8, sequence=inside), key(True, 105, sequence=inside))
self.assertEqual(self.seen.keys, [("cmd_r", True, 97, None)])
after = self.connection.serial
self.feed(raw(capture_x11.XI_RAW_KEY_RELEASE, 105, sourceid=8, sequence=after))
self.assertEqual(self.seen.keys[-1], ("cmd_r", False, 97, None))
def test_sequence_numbers_wrap(self):
self.assertTrue(capture_x11._at_or_after(3, 0xFFFE))
self.assertFalse(capture_x11._at_or_after(0xFFFE, 3))
def test_injected_keys_are_dropped_unless_asked_for(self):
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=5), key(True, 105, sourceid=5))
self.assertEqual(self.seen.keys, [])
self.hooks.drop_injected = False
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=5))
self.assertEqual(self.seen.keys, [("cmd_r", True, 97, None)])
def test_a_dead_key_is_not_reported(self):
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 34, sourceid=8))
self.assertEqual(self.seen.keys, [])
class HandedBackTest(Harness):
"""An input the sender hands back from inside a grab reached no app; it is played here."""
def setUp(self):
super().setUp()
self.hooks.grab_while(lambda: True)
self.hooks._tick()
self.inside = self.connection.serial
self.seen.answer = False
def test_a_key_is_played_with_the_keyboard_let_go_around_it(self):
self.feed(key(True, 123, sequence=self.inside)) # volume up, on the stays-here list
self.assertEqual([call for call in self.connection.calls if call[0] == "fake_key"], [("fake_key", 123, True, (2,))])
self.assertEqual(sorted(self.connection.grabs), [2, 3])
def test_a_button_and_the_wheel_are_played_with_the_pointer_let_go(self):
self.feed(raw(capture_x11.XI_RAW_BUTTON_PRESS, 8, sequence=self.inside), raw(capture_x11.XI_RAW_BUTTON_PRESS, 4, sequence=self.inside))
fakes = [call for call in self.connection.calls if call[0] == "fake_button"]
self.assertEqual(fakes, [("fake_button", 8, True, (3,)), ("fake_button", 4, True, (3,)), ("fake_button", 4, False, (3,))])
self.assertEqual(sorted(self.connection.grabs), [2, 3])
def test_nothing_from_outside_a_grab_is_played(self):
self.feed(raw(capture_x11.XI_RAW_KEY_PRESS, 123, sourceid=8, sequence=self.inside - 1),
raw(capture_x11.XI_RAW_BUTTON_PRESS, 8, sequence=self.inside - 2))
self.assertEqual([call for call in self.connection.calls if call[0].startswith("fake")], [])
def test_a_grab_refused_after_playing_lets_go_of_everything(self):
self.connection.refuse = {3}
self.feed(key(True, 123, sequence=self.inside))
self.assertEqual(self.connection.grabs, [])
self.assertFalse(self.hooks.grabbed)
class PlayedTest(Harness):
"""What was played here stays held only until its own release, whichever way that comes."""
def setUp(self):
super().setUp()
self.away = True
self.hooks.grab_while(lambda: self.away)
self.hooks._tick()
self.inside = self.connection.serial
def fakes(self):
return [call[:3] for call in self.connection.calls if call[0].startswith("fake")]
def test_a_played_key_is_let_go_when_its_release_comes_from_outside_the_grab(self):
self.seen.answer = False
self.feed(key(True, 123, sequence=self.inside))
self.away = False
self.hooks._tick()
self.seen.answer = True # at home the sender keeps nothing
self.feed(raw(capture_x11.XI_RAW_KEY_RELEASE, 123, sourceid=8, sequence=self.connection.serial))
self.assertEqual(self.fakes(), [("fake_key", 123, True), ("fake_key", 123, False)])
def test_a_played_button_is_let_go_by_its_release(self):
self.seen.answer = False
self.feed(raw(capture_x11.XI_RAW_BUTTON_PRESS, 9, sequence=self.inside))
self.seen.answer = True
self.feed(raw(capture_x11.XI_RAW_BUTTON_RELEASE, 9, sequence=self.inside))
self.assertEqual(self.fakes(), [("fake_button", 9, True), ("fake_button", 9, False)])
def test_whatever_is_still_played_is_let_go_when_capture_ends(self):
self.seen.answer = False
self.feed(key(True, 123, sequence=self.inside), raw(capture_x11.XI_RAW_BUTTON_PRESS, 8, sequence=self.inside))
self.hooks._release_played()
self.assertEqual(self.fakes()[-2:], [("fake_key", 123, False), ("fake_button", 8, False)])
class SpanTest(Harness):
def test_a_let_go_span_is_forgotten_before_the_sequence_comes_round(self):
away = [True]
self.hooks.grab_while(lambda: away[0])
self.hooks._tick()
inside = self.connection.serial
away[0] = False
self.hooks._tick()
self.assertTrue(self.hooks._inside(3, inside))
with mock.patch.object(capture_x11, "SPAN_KEEP_SECONDS", -1):
self.assertFalse(self.hooks._inside(3, inside)) # one lap on, the same number is outside
def test_the_grab_counts_as_held_through_the_ungrab_s_round_trip(self):
self.connection.held_while_ungrabbing = lambda: self.hooks.grabbed
self.hooks.grab_while(lambda: True)
self.hooks._tick()
self.hooks._let_go()
self.assertEqual([call[2] for call in self.connection.calls if call[0] == "ungrab"], [True, True])
class MouseTest(Harness):
def test_buttons_as_windows_messages(self):
for number in (1, 2, 3, 8, 9):
self.feed(raw(capture_x11.XI_RAW_BUTTON_PRESS, number), raw(capture_x11.XI_RAW_BUTTON_RELEASE, number))
self.assertEqual(self.messages(), [("button", name, down) for name in ("left", "middle", "right", "back", "forward") for down in (True, False)])
def test_buttons_follow_the_pointer_mapping(self):
self.connection.mapping = [3, 2, 1] + list(range(4, 11)) # left-handed
self.feed(("mapping", capture_x11.MAPPING_POINTER), raw(capture_x11.XI_RAW_BUTTON_PRESS, 1))
self.assertEqual(self.messages(), [("button", "right", True)])
def test_the_wheel_buttons_on_press_only(self):
for number in (4, 5, 6, 7):
self.feed(raw(capture_x11.XI_RAW_BUTTON_PRESS, number, sourceid=9), raw(capture_x11.XI_RAW_BUTTON_RELEASE, number, sourceid=9))
self.assertEqual(self.messages(), [("wheel", 1.0, 0.0), ("wheel", -1.0, 0.0), ("wheel", 0.0, -1.0), ("wheel", 0.0, 1.0)])
def test_a_smooth_scrolling_wheel_is_its_valuators_and_its_emulated_buttons_are_skipped(self):
self.feed(raw(capture_x11.XI_RAW_BUTTON_PRESS, 5, flags=capture_x11.XI_POINTER_EMULATED),
raw(capture_x11.XI_RAW_MOTION, values={3: 15.0}), raw(capture_x11.XI_RAW_MOTION, values={3: -7.5}),
raw(capture_x11.XI_RAW_MOTION, values={3: -7.5}), raw(capture_x11.XI_RAW_MOTION, values={2: 15.0}))
self.assertEqual(self.messages(), [("wheel", -1.0, 0.0), ("wheel", 0.5, 0.0), ("wheel", 0.5, 0.0), ("wheel", 0.0, 1.0)])
self.assertEqual(self.seen.motions, [])
def test_motion_carries_its_fraction_and_moves_the_pin(self):
self.feed(raw(capture_x11.XI_RAW_MOTION, values={0: 0.6, 1: -1.5}), raw(capture_x11.XI_RAW_MOTION, values={0: 0.6, 1: -0.5}))
self.assertEqual(self.seen.motions, [(0, -1), (1, -1)])
self.assertEqual(self.seen.mice, [(capture_x11.WM_MOUSEMOVE, 0)] * 2)
def test_injected_motion_is_dropped(self):
self.feed(raw(capture_x11.XI_RAW_MOTION, sourceid=4, values={0: 5.0, 1: 0.0}), raw(capture_x11.XI_RAW_BUTTON_PRESS, 1, sourceid=4))
self.assertEqual((self.seen.motions, self.seen.mice), ([], []))
def test_an_absolute_pointer_moves_the_pin_but_gives_no_pressure(self):
self.feed(raw(capture_x11.XI_RAW_MOTION, sourceid=7, values={0: 900.0, 1: 300.0}))
self.assertEqual((self.seen.motions, self.seen.mice), ([], [(capture_x11.WM_MOUSEMOVE, 0)]))
def test_a_new_device_is_read_on_a_hierarchy_change(self):
self.connection.device_list.append(Device(9, capture_x11.XI_SLAVE_POINTER, "Virtual XTEST pointer 2"))
self.feed(("hierarchy",), raw(capture_x11.XI_RAW_MOTION, sourceid=9, values={0: 5.0}))
self.assertEqual(self.seen.motions, [])
class GrabTest(Harness):
def setUp(self):
super().setUp()
self.away = False
self.hooks.grab_while(lambda: self.away)
def test_grabs_every_master_while_away_and_lets_go_at_home(self):
self.hooks._tick()
self.assertEqual(self.connection.grabs, [])
self.away = True
self.hooks._tick()
self.hooks._tick()
self.assertEqual(self.connection.grabs, [2, 3])
self.assertEqual(self.connection.calls.count(("grab", 2)), 1)
self.away = False
self.hooks._tick()
self.assertEqual(self.connection.grabs, [])
self.assertFalse(self.hooks.grabbed)
def test_a_refused_grab_holds_nothing_and_is_tried_again(self):
self.connection.refuse = {3}
self.away = True
with self.assertLogs(capture_x11.LOGGER, "WARNING") as logs:
self.hooks._tick()
self.hooks._tick()
self.assertEqual(len(logs.records), 1)
self.assertEqual(self.connection.grabs, [])
self.connection.refuse = set()
self.hooks._tick()
self.assertEqual(self.connection.grabs, [2, 3])
def test_a_predicate_that_raises_lets_go(self):
self.away = True
self.hooks._tick()
def broken():
raise RuntimeError("no")
self.hooks.grab_while(broken)
with self.assertLogs(capture_x11.LOGGER, "ERROR"):
self.hooks._tick()
self.assertEqual(self.connection.grabs, [])
def test_a_new_master_while_away_is_grabbed_too(self):
self.away = True
self.hooks._tick()
self.connection.device_list += [Device(10, capture_x11.XI_MASTER_POINTER, "Second pointer"),
Device(11, capture_x11.XI_MASTER_KEYBOARD, "Second keyboard")]
self.feed(("hierarchy",))
self.assertEqual(self.connection.grabs, [])
self.hooks._tick()
self.assertEqual(sorted(self.connection.grabs), [2, 3, 10, 11])
def test_raw_events_still_count_while_grabbed(self):
self.away = True
self.hooks._tick()
inside = self.connection.serial
self.feed(raw(capture_x11.XI_RAW_MOTION, values={0: 4.0, 1: 0.0}, sequence=inside), raw(capture_x11.XI_RAW_BUTTON_PRESS, 1, sequence=inside))
self.assertEqual(self.seen.motions, [(4, 0)])
self.assertEqual(self.messages()[-1], ("button", "left", True))
class ThreadTest(unittest.TestCase):
def make(self, connection, on_key=None):
self.seen = Recorder()
return capture_x11.Hooks(on_key or self.seen.on_key, self.seen.on_mouse, self.seen.on_motion, connect=lambda: connection)
def wait_for(self, condition, timeout=2.0):
end = time.monotonic() + timeout
while time.monotonic() < end:
if condition():
return True
time.sleep(0.01)
return condition()
def test_stop_lets_go_and_closes(self):
connection = FakeConnection()
hooks = self.make(connection)
hooks.grab_while(lambda: True)
hooks.start()
self.assertTrue(self.wait_for(lambda: connection.grabs == [2, 3]))
hooks.stop()
self.assertEqual(connection.grabs, [])
self.assertTrue(connection.closed)
def test_seam_sources_follow_zone_and_monitor_changes_while_capture_runs(self):
connection = FakeConnection()
hooks = self.make(connection)
monitors = [Rect(0, 0, 100, 100)]
display_map = {"0": monitors[0]}
models = []
hooks.configure_seams(lambda: monitors, 30, display_map=lambda: display_map,
models=lambda: models)
hooks.start()
self.assertTrue(self.wait_for(lambda: connection.seam_configs))
self.assertEqual(connection.seam_configs[-1][4], [])
monitors[:] = [Rect(0, 0, 100, 100), Rect(100, 0, 100, 100)]
display_map["1"] = monitors[1]
models[:] = [ReturnEdge("right", display="0")]
self.assertTrue(self.wait_for(lambda: connection.seam_configs[-1][4] == models
and len(connection.seam_configs[-1][0]) == 2))
hooks.stop()
def test_the_loop_dying_lets_go(self):
connection = FakeConnection()
hooks = self.make(connection)
hooks.grab_while(lambda: True)
hooks.start()
self.assertTrue(self.wait_for(lambda: connection.grabs == [2, 3]))
with self.assertLogs(capture_x11.LOGGER, "ERROR"):
connection.raise_in_events = ConnectionError("the X server went away")
self.assertTrue(self.wait_for(lambda: connection.closed))
self.assertEqual(connection.grabs, [])
hooks.stop()
def test_an_event_that_fails_does_not_stop_capture(self):
connection = FakeConnection()
hooks = self.make(connection)
hooks.start()
with self.assertLogs(capture_x11.LOGGER, "ERROR"):
connection.push(("raw", capture_x11.XI_RAW_MOTION, 0, 6, 0, None, 2, 0)) # a malformed event
connection.push(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=8))
self.assertTrue(self.wait_for(lambda: self.seen.keys))
hooks.stop()
self.assertEqual(self.seen.keys, [("cmd_r", True, 97, None)])
def test_capture_ending_on_its_own_is_reported_and_a_stop_is_not(self):
connection = FakeConnection()
hooks = self.make(connection)
failures = []
hooks.on_failure = failures.append
hooks.start()
with self.assertLogs(capture_x11.LOGGER, "ERROR"):
connection.raise_in_events = ConnectionError("the X server went away")
self.assertTrue(self.wait_for(lambda: failures))
hooks.stop()
self.assertIsInstance(failures[0], ConnectionError)
quiet = FakeConnection()
hooks = self.make(quiet)
hooks.on_failure = failures.append
hooks.start()
hooks.stop()
self.assertEqual(len(failures), 1)
def test_a_connection_that_cannot_open_is_the_caller_s_error(self):
def refuse():
raise RuntimeError("This X server has XInput 2.0; Beamer needs 2.1")
hooks = capture_x11.Hooks(None, None, None, connect=refuse)
with self.assertLogs(capture_x11.LOGGER, "ERROR"), self.assertRaisesRegex(RuntimeError, "needs 2.1"):
hooks.start()
def test_a_thread_stuck_while_grabbed_has_its_connection_ended(self):
connection = FakeConnection()
release = threading.Event()
def stuck(*args):
release.wait(5)
return True
hooks = self.make(connection, on_key=stuck)
hooks.grab_while(lambda: True)
with mock.patch.object(capture_x11, "STALL_SECONDS", 0.3):
hooks.start()
self.assertTrue(self.wait_for(lambda: connection.grabs == [2, 3]))
with self.assertLogs(capture_x11.LOGGER, "ERROR") as logs:
connection.push(key(True, 38, sequence=connection.serial))
self.assertTrue(self.wait_for(lambda: connection.aborted))
release.set()
self.assertTrue(self.wait_for(lambda: connection.closed))
self.assertIn("has not answered", logs.output[0])
hooks.stop()
def test_a_stop_that_times_out_ends_the_connection_and_a_start_waits_for_it(self):
connection = FakeConnection()
release = threading.Event()
def stuck(*args):
release.wait(10)
return True
hooks = self.make(connection, on_key=stuck)
hooks.start()
connection.push(raw(capture_x11.XI_RAW_KEY_PRESS, 105, sourceid=8))
time.sleep(0.2)
with mock.patch.object(threading.Thread, "join", lambda self, timeout=None: None), \
self.assertLogs(capture_x11.LOGGER, "ERROR"):
hooks.stop()
self.assertTrue(connection.aborted)
with self.assertRaisesRegex(RuntimeError, "has not stopped"):
hooks.start()
release.set()
self.assertTrue(self.wait_for(lambda: connection.closed))
if __name__ == "__main__":
unittest.main()