Skip to content

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

26.6 KB
Raw Blame
import ctypes
import unittest
from unittest import mock

import input_injector
from input_injector import (
    KEYEVENTF_EXTENDEDKEY,
    KEYEVENTF_KEYUP,
    KEYEVENTF_UNICODE,
    MOUSEEVENTF_HWHEEL,
    MOUSEEVENTF_WHEEL,
    WHEEL_UNITS_PER_PIXEL,
    plan_key_inputs,
    plan_scroll_units,
)


# Fake VkKeyScanW: maps a character to a 16-bit (shift_state << 8) | vk value,
# or -1 if the character can't be produced by the "layout" at all.
FAKE_VK_SCAN = {
    "c": 0x0043,  # plain, no shift needed
    "e": 0x0045,  # plain
    "C": 0x0143,  # shift + VK_C (upper-case via shift)
    "k": 0x004B,  # plain, no shift needed
    "K": 0x014B,  # shift + VK_K (upper-case via shift)
    "@": 0x0632,  # requires ctrl+alt (AltGr) bits
}

# Fake MapVirtualKeyW: vk -> hardware scan code.
FAKE_SCAN_CODES = {
    0x43: 0x2E,  # 'C' key
    0x45: 0x12,  # 'E' key
    0x4B: 0x25,  # 'K' key
    0x32: 0x03,  # '2' key
    0x0D: 0x1C,  # enter
    0x26: 0x48,  # up arrow
    0xA3: 0x1D,  # ctrl_r
    0x5B: 0x5B,  # cmd (left win)
    0x08: 0x0E,  # backspace
    0x2E: 0x53,  # delete
}


def fake_vk_lookup(ch: str) -> int:
    return FAKE_VK_SCAN.get(ch, -1)


def fake_scan_lookup(vk: int) -> int:
    return FAKE_SCAN_CODES.get(vk, 0)


class BackspaceTests(unittest.TestCase):
    """Backspace is an ordinary named key under every modifier. It used to be
    remapped to Delete under Ctrl+Alt to stand in for Ctrl+Alt+Del; that went
    with the SAS feature, so Ctrl+Alt+Backspace now reaches Windows as the
    plain chord it is."""

    def plan(self, down, mods_down, char_vk_down):
        return plan_key_inputs(
            "backspace", down, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup
        )

    def test_plain_backspace_stays_backspace(self):
        char_vk_down = {}
        self.assertEqual(self.plan(True, set(), char_vk_down), [(0x08, 0x0E, 0)])
        self.assertEqual(
            self.plan(False, set(), char_vk_down), [(0x08, 0x0E, KEYEVENTF_KEYUP)]
        )

    def test_ctrl_only_backspace_stays_backspace(self):
        self.assertEqual(self.plan(True, {"ctrl"}, {}), [(0x08, 0x0E, 0)])

    def test_ctrl_alt_backspace_is_an_ordinary_chord(self):
        char_vk_down = {}
        for mods in ({"ctrl", "alt"}, {"ctrl_r", "alt_r"}):
            self.assertEqual(self.plan(True, mods, char_vk_down), [(0x08, 0x0E, 0)])
            self.assertEqual(
                self.plan(False, mods, char_vk_down), [(0x08, 0x0E, KEYEVENTF_KEYUP)]
            )
        self.assertEqual(char_vk_down, {})


class PlanKeyInputsChordTests(unittest.TestCase):
    def setUp(self):
        input_injector._warned_chars.clear()

    def test_ctrl_held_char_uses_vk_keystroke_and_mirrors_on_keyup(self):
        mods_down = {"ctrl"}
        char_vk_down = {}

        down_plan = plan_key_inputs("c", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x43, 0x2E, 0)])
        self.assertEqual(char_vk_down, {"c": 0x43})

        up_plan = plan_key_inputs("c", False, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(up_plan, [(0x43, 0x2E, KEYEVENTF_KEYUP)])
        self.assertEqual(char_vk_down, {})

    def test_win_held_char_uses_vk_path(self):
        mods_down = {"cmd"}
        char_vk_down = {}

        down_plan = plan_key_inputs("e", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x45, 0x12, 0)])
        self.assertEqual(char_vk_down, {"e": 0x45})

    def test_native_media_keys_use_the_windows_virtual_key_table(self):
        for name, vk in (("volume_up", 0xAF), ("volume_down", 0xAE), ("volume_mute", 0xAD),
                         ("media_play_pause", 0xB3), ("media_next", 0xB0), ("media_prev", 0xB1)):
            self.assertEqual(input_injector.VK_MAP[name], vk)

    def test_keyup_mirrors_vk_even_if_modifier_released_first(self):
        mods_down = {"ctrl"}
        char_vk_down = {}

        plan_key_inputs("c", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(char_vk_down, {"c": 0x43})

        # Modifier released before the char keyup arrives.
        plan_key_inputs("ctrl", False, mods_down, {}, fake_vk_lookup, fake_scan_lookup)
        self.assertNotIn("ctrl", mods_down)

        up_plan = plan_key_inputs("c", False, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(up_plan, [(0x43, 0x2E, KEYEVENTF_KEYUP)])
        self.assertEqual(char_vk_down, {})

    def test_no_modifier_and_unresolvable_char_uses_unicode_path(self):
        # 'a' has no entry in FAKE_VK_SCAN, standing in for a character this
        # "layout" can't resolve at all -- vk_lookup is still consulted (no
        # longer gated on a chord modifier being held), but comes back -1,
        # so this falls back to Unicode exactly like before.
        mods_down = set()
        char_vk_down = {}

        with self.assertLogs("input_injector", level="WARNING"):
            down_plan = plan_key_inputs("a", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0, ord("a"), KEYEVENTF_UNICODE)])

        up_plan = plan_key_inputs("a", False, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(up_plan, [(0, ord("a"), KEYEVENTF_UNICODE | KEYEVENTF_KEYUP)])
        self.assertEqual(char_vk_down, {})

    def test_chord_uses_the_real_key_even_when_translation_needs_altgr(self):
        mods_down = {"ctrl"}
        char_vk_down = {}

        down_plan = plan_key_inputs("@", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x32, 0x03, 0)])
        self.assertEqual(char_vk_down, {"@": 0x32})

    def test_unresolvable_char_falls_back_to_unicode(self):
        mods_down = {"alt"}
        char_vk_down = {}

        with self.assertLogs("input_injector", level="WARNING"):
            down_plan = plan_key_inputs("$", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)

        self.assertEqual(down_plan, [(0, ord("$"), KEYEVENTF_UNICODE)])
        self.assertEqual(char_vk_down, {})

    def test_shift_only_vk_scan_result_adds_no_synthetic_shift(self):
        mods_down = {"ctrl", "shift"}
        char_vk_down = {}

        down_plan = plan_key_inputs("C", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x43, 0x2E, 0)])
        self.assertEqual(char_vk_down, {"C": 0x43})

    def test_caps_capital_keeps_the_real_chord_key_and_the_forwarded_shift(self):
        for modifier in sorted(input_injector.CHORD_KEYS):
            for shifted in (False, True):
                for character in ("C", "Ф", "Ω"):
                    with self.subTest(modifier=modifier, shifted=shifted, character=character):
                        mods = {modifier} | ({"shift_r"} if shifted else set())
                        held = {}
                        lookup = lambda ch: 0x0143
                        expected_mods = set(mods)
                        self.assertEqual(plan_key_inputs(character, True, mods, held, lookup, fake_scan_lookup),
                                         [(0x43, 0x2E, 0)])
                        self.assertEqual(mods, expected_mods)
                        self.assertEqual(plan_key_inputs(character, True, mods, held, lambda ch: -1, fake_scan_lookup),
                                         [(0x43, 0x2E, 0)])
                        mods.clear()
                        self.assertEqual(plan_key_inputs(character, False, mods, held, lambda ch: -1, fake_scan_lookup),
                                         [(0x43, 0x2E, KEYEVENTF_KEYUP)])
                        self.assertEqual(held, {})

    def test_plain_non_latin_caps_capital_stays_unicode(self):
        for character in ("Ф", "Ω"):
            with self.subTest(character=character):
                held = {}
                self.assertEqual(plan_key_inputs(character, True, set(), held, lambda ch: 0x0143, fake_scan_lookup),
                                 [(0, ord(character), KEYEVENTF_UNICODE)])
                self.assertEqual(plan_key_inputs(character, False, set(), held, lambda ch: -1, fake_scan_lookup),
                                 [(0, ord(character), KEYEVENTF_UNICODE | KEYEVENTF_KEYUP)])
                self.assertEqual(held, {})

    def test_chord_from_another_script_uses_its_physical_place(self):
        for modifier in sorted(input_injector.CHORD_KEYS):
            with self.subTest(modifier=modifier):
                held = {}
                args = (held, lambda ch: -1, fake_scan_lookup, "c", lambda us: (0x43, "c"))
                self.assertEqual(plan_key_inputs("Ф", True, {modifier}, *args), [(0x43, 0x2E, 0)])
                self.assertEqual(plan_key_inputs("Ф", False, set(), *args), [(0x43, 0x2E, KEYEVENTF_KEYUP)])
                self.assertEqual(held, {})

    def test_windows_caps_capture_reaches_ctrl_a_and_win_r_as_real_keys(self):
        import capture_win
        from sender import PHYSICAL
        from core import keytable

        for caps in (False, True):
            for modifier_vk, vk, scan in ((0xA2, 0x41, 0x1E), (0x5B, 0x52, 0x13)):
                with self.subTest(caps=caps, modifier=modifier_vk):
                    state = capture_win.KeyboardState()
                    state.caps_lock = caps

                    def translate(key, code, keyboard):
                        return chr(key) if keyboard[capture_win.VK_CAPITAL] else chr(key).lower()

                    captured = capture_win.VK_TO_NAME[modifier_vk]
                    modifier = keytable.wire_name(PHYSICAL.get(captured, captured),
                                                 "windows", "windows", "semantic")
                    name = capture_win.key_name(vk, scan, state, translate)
                    self.assertEqual(name, chr(vk) if caps else chr(vk).lower())
                    held = {}
                    lookup = lambda ch: vk | (0x100 if ch.isupper() else 0)
                    self.assertEqual(plan_key_inputs(name, True, {modifier}, held, lookup, lambda key: scan),
                                     [(vk, scan, 0)])
                    self.assertEqual(plan_key_inputs(name, False, set(), held, lookup, lambda key: scan),
                                     [(vk, scan, KEYEVENTF_KEYUP)])


class PlanKeyInputsBareCharacterTests(unittest.TestCase):
    """Bug: a bare character (no chord modifier held) used to always go out
    as KEYEVENTF_UNICODE, which delivers text (WM_CHAR-style) but no usable
    keyCode -- apps and web pages listening for a real keydown (e.g.
    YouTube's 'k' to pause) never saw it, even though typing into a text
    field worked fine. The VK path is now preferred for any character the
    layout can resolve, chord or not; Unicode is only the fallback."""

    def setUp(self):
        input_injector._warned_chars.clear()

    def test_bare_character_uses_vk_path_with_scan_code(self):
        mods_down = set()
        char_vk_down = {}
        down_plan = plan_key_inputs("k", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x4B, 0x25, 0)])
        self.assertEqual(char_vk_down, {"k": 0x4B})

    def test_bare_character_keyup_mirrors_the_recorded_vk(self):
        mods_down = set()
        char_vk_down = {}
        plan_key_inputs("k", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        up_plan = plan_key_inputs("k", False, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(up_plan, [(0x4B, 0x25, KEYEVENTF_KEYUP)])
        self.assertEqual(char_vk_down, {})

    def test_shift_required_and_held_uses_vk_path_with_no_synthetic_shift(self):
        mods_down = {"shift"}
        char_vk_down = {}
        down_plan = plan_key_inputs("K", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        # A single tuple only: the Mac is already forwarding shift as its
        # own physical keydown, so nothing synthetic is added here.
        self.assertEqual(down_plan, [(0x4B, 0x25, 0)])
        self.assertEqual(char_vk_down, {"K": 0x4B})

    def test_shift_r_also_satisfies_the_shift_only_requirement(self):
        mods_down = {"shift_r"}
        char_vk_down = {}
        down_plan = plan_key_inputs("K", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0x4B, 0x25, 0)])

    def test_shift_required_but_not_held_falls_back_to_unicode(self):
        # Caps-lock case: VkKeyScanW says shift is needed to produce 'K',
        # but no physical shift is currently down. Trusting the VK here
        # would desync from the real keyboard state, so this must stay
        # Unicode -- and silently, since it isn't a broken layout.
        mods_down = set()
        char_vk_down = {}
        down_plan = plan_key_inputs("K", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0, ord("K"), KEYEVENTF_UNICODE)])
        self.assertEqual(char_vk_down, {})

    def test_altgr_character_without_any_chord_falls_back_to_unicode(self):
        mods_down = set()
        char_vk_down = {}
        with self.assertLogs("input_injector", level="WARNING"):
            down_plan = plan_key_inputs("@", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0, ord("@"), KEYEVENTF_UNICODE)])
        self.assertEqual(char_vk_down, {})

    def test_unresolvable_character_without_any_chord_falls_back_to_unicode(self):
        mods_down = set()
        char_vk_down = {}
        with self.assertLogs("input_injector", level="WARNING"):
            down_plan = plan_key_inputs("$", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(down_plan, [(0, ord("$"), KEYEVENTF_UNICODE)])
        self.assertEqual(char_vk_down, {})


class PlanKeyInputsNamedKeyTests(unittest.TestCase):
    def test_named_keys_use_scan_lookup(self):
        plan = plan_key_inputs("enter", True, set(), {}, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(plan, [(0x0D, 0x1C, 0)])

    def test_input_method_keys_use_their_non_extended_virtual_keys(self):
        self.assertFalse({"hangul", "hanja"} & input_injector.MODIFIER_KEYS)
        for name, vk in (("hangul", 0x15), ("hanja", 0x19)):
            with self.subTest(name=name):
                plan = plan_key_inputs(name, True, set(), {}, fake_vk_lookup, fake_scan_lookup)
                self.assertEqual(plan, [(vk, fake_scan_lookup(vk), 0)])

    def test_extended_keys_carry_extended_flag(self):
        for name, vk in (("up", 0x26), ("ctrl_r", 0xA3), ("cmd", 0x5B)):
            with self.subTest(name=name):
                plan = plan_key_inputs(name, True, set(), {}, fake_vk_lookup, fake_scan_lookup)
                self.assertEqual(len(plan), 1)
                _, _, flags = plan[0]
                self.assertTrue(flags & KEYEVENTF_EXTENDEDKEY)

    def test_non_extended_named_key_has_no_extended_flag(self):
        plan = plan_key_inputs("ctrl", True, set(), {}, fake_vk_lookup, fake_scan_lookup)
        self.assertEqual(len(plan), 1)
        _, _, flags = plan[0]
        self.assertFalse(flags & KEYEVENTF_EXTENDEDKEY)

    def test_named_modifier_key_updates_mods_down(self):
        mods_down = set()
        plan_key_inputs("ctrl", True, mods_down, {}, fake_vk_lookup, fake_scan_lookup)
        self.assertIn("ctrl", mods_down)
        plan_key_inputs("ctrl", False, mods_down, {}, fake_vk_lookup, fake_scan_lookup)
        self.assertNotIn("ctrl", mods_down)

    def test_unknown_key_name_is_dropped(self):
        old_names = {name: vk for name, vk in input_injector.VK_MAP.items() if name not in ("hangul", "hanja")}
        with mock.patch.object(input_injector, "VK_MAP", old_names):
            for name in ("hangul", "hanja"):
                with self.subTest(name=name):
                    self.assertEqual(plan_key_inputs(name, True, set(), {}, fake_vk_lookup, fake_scan_lookup), [])

    def test_release_all_releases_a_held_named_non_modifier_key(self):
        sent = []
        input_injector._mods_down.clear()
        input_injector._char_vk_down.clear()
        input_injector._named_down.clear()
        input_injector._buttons_down.clear()
        with mock.patch.object(input_injector, "_vk_key_scan", lambda _ch: -1), \
             mock.patch.object(input_injector, "_map_virtual_key", lambda _vk: 0x48), \
             mock.patch.object(input_injector, "_send_input", lambda *items: sent.extend(items)):
            input_injector.inject_key("left", True)
            input_injector.release_all()
        self.assertEqual(len(sent), 2)
        self.assertEqual(sent[0].union.ki.dwFlags, KEYEVENTF_EXTENDEDKEY)
        self.assertEqual(sent[1].union.ki.dwFlags, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP)


class PlanScrollUnitsLineModeTests(unittest.TestCase):
    def test_line_mode_scales_by_120_and_never_carries_a_remainder(self):
        accum = [0.0, 0.0]
        self.assertEqual(plan_scroll_units(1, 0, "line", accum), (120, 0))
        self.assertEqual(accum, [0.0, 0.0])
        self.assertEqual(plan_scroll_units(-2, 3, "line", accum), (-240, -360))
        self.assertEqual(accum, [0.0, 0.0])

    def test_line_mode_defaults_to_no_horizontal_movement(self):
        accum = [0.0, 0.0]
        self.assertEqual(plan_scroll_units(1, 0, "line", accum), (120, 0))


class PlanScrollUnitsPixelModeTests(unittest.TestCase):
    def test_pixel_mode_small_delta_does_not_flush_immediately(self):
        # WHEEL_UNITS_PER_PIXEL is 3.0 by default: 0.1px is 0.3 wheel units,
        # under a whole unit, so a single small delta must not flush yet.
        accum = [0.0, 0.0]
        self.assertEqual(plan_scroll_units(0.1, 0.0, "pixel", accum), (0, 0))
        self.assertAlmostEqual(accum[0], 0.3, places=6)

    def test_pixel_mode_flushes_once_enough_small_deltas_accumulate(self):
        accum = [0.0, 0.0]
        for _ in range(3):
            plan_scroll_units(0.1, 0.0, "pixel", accum)
        # 0.3 units/call * 4 calls = 1.2 -> flush 1, carry 0.2.
        whole_y, whole_x = plan_scroll_units(0.1, 0.0, "pixel", accum)
        self.assertEqual((whole_y, whole_x), (1, 0))
        self.assertAlmostEqual(accum[0], 0.2, places=6)

    def test_pixel_mode_carries_residue_across_multiple_small_deltas(self):
        accum = [0.0, 0.0]
        # 0.4px * 3.0 units/px = 1.2 units per call.
        self.assertEqual(plan_scroll_units(0.4, 0.0, "pixel", accum), (1, 0))
        self.assertAlmostEqual(accum[0], 0.2, places=6)
        # 0.2 + 1.2 = 1.4 -> flush 1, carry 0.4.
        self.assertEqual(plan_scroll_units(0.4, 0.0, "pixel", accum), (1, 0))
        self.assertAlmostEqual(accum[0], 0.4, places=6)

    def test_pixel_mode_tracks_horizontal_axis_independently(self):
        accum = [0.0, 0.0]
        whole_y, whole_x = plan_scroll_units(0.0, -0.4, "pixel", accum)
        self.assertEqual((whole_y, whole_x), (0, 1))
        self.assertAlmostEqual(accum[0], 0.0)
        self.assertAlmostEqual(accum[1], 0.2, places=6)

    def test_pixel_mode_negative_deltas_carry_a_negative_remainder(self):
        accum = [0.0, 0.0]
        whole_y, _ = plan_scroll_units(-0.1, 0.0, "pixel", accum)
        self.assertEqual(whole_y, 0)
        self.assertAlmostEqual(accum[0], -0.1 * WHEEL_UNITS_PER_PIXEL, places=6)


class InjectScrollDispatchTests(unittest.TestCase):
    """inject_scroll's real _send_input call requires Win32 SendInput, which
    only exists on Windows. These tests fake that boundary (patch
    _send_input) so the dispatch logic -- which flags to use, whether an
    axis with nothing to flush is skipped -- can be verified on any
    platform, matching how plan_key_inputs/inject_key are already split for
    testability.
    """

    def setUp(self):
        # inject_scroll accumulates in module-level state; reset it so tests
        # don't leak residue into each other.
        input_injector._scroll_accum[:] = [0.0, 0.0]

    def test_line_mode_sends_wheel_and_hwheel_with_expected_flags(self):
        with mock.patch.object(input_injector, "_send_input") as fake_send:
            input_injector.inject_scroll(1, 2, "line")
        calls = [call.args[0] for call in fake_send.call_args_list]
        self.assertEqual(len(calls), 2)
        self.assertEqual(calls[0].union.mi.mouseData, 120)
        self.assertEqual(calls[0].union.mi.dwFlags, MOUSEEVENTF_WHEEL)
        self.assertEqual(calls[1].union.mi.mouseData, ctypes.c_ulong(-240).value)
        self.assertEqual(calls[1].union.mi.dwFlags, MOUSEEVENTF_HWHEEL)

    def test_zero_delta_axis_sends_nothing(self):
        with mock.patch.object(input_injector, "_send_input") as fake_send:
            input_injector.inject_scroll(1, 0, "line")
        calls = [call.args[0] for call in fake_send.call_args_list]
        self.assertEqual(len(calls), 1)
        self.assertEqual(calls[0].union.mi.dwFlags, MOUSEEVENTF_WHEEL)

    def test_pixel_mode_small_delta_flushes_nothing_yet(self):
        with mock.patch.object(input_injector, "_send_input") as fake_send:
            input_injector.inject_scroll(0.1, 0.0, "pixel")
        fake_send.assert_not_called()
        self.assertAlmostEqual(input_injector._scroll_accum[0], 0.1 * WHEEL_UNITS_PER_PIXEL, places=6)


class InjectSideButtonTests(unittest.TestCase):
    def tearDown(self):
        input_injector._buttons_down.clear()

    def test_back_and_forward_are_x_buttons_one_and_two(self):
        with mock.patch.object(input_injector, "_send_input") as fake_send:
            input_injector.inject_mouse_button("back", True)
            input_injector.inject_mouse_button("forward", False)
        sent = [call.args[0].union.mi for call in fake_send.call_args_list]
        self.assertEqual((sent[0].dwFlags, sent[0].mouseData), (input_injector.MOUSEEVENTF_XDOWN, 1))
        self.assertEqual((sent[1].dwFlags, sent[1].mouseData), (input_injector.MOUSEEVENTF_XUP, 2))



class FractionalWheelTests(unittest.TestCase):
    def test_half_clicks_add_up_to_whole_ones(self):
        accum = [0.0, 0.0]
        units = [input_injector.plan_scroll_units(0.5, 0.0, "line", accum)[0] for _ in range(4)]
        self.assertEqual(sum(units), 240)
        self.assertEqual(input_injector.plan_scroll_units(2, 0, "line", [0.0, 0.0]), (240, 0))


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


class InjectGestureTests(unittest.TestCase):
    def setUp(self):
        self.pressed = []
        patcher = mock.patch.object(
            input_injector, "inject_key", side_effect=lambda key, down: self.pressed.append((key, down))
        )
        patcher.start()
        self.addCleanup(patcher.stop)

    def test_touchpad_swipe_is_preferred_and_ends_the_gesture(self):
        swipes = []
        input_injector.inject_gesture("swipe_up", swipe=lambda fingers, direction: swipes.append((fingers, direction)) or True)
        self.assertEqual(swipes, [(3, "up")])
        self.assertEqual(self.pressed, [])

    def test_refused_swipe_falls_back_to_the_shortcut_chord(self):
        input_injector.inject_gesture("swipe_left", swipe=lambda fingers, direction: False)
        self.assertEqual(
            self.pressed,
            [("cmd", True), ("ctrl", True), ("right", True), ("right", False), ("ctrl", False), ("cmd", False)],
        )

    def test_spread_and_swipe_down_both_show_the_desktop(self):
        for name in ("spread", "swipe_down"):
            swipes = []
            input_injector.inject_gesture(name, swipe=lambda fingers, direction: swipes.append((fingers, direction)) or True)
            self.assertEqual(swipes, [(3, "down")], name)

    def test_pinch_has_no_touchpad_gesture_and_opens_start(self):
        input_injector.inject_gesture("pinch", swipe=lambda fingers, direction: self.fail("no swipe expected"))
        self.assertEqual(self.pressed, [("cmd", True), ("cmd", False)])

    def test_unknown_gesture_does_nothing(self):
        input_injector.inject_gesture("wiggle", swipe=lambda fingers, direction: self.fail("no swipe expected"))
        self.assertEqual(self.pressed, [])


class TouchpadContactFramesTests(unittest.TestCase):
    def test_fingers_move_together_by_the_axis_distance_and_stay_on_the_pad(self):
        import touchpad_injector

        frames = touchpad_injector.contact_frames(3, "up")
        self.assertEqual(len(frames), touchpad_injector.SWIPE_STEPS + 1)
        first, last = frames[0], frames[-1]
        for (x0, y0), (x1, y1) in zip(first, last):
            self.assertEqual(x1, x0)
            self.assertEqual(y0 - y1, 3000)
        for frame in frames:
            for x, y in frame:
                self.assertTrue(0 <= x <= touchpad_injector.PAD_WIDTH)
                self.assertTrue(0 <= y <= touchpad_injector.PAD_HEIGHT)

    def test_four_fingers_sideways_keep_their_spacing(self):
        import touchpad_injector

        frames = touchpad_injector.contact_frames(4, "left")
        xs = [x for x, _ in frames[-1]]
        self.assertEqual([b - a for a, b in zip(xs, xs[1:])], [touchpad_injector.FINGER_SPACING] * 3)


class InjectedMarkTests(unittest.TestCase):
    """Every INPUT carries the mark. The raw-input reader in capture_win
    reads it back out of ulExtraInformation to tell the Mac's pointer from
    the hand; nothing else in Windows does."""

    def test_a_mouse_input_is_stamped(self):
        item = input_injector._mouse_input(5, 0, 0, input_injector.MOUSEEVENTF_MOVE)
        self.assertEqual(item.union.mi.dwExtraInfo, input_injector.INJECTED_MARK)

    def test_a_key_input_is_stamped(self):
        item = input_injector._keybd_input(0x41, 0x1E, 0)
        self.assertEqual(item.union.ki.dwExtraInfo, input_injector.INJECTED_MARK)


class InjectTextTests(unittest.TestCase):
    """WIRE.md section 10: a `text` message is typed as characters, never as keys."""

    def test_each_character_is_a_unicode_down_and_up_pair(self):
        plan = input_injector.plan_text_inputs("aé")
        down, up = KEYEVENTF_UNICODE, KEYEVENTF_UNICODE | KEYEVENTF_KEYUP
        self.assertEqual(plan, [(0, ord("a"), down), (0, ord("a"), up), (0, ord("é"), down), (0, ord("é"), up)])

    def test_a_character_outside_the_bmp_goes_as_its_surrogate_pair(self):
        plan = input_injector.plan_text_inputs("\U0001F600")
        self.assertEqual([scan for _vk, scan, _flags in plan], [0xD83D, 0xD83D, 0xDE00, 0xDE00])

    def test_injecting_text_sends_one_batch_stamped_with_the_mark(self):
        sent = []
        with mock.patch.object(input_injector, "_send_input", lambda *items: sent.extend(items)):
            input_injector.inject_text("hi")
        self.assertEqual(len(sent), 4)
        self.assertTrue(all(item.union.ki.dwExtraInfo == input_injector.INJECTED_MARK for item in sent))
        self.assertEqual([item.union.ki.wScan for item in sent], [ord("h"), ord("h"), ord("i"), ord("i")])

    def test_empty_text_sends_nothing(self):
        with mock.patch.object(input_injector, "_send_input", lambda *items: self.fail("nothing to send")):
            input_injector.inject_text("")