Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

15.7 KB
Raw Blame
"""inject_x11's planning on a fake layout, and its functions against a fake connection.
tools/x11_proof.sh types through the same module on a real X server and reads it back."""

import sys
import unittest
from unittest import mock
from pathlib import Path

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 inject_x11  # noqa: E402
from inject_x11 import MAP, NO_REPEAT, PRESS, RELEASE, REPEAT, KeyState, Layout  # noqa: E402

U = 0x01000000
SHIFT_L, SHIFT_R, CTRL_L = 50, 62, 37
A, ONE, C, E, SEVEN = 38, 10, 54, 26, 16
CAPS = capture_x11.LOCK_MASK


class FakeKeymap:
    """A US layout in group one and Russian in group two, the 7 key typing / with Shift as on a
    German keyboard, and two empty keycodes. Shift picks level 2, Caps Lock flips a letter."""

    min_keycode, max_keycode = 8, 202

    def __init__(self):
        self.rows = {
            A: [[ord("a"), ord("A")], [U | 0x444, U | 0x424]],  # ф Ф
            C: [[ord("c"), ord("C")], [U | 0x441, U | 0x421]],  # с С
            E: [[ord("e"), ord("E")], [U | 0x443, U | 0x423]],  # у У
            ONE: [[ord("1"), ord("!")]],
            SEVEN: [[ord("7"), ord("/")]],
            SHIFT_L: [[0xFFE1, 0xFFE1]],
        }
        for keycode in range(self.min_keycode, self.max_keycode + 1):
            if keycode not in self.rows and keycode not in (200, 201):
                self.rows[keycode] = [[0xFF00 + keycode, 0xFF00 + keycode]]  # something with no text

    def keysym(self, keycode, mods, group):
        groups = self.rows.get(keycode)
        if not groups:
            return 0
        levels = groups[group % len(groups)]
        level = 1 if mods & capture_x11.SHIFT_MASK else 0
        if mods & CAPS and (capture_x11.keysym_text(levels[1]) or "").isalpha():
            level ^= 1
        return levels[level]

    def text(self, keysym):
        return capture_x11.keysym_text(keysym) if keysym < 0xFF00 or keysym > 0xFFFF else None

    def empty(self, keycode):
        return keycode not in self.rows


def plan(name, down=True, us=None, state=None, layout=None, group=0, locks=0):
    state = state if state is not None else KeyState()
    return inject_x11.plan_key(name, down, us, state, layout or Layout(FakeKeymap()), group, locks)


class NamedKeyTest(unittest.TestCase):
    def test_named_keys_by_evdev_code(self):
        self.assertEqual(plan("enter"), [(PRESS, 36)])
        self.assertEqual(plan("return", down=False), [(RELEASE, 36)])
        self.assertEqual(plan("cmd"), [(PRESS, 133)])  # Super
        self.assertEqual(plan("ctrl_r"), [(PRESS, 105)])
        self.assertEqual(plan("alt_r"), [(PRESS, 108)])
        self.assertEqual(plan("f24"), [(PRESS, 202)])
        self.assertEqual(plan("media_play_pause"), [(PRESS, 172)])
        self.assertEqual(plan("hangul"), [(PRESS, 130)])
        self.assertEqual(plan("hanja"), [(PRESS, 131)])

    def test_search_intents_open_the_gnome_activities_key(self):
        self.assertEqual(plan("spotlight"), [(PRESS, 133)])
        self.assertEqual(plan("spotlight", down=False), [(RELEASE, 133)])

    def test_the_server_repeats_a_held_named_key(self):
        state = KeyState()
        self.assertEqual(plan("backspace", state=state), [(PRESS, 22)])
        self.assertEqual(plan("backspace", state=state), [])
        self.assertEqual(plan("backspace", down=False, state=state), [(RELEASE, 22)])
        self.assertEqual(plan("backspace", state=state), [(PRESS, 22)])

    def test_modifiers_are_tracked(self):
        state = KeyState()
        plan("ctrl", state=state)
        plan("shift_r", state=state)
        self.assertEqual(state.mods_down, {"ctrl", "shift_r"})
        plan("ctrl", down=False, state=state)
        self.assertEqual(state.mods_down, {"shift_r"})

    def test_an_unknown_name_is_dropped(self):
        old_names = {name: code for name, code in inject_x11.NAME_TO_CODE.items() if name not in ("hangul", "hanja")}
        with mock.patch.object(inject_x11, "NAME_TO_CODE", old_names):
            for name in ("hangul", "hanja"):
                with self.subTest(name=name), self.assertLogs(inject_x11.LOGGER, "WARNING"):
                    self.assertEqual(plan(name), [])


class CharacterTest(unittest.TestCase):
    def test_a_plain_character_and_the_server_s_repeat(self):
        state = KeyState()
        self.assertEqual(plan("a", state=state), [(PRESS, A)])
        self.assertEqual(plan("a", state=state), [])  # the peer's repeat: the server is repeating it
        self.assertEqual(plan("a", down=False, state=state), [(RELEASE, A)])
        self.assertEqual(state.chars_down, {})

    def test_shift_is_pressed_around_a_character_that_needs_it(self):
        state = KeyState()
        self.assertEqual(plan("!", state=state), [(NO_REPEAT, ONE), (PRESS, SHIFT_L), (PRESS, ONE), (RELEASE, SHIFT_L)])
        # Each of the peer's repeats is typed again with its Shift, the server's being off for it.
        self.assertEqual(plan("!", state=state), [(RELEASE, ONE), (PRESS, SHIFT_L), (PRESS, ONE), (RELEASE, SHIFT_L)])
        self.assertEqual(plan("!", down=False, state=state), [(RELEASE, ONE), (REPEAT, ONE)])

    def test_a_german_slash_repeats_as_a_slash(self):
        state = KeyState()
        plan("/", state=state)
        self.assertEqual(plan("/", state=state), [(RELEASE, SEVEN), (PRESS, SHIFT_L), (PRESS, SEVEN), (RELEASE, SHIFT_L)])

    def test_a_repeat_works_shift_out_again_when_the_peer_s_shift_changed(self):
        state = KeyState()
        plan("shift", state=state)
        self.assertEqual(plan("1", state=state), [(NO_REPEAT, ONE), (RELEASE, SHIFT_L), (PRESS, ONE), (PRESS, SHIFT_L)])
        plan("shift", down=False, state=state)
        self.assertEqual(plan("1", state=state), [(RELEASE, ONE), (PRESS, ONE)])  # no Shift pressed for nobody

    def test_a_held_shift_is_let_go_around_a_character_that_must_not_have_it(self):
        state = KeyState()
        plan("shift_r", state=state)
        self.assertEqual(plan("1", state=state), [(NO_REPEAT, ONE), (RELEASE, SHIFT_R), (PRESS, ONE), (PRESS, SHIFT_R)])
        self.assertEqual(plan("A", state=state), [(PRESS, A)])

    def test_caps_lock_as_the_layout_applies_it(self):
        self.assertEqual(plan("A", locks=CAPS), [(PRESS, A)])
        self.assertEqual(plan("a", locks=CAPS), [(NO_REPEAT, A), (PRESS, SHIFT_L), (PRESS, A), (RELEASE, SHIFT_L)])
        self.assertEqual(plan("!", locks=CAPS), [(NO_REPEAT, ONE), (PRESS, SHIFT_L), (PRESS, ONE), (RELEASE, SHIFT_L)])

    def test_caps_capitals_keep_chord_keys_in_latin_and_non_latin_layouts(self):
        for character, group in (("A", 0), ("Ф", 1)):
            for locks in (0, CAPS):
                for modifier in sorted(inject_x11.CHORD_KEYS):
                    for shifted in (False, True):
                        with self.subTest(character=character, locks=locks, modifier=modifier, shifted=shifted):
                            state = KeyState()
                            plan(modifier, state=state)
                            if shifted:
                                plan("shift", state=state)
                            self.assertEqual(plan(character, state=state, group=group, locks=locks), [(PRESS, A)])
                            state.mods_down.clear()
                            self.assertEqual(plan(character, down=False, state=state, group=group, locks=locks), [(RELEASE, A)])
                            self.assertEqual(state.chars_down, {})

    def test_under_a_chord_shift_is_the_peer_s(self):
        state = KeyState()
        plan("ctrl", state=state)
        plan("shift", state=state)
        self.assertEqual(plan("a", state=state), [(PRESS, A)])

    def test_the_current_group(self):
        self.assertEqual(plan("ф", group=1), [(PRESS, A)])
        self.assertEqual(plan("Ф", group=1), [(NO_REPEAT, A), (PRESS, SHIFT_L), (PRESS, A), (RELEASE, SHIFT_L)])
        self.assertEqual(plan("1", group=1), [(PRESS, ONE)])  # a key without the group wraps
        self.assertEqual(plan("ф", group=3), [(PRESS, A)])  # a fourth group, wrapped as XKB wraps it

    def test_a_repeat_and_its_release_stay_on_the_first_key(self):
        state = KeyState()
        layout = Layout(FakeKeymap())
        plan("a", state=state, layout=layout)
        self.assertEqual(plan("a", state=state, layout=layout, group=1), [])
        self.assertEqual(plan("a", down=False, state=state, layout=layout, group=1), [(RELEASE, A)])

    def test_by_place_under_a_chord(self):
        state = KeyState()
        plan("ctrl", state=state)
        # Ctrl-C from an English Mac to Russian: no key types "c", so the key in C's place.
        self.assertEqual(plan("c", us="c", state=state, group=1), [(PRESS, C)])

    def test_by_place_for_another_script_s_letter(self):
        # A Russian Mac types "у" on its E key; on this English layout that is the E key too.
        self.assertEqual(plan("у", us="e"), [(PRESS, E)])

    def test_a_character_on_no_key_gets_a_spare_that_stays_mapped(self):
        state = KeyState()
        layout = Layout(FakeKeymap())
        self.assertEqual(plan("é", state=state, layout=layout), [(MAP, 201, 0xE9, False), (PRESS, 201)])
        plan("é", down=False, state=state, layout=layout)
        self.assertEqual(plan("é", state=state, layout=layout), [(PRESS, 201)])
        self.assertEqual(plan("€", state=state, layout=layout), [(MAP, 200, U | 0x20AC, False), (PRESS, 200)])

    def test_a_spare_wiped_by_a_new_keymap_is_mapped_again(self):
        state = KeyState()
        plan("é", state=state, layout=Layout(FakeKeymap()))
        plan("é", down=False, state=state, layout=Layout(FakeKeymap()))
        self.assertEqual(plan("é", state=state, layout=Layout(FakeKeymap())), [(MAP, 201, 0xE9, False), (PRESS, 201)])

    def test_the_least_recent_free_spare_is_reused_after_a_pause(self):
        state = KeyState()
        layout = Layout(FakeKeymap())
        plan("é", state=state, layout=layout)
        plan("é", down=False, state=state, layout=layout)
        plan("€", state=state, layout=layout)  # held
        self.assertEqual(plan("ß", state=state, layout=layout), [(MAP, 201, 0xDF, True), (PRESS, 201)])
        with self.assertLogs(inject_x11.LOGGER, "WARNING"):
            self.assertEqual(plan("ñ", state=state, layout=layout), [])  # both spares held


class TextTest(unittest.TestCase):
    def test_text_lets_held_modifiers_go_and_presses_them_again(self):
        state = KeyState()
        plan("ctrl", state=state)
        plan("shift", state=state)
        steps = inject_x11.plan_text("a!", state, Layout(FakeKeymap()), 0, 0)
        self.assertEqual(steps, [
            (RELEASE, CTRL_L), (RELEASE, SHIFT_L),
            (PRESS, A), (RELEASE, A),
            (PRESS, SHIFT_L), (PRESS, ONE), (RELEASE, SHIFT_L), (RELEASE, ONE),
            (PRESS, CTRL_L), (PRESS, SHIFT_L),
        ])
        self.assertEqual(state.mods_down, {"ctrl", "shift"})

    def test_text_off_the_layout_uses_a_spare(self):
        self.assertEqual(inject_x11.plan_text("é", KeyState(), Layout(FakeKeymap()), 0, 0),
                         [(MAP, 201, 0xE9, False), (PRESS, 201), (RELEASE, 201)])


class ScrollTest(unittest.TestCase):
    def test_line_clicks(self):
        carry = [0.0, 0.0]
        self.assertEqual(inject_x11.plan_scroll(2, 1, "line", carry), (2, -1))
        self.assertEqual(inject_x11.scroll_buttons(2, -1), [4, 4, 6])
        self.assertEqual(inject_x11.scroll_buttons(-1, 1), [5, 7])

    def test_pixels_carry_their_remainder(self):
        carry = [0.0, 0.0]
        self.assertEqual(inject_x11.plan_scroll(30, 0, "pixel", carry), (0, 0))
        self.assertEqual(inject_x11.plan_scroll(30, 0, "pixel", carry), (1, 0))
        self.assertAlmostEqual(carry[0], 0.5)

    def test_a_fractional_line_carries(self):
        carry = [0.0, 0.0]
        self.assertEqual(inject_x11.plan_scroll(0.5, 0, "line", carry), (0, 0))
        self.assertEqual(inject_x11.plan_scroll(0.5, 0, "line", carry), (1, 0))


class FakeConnection:
    def __init__(self):
        self.sent = []
        self.changed = False
        self.group, self.locks = 0, 0
        self.closed = False
        self.fail = None
        self.repeat_restored = 0

    def layout(self):
        return Layout(FakeKeymap())

    def mapping_changed(self):
        changed, self.changed = self.changed, False
        return changed

    def state(self):
        return self.group, self.locks

    def run(self, steps):
        if self.fail is not None:
            raise self.fail
        self.sent.extend(steps)

    def restore_repeat(self):
        self.repeat_restored += 1

    def button(self, number, down):
        self.sent.append(("button", number, down))

    def move(self, dx, dy):
        self.sent.append(("move", dx, dy))

    def move_to(self, x, y):
        self.sent.append(("move_to", x, y))

    def close(self):
        self.closed = True


class ModuleTest(unittest.TestCase):
    def setUp(self):
        self.connection = FakeConnection()
        self.made = 0

        def connect():
            self.made += 1
            return self.connection

        self.real = inject_x11._connect
        inject_x11._connect = connect
        inject_x11._drop()
        inject_x11._state.__init__()
        inject_x11._buttons_down.clear()
        inject_x11._scroll_carry[:] = [0.0, 0.0]

    def tearDown(self):
        inject_x11._drop()
        inject_x11._connect = self.real

    def test_keys_buttons_moves_and_scrolls_reach_the_connection(self):
        inject_x11.inject_key("ctrl", True)
        inject_x11.inject_key("c", True, us="c")
        inject_x11.inject_mouse_button("back", True)
        inject_x11.inject_mouse_move(3, -2)
        inject_x11.inject_scroll(-1, 0, "line")
        self.assertEqual(self.connection.sent, [
            (PRESS, CTRL_L), (PRESS, C), ("button", 8, True), ("move", 3, -2), ("button", 5, True), ("button", 5, False),
        ])
        self.assertEqual(self.made, 1)

    def test_the_layout_is_read_again_after_a_mapping_change(self):
        self.connection.group = 1
        inject_x11.inject_key("ф", True)
        layout = inject_x11._layout
        inject_x11.inject_key("ф", False)
        self.assertIs(inject_x11._layout, layout)
        self.connection.changed = True
        inject_x11.inject_key("a", True)
        self.assertIsNot(inject_x11._layout, layout)

    def test_release_all_lets_go_of_everything_held(self):
        inject_x11.inject_key("shift", True)
        inject_x11.inject_key("A", True)
        inject_x11.inject_key("backspace", True)
        inject_x11.inject_mouse_button("left", True)
        inject_x11.inject_scroll(0.5, 0, "line")
        self.connection.sent.clear()
        inject_x11.release_all()
        self.assertEqual(self.connection.sent, [(RELEASE, SHIFT_L), (RELEASE, 22), (RELEASE, A), ("button", 1, False)])
        self.assertEqual(self.connection.repeat_restored, 1)
        state = inject_x11._state
        self.assertEqual((state.mods_down, state.named_down, state.chars_down, inject_x11._buttons_down), (set(), set(), {}, set()))
        self.assertEqual(inject_x11._scroll_carry, [0.0, 0.0])

    def test_a_failed_request_reconnects_next_time(self):
        self.connection.fail = ConnectionError("gone")
        with self.assertRaises(ConnectionError):
            inject_x11.inject_key("a", True)
        self.assertTrue(self.connection.closed)
        self.connection.fail = None
        inject_x11.inject_key("enter", True)
        self.assertEqual(self.made, 2)

    def test_a_gesture_is_dropped_with_one_line(self):
        with self.assertLogs(inject_x11.LOGGER, "WARNING") as logs:
            inject_x11.inject_gesture("swipe_left_once_test")
            inject_x11.inject_gesture("swipe_left_once_test")
        self.assertEqual(len(logs.records), 1)
        self.assertEqual(self.connection.sent, [])


if __name__ == "__main__":
    unittest.main()