"""Tests specific to Kitty keyboard protocol features.""" import io import os import sys import time import math import pytest import platform from blessed import Terminal from blessed.keyboard import ( KEY_TAB, KEY_LEFT_SHIFT, KEY_LEFT_CONTROL, KEY_RIGHT_ALT, _match_kitty_key, KittyKeyEvent, Keystroke, KittyKeyboardProtocol, resolve_sequence, _match_legacy_csi_letter_form, ) from tests.accessories import (as_subprocess, SEMAPHORE, TestTerminal, read_until_semaphore, pty_test) from tests.conftest import IS_WINDOWS, TEST_KEYBOARD # isort: off # curses if platform.system() == 'Windows': # pylint: disable=import-error from jinxed import KEY_EXIT, KEY_ENTER, KEY_BACKSPACE else: from curses import KEY_EXIT, KEY_ENTER, KEY_BACKSPACE # Skip PTY tests on Windows and build farms pytestmark = pytest.mark.skipif( IS_WINDOWS, reason="PTY tests not supported on Windows") @pytest.mark.parametrize( "sequence,unicode_key,shifted_key,base_key,modifiers,event_type,codepoints", [('\x1b[97u', 97, None, None, 1, 1, ()), ('\x1b[97;5u', 97, None, None, 5, 1, ()), ('\x1b[97:65;2u', 97, 65, None, 2, 1, ()), ('\x1b[1089::99;5u', 1089, None, 99, 5, 1, ()), ('\x1b[97;1:3u', 97, None, None, 1, 3, ()), ('\x1b[97;2;65u', 97, None, None, 2, 1, (65,))]) def test_match_kitty_basic_forms( # pylint: disable=too-many-positional-arguments sequence, unicode_key, shifted_key, base_key, modifiers, event_type, codepoints): """Test basic Kitty protocol sequence parsing.""" ks = _match_kitty_key(sequence) assert isinstance(ks._match, KittyKeyEvent) event = ks._match assert event.unicode_key == unicode_key assert event.shifted_key == shifted_key assert event.base_key == base_key assert event.modifiers == modifiers assert event.event_type == event_type assert event.int_codepoints == codepoints def test_match_kitty_complex(): """Test complex Kitty protocol sequence with all fields.""" ks = _match_kitty_key('\x1b[97:65:99;6:2;65:66u') event = ks._match assert event.unicode_key == 97 assert event.shifted_key == 65 assert event.base_key == 99 assert event.modifiers == 6 assert event.event_type == 2 assert event.int_codepoints == (65, 66) @pytest.mark.parametrize("sequence", [ 'a', '\x1b[A', '\x1b[97', '\x1b]97u', '\x1b[97v', ]) def test_match_kitty_non_matching(sequence): """Test non-Kitty sequences return None.""" assert _match_kitty_key(sequence) is None def test_kitty_modifier_encoding(): """Test Kitty protocol modifier value encoding.""" modifiers = { 'shift': 2, 'alt': 3, 'ctrl': 5, 'super': 9, 'hyper': 17, 'meta': 33, 'caps_lock': 65, 'num_lock': 129, 'ctrl+shift': 6, 'ctrl+alt': 7, } for mod_value in modifiers.values(): ks = _match_kitty_key(f'\x1b[97;{mod_value}u') assert ks is not None assert ks._match.modifiers == mod_value def test_kitty_sequence_properties(): """Test Kitty keystroke properties.""" ks = _match_kitty_key('\x1b[97;5u') assert str(ks) == '\x1b[97;5u' assert ks.is_sequence is True assert ks._code is None def test_terminal_inkey_kitty_protocol(): """Test Terminal.inkey() with Kitty protocol sequences.""" @as_subprocess def child(): stream = io.StringIO() term = Terminal(stream=stream, force_styling=True) term.ungetch('\x1b[97;5u') ks = term.inkey(timeout=0) assert ks == '\x1b[97;5u' assert ks._mode == -1 assert isinstance(ks._match, KittyKeyEvent) assert ks._match.unicode_key == 97 assert ks._match.modifiers == 5 term.ungetch('\x1b[65u') ks = term.inkey(timeout=0) assert ks._mode == -1 assert ks._match.unicode_key == 65 term.ungetch('\x1b[97;5uextra') ks = term.inkey(timeout=0) assert ks == '\x1b[97;5u' assert ks._mode == -1 remaining = term.flushinp() assert remaining == 'extra' term.ungetch('\x1b[97;8u') ks = term.inkey(timeout=0) assert ks._mode == -1 assert isinstance(ks._match, KittyKeyEvent) assert ks._match.unicode_key == 97 assert ks._match.modifiers == 8 assert stream.getvalue() == '' child() def test_kitty_protocol_modifier_properties(): """Test Kitty protocol modifier properties.""" # Test Ctrl+Alt+a ks = _match_kitty_key('\x1b[97;7u') # 1 + 2 + 4 = 7 assert ks._ctrl is True assert ks._alt is True assert ks._shift is False assert ks._super is False assert ks.value == 'a' assert ks.is_ctrl_alt('a') # Test with caps lock ks = _match_kitty_key('\x1b[97;69u') # 1 + 4 + 64 = 69 (ctrl + a w/caps_lock) assert ks._ctrl is True assert ks._caps_lock is True assert ks._alt is False assert ks.value == 'a' assert ks.is_ctrl('a') # Test with num lock ks = _match_kitty_key('\x1b[97;129u') # 1 + 128 = 129 (a w/num_lock) assert ks._num_lock is True assert ks._ctrl is False assert ks._alt is False assert ks.value == 'a' def test_kitty_protocol_is_ctrl_is_alt(): """Test is_ctrl() and is_alt() with Kitty protocol.""" # Matching Ctrl+a ks = _match_kitty_key('\x1b[97;5u') # Ctrl+a assert ks.is_ctrl('a') is True assert ks.is_ctrl('A') is True # Ctrl is Case insensitive assert ks.is_ctrl('b') is False assert ks.is_ctrl() is False # Matching Alt+a ks = _match_kitty_key('\x1b[97;3u') # Alt+a assert ks.is_alt('a') is True assert ks.is_alt('A') is True # Alt is also Case insensitive assert ks.is_alt('b') is False # Ctrl+Alt+a should NOT match exact is_ctrl('a') or is_alt('a') ks = _match_kitty_key('\x1b[97;7u') # Ctrl+Alt+a assert ks.is_ctrl('a') is False # Not exactly ctrl assert ks.is_alt('a') is False # Not exactly alt @pytest.mark.parametrize("value,dis,events,alt,all_keys,text", [ (0, False, False, False, False, False), (1, True, False, False, False, False), (2, False, True, False, False, False), (4, False, False, True, False, False), (8, False, False, False, True, False), (16, False, False, False, False, True), (31, True, True, True, True, True), (5, True, False, True, False, False), (9, True, False, False, True, False), (18, False, True, False, False, True), ]) def test_kitty_keyboard_protocol_properties( # pylint: disable=too-many-positional-arguments value, dis, events, alt, all_keys, text): """Test KittyKeyboardProtocol flag parsing, make_arguments, repr, and equality.""" proto = KittyKeyboardProtocol(value) assert proto.value == value assert proto.disambiguate == dis assert proto.report_events == events assert proto.report_alternates == alt assert proto.report_all_keys == all_keys assert proto.report_text == text expected_args = { 'disambiguate': dis, 'report_events': events, 'report_alternates': alt, 'report_all_keys': all_keys, 'report_text': text } assert proto.make_arguments() == expected_args repr_str = repr(proto) assert f'KittyKeyboardProtocol(value={value}' in repr_str if value == 0: assert 'flags=[]' in repr_str proto_copy = KittyKeyboardProtocol(value) assert proto == proto_copy assert proto == value if value != 10: assert proto != 10 @pytest.mark.skipif(not TEST_KEYBOARD, reason="TEST_KEYBOARD not specified") def test_get_kitty_keyboard_state_pty_success(): """PTY test: get_kitty_keyboard_state with successful terminal response.""" def child(term): # Signal readiness and query Kitty state os.write(sys.__stdout__.fileno(), SEMAPHORE) flags = term.get_kitty_keyboard_state(timeout=0.1) # Write result to stdout for parent verification if flags is not None: os.write(sys.__stdout__.fileno(), str(flags.value).encode('ascii')) else: os.write(sys.__stdout__.fileno(), b'None') def parent(master_fd): # Wait for child readiness read_until_semaphore(master_fd) # Send both Kitty protocol flags response and DA1 response for boundary detection # flags=27: all basic flags set, and a DA1 response indicating VT terminal os.write(master_fd, b'\x1b[?27u\x1b[?64c') output = pty_test(child, parent, 'test_get_kitty_keyboard_state_pty_success') # first call to get_kitty_keyboard_state causes both kitty and dec # parameters query to output, we faked a "response" by writing to our master pty side assert output == '\x1b[?u\x1b[c' + '27' # Should have parsed flags value 27 @pytest.mark.skipif(not TEST_KEYBOARD, reason="TEST_KEYBOARD not specified") def test_enable_kitty_keyboard_pty_success(): """PTY test: enable_kitty_keyboard with set and restore sequences.""" def child(term): # Signal readiness os.write(sys.__stdout__.fileno(), SEMAPHORE) # Use context manager with comprehensive flags (27 = 1+2+8+16) with term.enable_kitty_keyboard( disambiguate=True, report_events=True, report_all_keys=True, report_text=True, timeout=1.0, force=True ): # Write marker to show we're inside the context os.write(sys.__stdout__.fileno(), b'INSIDE') # Write completion marker os.write(sys.__stdout__.fileno(), b'COMPLETE') def parent(master_fd): # Wait for child readiness read_until_semaphore(master_fd) # Send initial state response when child queries current flags (9 = # disambiguate + report_all_keys) os.write(master_fd, b'\x1b[?9u') output = pty_test(child, parent, 'test_enable_kitty_keyboard_pty_success') # Verify child completed successfully assert 'INSIDE' in output assert 'COMPLETE' in output def test_kitty_state_0s_reply_via_ungetch(): """0-second get_kitty_keyboard_state call with response via ungetch.""" @as_subprocess def child(): term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True # Force TTY behavior for testing stime = time.time() # Simulate Kitty keyboard state response - flags value 9 (disambiguate + report_all_keys) # Need both Kitty and DA response for boundary approach on first call term.ungetch('\x1b[?9u\x1b[?64c') flags = term.get_kitty_keyboard_state(timeout=0.01) assert math.floor(time.time() - stime) == 0.0 assert flags is not None assert flags.value == 9 assert flags.disambiguate is True assert flags.report_all_keys is True assert flags.report_events is False child() def test_kitty_state_styling_indifferent(): """Test get_kitty_keyboard_state with styling enabled and disabled.""" @as_subprocess def child(): # Test with styling enabled term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True # Force TTY behavior for testing # Need both Kitty and DA response for boundary approach on first call term.ungetch('\x1b[?15u\x1b[?64c') # flags value 15 (multiple flags) flags = term.get_kitty_keyboard_state(timeout=0.01) assert flags is not None assert flags.value == 15 assert flags.disambiguate is True assert flags.report_events is True assert flags.report_alternates is True assert flags.report_all_keys is True # bit 3 (8) is set in value 15 assert flags.report_text is False # Test with styling disabled, still works when is_a_tty is True term = TestTerminal(stream=io.StringIO(), force_styling=False) term._is_a_tty = True term.ungetch('\x1b[?15u\x1b[?64c') flags = term.get_kitty_keyboard_state(timeout=0.01) assert flags is not None assert flags.value == 15 assert flags.disambiguate is True assert flags.report_events is True assert flags.report_alternates is True assert flags.report_all_keys is True assert flags.report_text is False child() def test_kitty_state_timeout_handling(): """Test get_kitty_keyboard_state timeout and sticky failure behavior.""" @as_subprocess def child(): term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True # Force TTY behavior for testing # Should have clean state initially assert term._kitty_kb_first_query_failed is False # First timeout should set sticky failure flag flags1 = term.get_kitty_keyboard_state(timeout=0.001) assert flags1 is None assert term._kitty_kb_first_query_failed is True # Subsequent calls should return None immediately (sticky failure) flags2 = term.get_kitty_keyboard_state(timeout=1.0) assert flags2 is None # Force should override sticky failure and attempt query again flags3 = term.get_kitty_keyboard_state(timeout=0.001, force=True) assert flags3 is None # Still timeout, but sticky behavior was bypassed child() def test_kitty_state_excludes_response_from_buffer(): """Test get_kitty_keyboard_state buffer management.""" @as_subprocess def child(): term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True # Force TTY behavior for testing # Buffer unrelated data before and after the kitty state response term.ungetch('abc' + '\x1b[?13u' + 'xyz') # get_kitty_keyboard_state should parse and consume only the response # Use force=True to bypass boundary approach for this buffer management test flags = term.get_kitty_keyboard_state(timeout=0.01, force=True) assert flags is not None assert flags.value == 13 # Remaining data should still be available for subsequent input remaining = term.flushinp() assert remaining == 'abcxyz' child() @pytest.mark.parametrize("force_styling,expected_sticky_flag", [ (False, False), # styling disabled -> no sticky flag (True, False), # not a TTY -> no sticky flag ]) def test_get_kitty_keyboard_state_no_tty_or_disabled(force_styling, expected_sticky_flag): """Test get_kitty_keyboard_state returns None when unsupported.""" @as_subprocess def child(): stream = io.StringIO() term = Terminal(stream=stream, force_styling=force_styling) # Should return None immediately without attempting query result = term.get_kitty_keyboard_state(timeout=0.01) assert result is None assert term._kitty_kb_first_query_failed == expected_sticky_flag # All subsequent calls should return None result2 = term.get_kitty_keyboard_state(timeout=None) assert result2 is None # Force should also return None when not supported/not a TTY result3 = term.get_kitty_keyboard_state(timeout=0.01, force=True) assert result3 is None assert stream.getvalue() == '' child() @pytest.mark.parametrize("force_styling,force,flags,mode,expected_output", [ (False, False, {'disambiguate': True}, 1, ''), # No styling, no output (True, False, {'disambiguate': True}, 1, ''), # Not TTY, no force, no output (True, True, {'disambiguate': True}, 1, '\x1b[=1;1u'), # Not TTY but forced (True, True, {'disambiguate': False, 'report_events': True, 'report_alternates': True}, 2, '\x1b[=6;2u'), # Multi-flag (True, True, {'disambiguate': True, 'report_events': True, 'report_all_keys': True, 'report_text': True}, 1, '\x1b[=27;1u'), # Comprehensive ]) def test_enable_kitty_keyboard(force_styling, force, flags, mode, expected_output): """Test enable_kitty_keyboard with various flag combinations and conditions.""" @as_subprocess def child(): stream = io.StringIO() term = Terminal(stream=stream, force_styling=force_styling) with term.enable_kitty_keyboard(**flags, mode=mode, force=force, timeout=0.01): pass assert stream.getvalue() == expected_output child() def test_enable_kitty_keyboard_all_flag_operations(): """Test all flag bit operations in enable_kitty_keyboard.""" @as_subprocess def child(): stream = io.StringIO() term = TestTerminal(stream=stream, force_styling=True) term._is_a_tty = True given_flags_response = '\x1b[?0u' # flags 0 (no flags currently set) expected_enable_seq = '\x1b[=31;1u' # flags 31 (1+2+4+8+16: all 5 flags), mode 1 (push) term.ungetch(given_flags_response) with term.enable_kitty_keyboard( disambiguate=True, report_events=True, report_alternates=True, report_all_keys=True, report_text=True, timeout=0.01, force=True ): pass output = stream.getvalue() assert expected_enable_seq in output child() def test_enable_kitty_keyboard_sequence_emission(): """Test sequence emission and flush in enable_kitty_keyboard.""" @as_subprocess def child(): stream = io.StringIO() term = TestTerminal(stream=stream, force_styling=True) term._is_a_tty = True given_flags_response = '\x1b[?5u' # flags 5 (1+4: disambiguate+report_alternates) expected_enable_seq = '\x1b[=1;1u' # flags 1 (disambiguate), mode 1 (push) expected_restore_seq = '\x1b[=5;1u' # flags 5 (restore previous), mode 1 term.ungetch(given_flags_response) with term.enable_kitty_keyboard(disambiguate=True, timeout=0.01, force=True): output_during = stream.getvalue() assert expected_enable_seq in output_during output_after = stream.getvalue() assert expected_restore_seq in output_after child() def test_enable_kitty_keyboard_restoration_with_previous_flags(): """Test restoration logic when previous flags exist.""" @as_subprocess def child(): stream = io.StringIO() term = TestTerminal(stream=stream, force_styling=True) term._is_a_tty = True given_flags_response = '\x1b[?9u' # flags 9 (1+8: disambiguate+report_all_keys) expected_restore_seq = '\x1b[=9;1u' # flags 9 (restore previous), mode 1 term.ungetch(given_flags_response) with term.enable_kitty_keyboard(disambiguate=True, report_all_keys=True, timeout=0.01, force=True): pass output = stream.getvalue() assert expected_restore_seq in output child() def test_enable_kitty_keyboard_sticky_failure(): """Test enable_kitty_keyboard skips when first query failed.""" @as_subprocess def child(): stream = io.StringIO() term = TestTerminal(stream=stream, force_styling=True) term._is_a_tty = True term._kitty_kb_first_query_failed = True with term.enable_kitty_keyboard(disambiguate=True, timeout=0.01): pass assert stream.getvalue() == '' child() @pytest.mark.parametrize("flags,expected_value", [ ({'disambiguate': True}, 1), ({'report_events': True}, 2), ({'report_alternates': True}, 4), ({'report_all_keys': True}, 8), ({'report_text': True}, 16), ({'disambiguate': True, 'report_events': True}, 3), ({'disambiguate': True, 'report_alternates': True}, 5), ({'report_events': True, 'report_all_keys': True}, 10), ({'report_alternates': True, 'report_text': True}, 20), ({'disambiguate': True, 'report_events': True, 'report_alternates': True}, 7), ({'report_all_keys': True, 'report_text': True, 'disambiguate': True}, 25), ]) def test_kitty_keyboard_protocol_setters(flags, expected_value): """Test KittyKeyboardProtocol property setters with various combinations.""" protocol = KittyKeyboardProtocol(0) for flag_name, flag_value in flags.items(): setattr(protocol, flag_name, flag_value) assert protocol.value == expected_value for flag_name, expected_flag_value in flags.items(): assert getattr(protocol, flag_name) == expected_flag_value def test_get_kitty_state_boundary_no_response(): """Test boundary approach when neither Kitty nor DA1 response found.""" @as_subprocess def child(): stream = io.StringIO() term = TestTerminal(stream=stream, force_styling=True) term._is_a_tty = True term.ungetch('garbage response') expected_kitty_query = '\x1b[?u' # query current flags expected_da1_query = '\x1b[c' # device attributes query flags = term.get_kitty_keyboard_state(timeout=0.01) assert flags is None assert term._kitty_kb_first_query_failed is True output = stream.getvalue() assert expected_kitty_query in output assert expected_da1_query in output child() def test_get_kitty_keyboard_state_boundary_approach(): """Test boundary approach for detecting Kitty keyboard support.""" @as_subprocess def child(): stream = io.StringIO() # Test 1: Successful first call with Kitty and DA responses term = Terminal(stream=stream, force_styling=True) term._is_a_tty = True term.ungetch('\x1b[?9u\x1b[?64;1;2;4c') flags = term.get_kitty_keyboard_state(timeout=0.01) assert flags is not None assert flags.value == 9 assert term._kitty_kb_first_query_attempted is True assert term._kitty_kb_first_query_failed is False # Test 2: First call with only DA response (no Kitty support) term = Terminal(stream=stream, force_styling=True) term._is_a_tty = True term.ungetch('\x1b[?64;1;2c') flags = term.get_kitty_keyboard_state(timeout=0.01) assert flags is None assert term._kitty_kb_first_query_attempted is True assert term._kitty_kb_first_query_failed is True flags2 = term.get_kitty_keyboard_state(timeout=1.0) assert flags2 is None # Test 3: First call timeout (no response) term = Terminal(stream=stream, force_styling=True) term._is_a_tty = True flags = term.get_kitty_keyboard_state(timeout=0.001) assert flags is None assert term._kitty_kb_first_query_attempted is True assert term._kitty_kb_first_query_failed is True flags2 = term.get_kitty_keyboard_state(timeout=1.0) assert flags2 is None # Test 4: Subsequent call uses normal query term = Terminal(stream=stream, force_styling=True) term._is_a_tty = True term.ungetch('\x1b[?15u\x1b[?64c') flags1 = term.get_kitty_keyboard_state(timeout=0.01) assert flags1 is not None assert flags1.value == 15 term.ungetch('\x1b[?7u') flags2 = term.get_kitty_keyboard_state(timeout=0.01) assert flags2 is not None assert flags2.value == 7 # Test 5: force=True bypasses boundary approach term = Terminal(stream=stream, force_styling=True) term._is_a_tty = True term.ungetch('\x1b[?13u') flags = term.get_kitty_keyboard_state(timeout=0.01, force=True) assert flags is not None assert flags.value == 13 assert term._kitty_kb_first_query_attempted is False assert term._kitty_kb_first_query_failed is False child() @pytest.mark.parametrize("sequence,expected_name,expected_value", [ ('\x1b[49;3u', 'KEY_ALT_1', '1'), ('\x1b[49;5u', 'KEY_CTRL_1', '1'), ('\x1b[49;4u', 'KEY_ALT_SHIFT_1', '1'), ('\x1b[50;3u', 'KEY_ALT_2', '2'), ('\x1b[57;5u', 'KEY_CTRL_9', '9'), ('\x1b[48;7u', 'KEY_CTRL_ALT_0', '0'), ('\x1b[97;5u', 'KEY_CTRL_A', 'a'), ('\x1b[97;3u', 'KEY_ALT_A', 'a'), ('\x1b[97;7u', 'KEY_CTRL_ALT_A', 'a'), ('\x1b[97;2u', 'KEY_SHIFT_A', 'a'), ('\x1b[97;6u', 'KEY_CTRL_SHIFT_A', 'a'), ('\x1b[97;4u', 'KEY_ALT_SHIFT_A', 'a'), ('\x1b[97;8u', 'KEY_CTRL_ALT_SHIFT_A', 'a'), ('\x1b[65;5u', 'KEY_CTRL_A', 'A'), ('\x1b[90;5u', 'KEY_CTRL_Z', 'Z'), ('\x1b[122;5u', 'KEY_CTRL_Z', 'z'), ('\x1b[77;3u', 'KEY_ALT_M', 'M'), ('\x1b[109;3u', 'KEY_ALT_M', 'm'), ('\x1b[97;9u', 'KEY_SUPER_A', 'a'), ('\x1b[97;17u', 'KEY_HYPER_A', 'a'), ('\x1b[97;33u', 'KEY_META_A', 'a'), ('\x1b[97;13u', 'KEY_CTRL_SUPER_A', 'a'), ('\x1b[97;11u', 'KEY_ALT_SUPER_A', 'a'), ]) def test_kitty_letter_digit_name_synthesis(sequence, expected_name, expected_value): """Test letter and digit name synthesis with modifiers.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name assert ks.value == expected_value @pytest.mark.parametrize("sequence,expected_name,expected_value", [ ('\x1b[49u', None, '1'), ('\x1b[97;1u', None, 'a'), ('\x1b[65;1u', None, 'A'), ('\x1b[122;1u', None, 'z'), ('\x1b[97u', None, 'a'), ('\x1b[32;5u', None, ' '), ('\x1b[33;3u', None, '!'), ('\x1b[59;5u', None, ';'), ('\x1b[46;3u', None, '.'), ('\x1b[64;5u', None, '@'), ('\x1b[91;3u', 'CSI', '['), ]) def test_kitty_name_synthesis_edge_cases(sequence, expected_name, expected_value): """Test name synthesis edge cases.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name assert ks.value == expected_value @pytest.mark.parametrize("sequence,expected_name", [ # Base key usage: unicode_key=1089, base_key=99 ('c'), modifiers=5 (Ctrl) ('\x1b[1089::99;5u', 'KEY_CTRL_C'), # Press event: unicode_key=97 ('a'), modifiers=5 (Ctrl), event_type=1 (press) ('\x1b[97;5:1u', 'KEY_CTRL_A'), # Release event: unicode_key=97 ('a'), modifiers=5 (Ctrl), event_type=3 (release) ('\x1b[97;5:3u', 'KEY_CTRL_A_RELEASED'), # Repeat event: unicode_key=97 ('a'), modifiers=5 (Ctrl), event_type=2 (repeat) ('\x1b[97;5:2u', 'KEY_CTRL_A_REPEATED'), # Additional release event tests - text keys with modifiers ('\x1b[106;5:3u', 'KEY_CTRL_J_RELEASED'), ('\x1b[106;5u', 'KEY_CTRL_J'), ('\x1b[97;3:3u', 'KEY_ALT_A_RELEASED'), ('\x1b[122;7:3u', 'KEY_CTRL_ALT_Z_RELEASED'), ('\x1b[49;5:3u', 'KEY_CTRL_1_RELEASED'), # Repeat event tests ('\x1b[106;5:2u', 'KEY_CTRL_J_REPEATED'), ('\x1b[97;3:2u', 'KEY_ALT_A_REPEATED'), ]) def test_kitty_name_synthesis_special_cases(sequence, expected_name): """Test special cases in Kitty protocol name synthesis including event types.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name def test_kitty_name_synthesis_custom_name(): """Test custom name override in name synthesis.""" kitty_event = KittyKeyEvent(unicode_key=97, shifted_key=None, base_key=None, modifiers=5, event_type=1, int_codepoints=()) ks = Keystroke('\x1b[97;5u', name='CUSTOM_NAME', mode=-1, match=kitty_event) assert ks.name == 'CUSTOM_NAME' @pytest.mark.parametrize("sequence,expected_name", [ ('\x1b[97;5u', 'KEY_CTRL_A'), ('\x1b[122;3u', 'KEY_ALT_Z'), ('\x1b[77;7u', 'KEY_CTRL_ALT_M'), ('\x1b[98;6u', 'KEY_CTRL_SHIFT_B'), ]) def test_kitty_letter_name_synthesis_integration(sequence, expected_name): """Test letter name synthesis with Terminal.inkey().""" @as_subprocess def child(): term = Terminal(force_styling=True) term.ungetch(sequence) ks = term.inkey(timeout=0) assert ks == sequence assert ks.name == expected_name child() @pytest.mark.parametrize("sequence,expected_name", [ ('\x1b[P', 'KEY_F1'), ('\x1b[Q', 'KEY_F2'), ('\x1b[13~', 'KEY_F3'), ('\x1b[S', 'KEY_F4'), ]) def test_disambiguate_f1_f4_csi_sequences(sequence, expected_name): """Test F1-F4 recognition in disambiguate mode.""" @as_subprocess def child(): term = Terminal(force_styling=True) mapper = term._keymap codes = term._keycodes prefixes = set() ks = resolve_sequence(sequence, mapper, codes, prefixes, final=True) assert ks is not None assert ks.name == expected_name assert str(ks) == sequence child() @pytest.mark.parametrize("sequence,expected_name", [ ('\x1b[P', 'KEY_F1'), ('\x1b[Q', 'KEY_F2'), ('\x1b[13~', 'KEY_F3'), ('\x1b[S', 'KEY_F4'), ]) def test_disambiguate_f1_f4_via_inkey(sequence, expected_name): """Test F1-F4 disambiguate sequences with Terminal.inkey().""" @as_subprocess def child(): term = Terminal(stream=io.StringIO(), force_styling=True) term.ungetch(sequence) ks = term.inkey(timeout=0) assert ks == sequence assert ks.name == expected_name child() def test_disambiguate_f1_f4_not_confused_with_alt(): """Test F1-F4 not confused with ALT+[ sequences.""" @as_subprocess def child(): term = Terminal(stream=io.StringIO(), force_styling=True) # F1 should be \x1b[P, not confused with ALT+[ followed by P term.ungetch('\x1b[P') ks = term.inkey(timeout=0) # Should be recognized as F1, not as two separate keys assert ks.name == 'KEY_F1' assert str(ks) == '\x1b[P' assert len(ks) == 3 # Verify no leftover input remaining = term.inkey(timeout=0) assert remaining == '' child() @pytest.mark.parametrize("sequence,expected_name", [ ('\x1b[91;5u', 'CSI'), ('\x1b[64;5u', None), ('\x1b[96;5u', None), ('\x1b[123;5u', None), ('\x1b[65;5u', 'KEY_CTRL_A'), ('\x1b[90;5u', 'KEY_CTRL_Z'), ('\x1b[97;5u', 'KEY_CTRL_A'), ('\x1b[122;5u', 'KEY_CTRL_Z'), ]) def test_kitty_letter_name_synthesis_boundary_conditions(sequence, expected_name): """Test boundary conditions for letter detection.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name @pytest.mark.parametrize("initial_value,flag_name,bit_position", [ (0, 'disambiguate', 0), (0, 'report_events', 1), (0, 'report_alternates', 2), (0, 'report_all_keys', 3), (0, 'report_text', 4), (31, 'disambiguate', 0), (31, 'report_events', 1), (31, 'report_alternates', 2), (31, 'report_all_keys', 3), (31, 'report_text', 4), ]) def test_kitty_keyboard_protocol_individual_setters(initial_value, flag_name, bit_position): """Test individual setter operations with parameterized values.""" protocol = KittyKeyboardProtocol(initial_value) initial_flag_state = getattr(protocol, flag_name) # Toggle the flag setattr(protocol, flag_name, not initial_flag_state) new_flag_state = getattr(protocol, flag_name) # Verify the flag changed assert new_flag_state == (not initial_flag_state) # Verify the bit manipulation worked correctly bit_value = 2 ** bit_position if new_flag_state: # Flag was turned on, bit should be set assert protocol.value & bit_value == bit_value expected_value = initial_value | bit_value else: # Flag was turned off, bit should be clear assert protocol.value & bit_value == 0 expected_value = initial_value & ~bit_value assert protocol.value == expected_value @pytest.mark.parametrize("sequence,expected_key,expected_mods", [ ('\x1b[57442;5u', KEY_LEFT_CONTROL, 5), ('\x1b[57441;6u', KEY_LEFT_SHIFT, 6), ('\x1b[57449;3u', KEY_RIGHT_ALT, 3), ('\x1b[57441;2u', KEY_LEFT_SHIFT, 2), ('\x1b[57442;1u', KEY_LEFT_CONTROL, 1), ]) def test_kitty_pua_modifier_keys(sequence, expected_key, expected_mods): """Test Kitty PUA modifier key sequences.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_key assert ks.modifiers == expected_mods assert ks.value == '' @pytest.mark.parametrize("modifier,mod_value,char", [ ('super', 9, 97), ('hyper', 17, 97), ('meta', 33, 97), ]) def test_kitty_advanced_modifiers(modifier, mod_value, char): """Test super/hyper/meta modifiers.""" sequence = f'\x1b[{char};{mod_value}u' ks = _match_kitty_key(sequence) assert getattr(ks, f'_{modifier}') is True assert ks._ctrl is False assert ks._alt is False expected_name = f'KEY_{modifier.upper()}_{chr(char).upper()}' assert ks.name == expected_name @pytest.mark.parametrize("sequence,expected_name", [ ('\x1b[97;13u', 'KEY_CTRL_SUPER_A'), ('\x1b[122;11u', 'KEY_ALT_SUPER_Z'), ('\x1b[97;21u', 'KEY_CTRL_HYPER_A'), ('\x1b[97;37u', 'KEY_CTRL_META_A'), ('\x1b[97;57u', 'KEY_SUPER_HYPER_META_A'), ]) def test_kitty_compound_advanced_modifiers(sequence, expected_name): """Test compound modifier combinations.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name @pytest.mark.parametrize("sequence,expected_key,expected_text", [ ('\x1b[97;;97u', 97, (97,)), ('\x1b[97;u', 97, ()), ('\x1b[98;:1;98u', 98, (98,)), ('\x1b[122;;122:65u', 122, (122, 65)), ]) def test_kitty_empty_modifiers(sequence, expected_key, expected_text): """Test Kitty empty modifiers support.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_key assert ks._match.modifiers == 1 assert ks._match.int_codepoints == expected_text @pytest.mark.parametrize("sequence,expected_value", [ ('\x1b[97;;97u', 'a'), ('\x1b[97;;97:98u', 'ab'), ('\x1b[122;;122:120:121u', 'zxy'), ]) def test_kitty_int_codepoints_value(sequence, expected_value): """Test int_codepoints conversion to value string.""" ks = _match_kitty_key(sequence) # removed redundant assertion assert len(ks._match.int_codepoints) > 0 assert ks.value == expected_value @pytest.mark.parametrize("sequence,is_press,is_repeat,is_release", [ ('\x1b[97u', True, False, False), ('\x1b[97;1:1u', True, False, False), ('\x1b[97;1:2u', False, True, False), ('\x1b[97;1:3u', False, False, True), ]) def test_event_types_kitty(sequence, is_press, is_repeat, is_release): """Test event type properties for Kitty protocol.""" ks = _match_kitty_key(sequence) assert ks.pressed == is_press assert ks.repeated == is_repeat assert ks.released == is_release @pytest.mark.parametrize("sequence,is_press,is_repeat,is_release", [ ('\x1b[1;2Q', True, False, False), ('\x1b[1;2:1Q', True, False, False), ('\x1b[1;2:2Q', False, True, False), ('\x1b[1;2:3Q', False, False, True), ]) def test_event_types_legacy_csi(sequence, is_press, is_repeat, is_release): """Test event type properties for legacy CSI.""" ks = _match_legacy_csi_letter_form(sequence) assert ks.pressed == is_press assert ks.repeated == is_repeat assert ks.released == is_release @pytest.mark.parametrize("sequence,expected_name,expected_value", [ ('\x1b[1;2:3Q', 'KEY_SHIFT_F2_RELEASED', ''), ('\x1b[1;2:2Q', 'KEY_SHIFT_F2_REPEATED', ''), ('\x1b[1;2Q', 'KEY_SHIFT_F2', ''), ]) def test_event_type_name_suffixes(sequence, expected_name, expected_value): """Test name suffixes for event types.""" ks = _match_legacy_csi_letter_form(sequence) assert ks.name == expected_name assert ks.value == expected_value def test_event_type_dynamic_predicates(): """Test dynamic predicates with event types.""" ks_release = _match_legacy_csi_letter_form('\x1b[1;2:3Q') # These predicates would require event type suffix support assert ks_release.is_shift_f2_released() is True assert ks_release.is_shift_f2_pressed() is False ks_press = _match_legacy_csi_letter_form('\x1b[1;2Q') assert ks_press.is_shift_f2_pressed() is True assert ks_press.is_shift_f2_released() is False def test_plain_keystroke_defaults_to_pressed(): """Test plain keystrokes default to pressed.""" ks = Keystroke('a') assert ks.pressed is True assert ks.repeated is False assert ks.released is False @pytest.mark.parametrize("sequence,expected_code,expected_name", [ ('\x1b[57399u', 57399, 'KEY_KP_0'), ('\x1b[57400u', 57400, 'KEY_KP_1'), ('\x1b[57401u', 57401, 'KEY_KP_2'), ('\x1b[57402u', 57402, 'KEY_KP_3'), ('\x1b[57403u', 57403, 'KEY_KP_4'), ('\x1b[57404u', 57404, 'KEY_KP_5'), ('\x1b[57405u', 57405, 'KEY_KP_6'), ('\x1b[57406u', 57406, 'KEY_KP_7'), ('\x1b[57407u', 57407, 'KEY_KP_8'), ('\x1b[57408u', 57408, 'KEY_KP_9'), ('\x1b[57409u', 57409, 'KEY_KP_DECIMAL'), ('\x1b[57410u', 57410, 'KEY_KP_DIVIDE'), ('\x1b[57411u', 57411, 'KEY_KP_MULTIPLY'), ('\x1b[57412u', 57412, 'KEY_KP_SUBTRACT'), ('\x1b[57413u', 57413, 'KEY_KP_ADD'), ('\x1b[57414u', 57414, 'KEY_KP_ENTER'), ('\x1b[57415u', 57415, 'KEY_KP_EQUAL'), ('\x1b[57416u', 57416, 'KEY_KP_SEPARATOR'), ('\x1b[57417u', 57417, 'KEY_KP_LEFT'), ('\x1b[57418u', 57418, 'KEY_KP_RIGHT'), ('\x1b[57419u', 57419, 'KEY_KP_UP'), ('\x1b[57420u', 57420, 'KEY_KP_DOWN'), ('\x1b[57421u', 57421, 'KEY_KP_PAGE_UP'), ('\x1b[57422u', 57422, 'KEY_KP_PAGE_DOWN'), ('\x1b[57423u', 57423, 'KEY_KP_HOME'), ('\x1b[57424u', 57424, 'KEY_KP_END'), ('\x1b[57425u', 57425, 'KEY_KP_INSERT'), ('\x1b[57426u', 57426, 'KEY_KP_DELETE'), ('\x1b[57427u', 57427, 'KEY_KP_BEGIN'), ]) def test_kitty_all_keypad_keys(sequence, expected_code, expected_name): """Test all Kitty protocol keypad keys.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' @pytest.mark.parametrize("sequence,expected_code,modifier", [ ('\x1b[57424;5u', 57424, 5), # Ctrl+KP_END ('\x1b[57424;3u', 57424, 3), # Alt+KP_END ('\x1b[57424;7u', 57424, 7), # Ctrl+Alt+KP_END ('\x1b[57399;6u', 57399, 6), # Ctrl+Shift+KP_0 ]) def test_kitty_keypad_with_modifiers(sequence, expected_code, modifier): """Test keypad keys with modifiers.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks._match.modifiers == modifier assert ks.code == expected_code @pytest.mark.parametrize("sequence,event_type", [ ('\x1b[57424u', 1), # press (default) ('\x1b[57424;1:1u', 1), # press (explicit) ('\x1b[57424;1:2u', 2), # repeat ('\x1b[57424;1:3u', 3), # release ]) def test_kitty_keypad_event_types(sequence, event_type): """Test keypad keys with different event types.""" ks = _match_kitty_key(sequence) assert ks._match.event_type == event_type assert ks.pressed == (event_type == 1) assert ks.repeated == (event_type == 2) assert ks.released == (event_type == 3) @pytest.mark.parametrize("sequence,expected_code,expected_name,ctrl,alt,released,repeated", [ ('\x1b[57424u', 57424, 'KEY_KP_END', False, False, False, False), ('\x1b[57399u', 57399, 'KEY_KP_0', False, False, False, False), ('\x1b[57414u', 57414, 'KEY_KP_ENTER', False, False, False, False), ('\x1b[57424;5u', 57424, 'KEY_CTRL_KP_END', True, False, False, False), ('\x1b[57424;7u', 57424, 'KEY_CTRL_ALT_KP_END', True, True, False, False), ('\x1b[57424;1:3u', 57424, 'KEY_KP_END_RELEASED', False, False, True, False), ('\x1b[57424;1:2u', 57424, 'KEY_KP_END_REPEATED', False, False, False, True), ]) def test_kitty_keypad_inkey_integration( # pylint: disable=too-many-positional-arguments sequence, expected_code, expected_name, ctrl, alt, released, repeated): """Test keypad integration with Terminal.inkey().""" @as_subprocess def child(): term = Terminal(stream=io.StringIO(), force_styling=True) term.ungetch(sequence) ks = term.inkey(timeout=0) if not released and not repeated: assert ks == sequence assert ks.code == expected_code assert ks.name == expected_name assert ks._ctrl == ctrl assert ks._alt == alt assert ks.released == released assert ks.repeated == repeated child() @pytest.mark.parametrize("digit", range(10)) def test_kitty_keypad_digit_keys(digit): """Test keypad digit keys 0-9.""" code = 57399 + digit sequence = f'\x1b[{code}u' expected_name = f'KEY_KP_{digit}' ks = _match_kitty_key(sequence) assert ks.code == code assert ks.name == expected_name @pytest.mark.parametrize("sequence,expected_code,expected_name", [ # Lock and special function keys (57358-57363) ('\x1b[57358u', 57358, 'KEY_CAPS_LOCK'), ('\x1b[57359u', 57359, 'KEY_SCROLL_LOCK'), ('\x1b[57360u', 57360, 'KEY_NUM_LOCK'), ('\x1b[57361u', 57361, 'KEY_PRINT_SCREEN'), ('\x1b[57362u', 57362, 'KEY_PAUSE'), ('\x1b[57363u', 57363, 'KEY_MENU'), ]) def test_kitty_lock_and_special_keys(sequence, expected_code, expected_name): """Test lock and special function keys.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' # Functional keys don't produce text @pytest.mark.parametrize("sequence,expected_code,expected_name", [ # Extended function keys F13-F35 (57376-57398) ('\x1b[57376u', 57376, 'KEY_F13'), ('\x1b[57377u', 57377, 'KEY_F14'), ('\x1b[57378u', 57378, 'KEY_F15'), ('\x1b[57379u', 57379, 'KEY_F16'), ('\x1b[57380u', 57380, 'KEY_F17'), ('\x1b[57381u', 57381, 'KEY_F18'), ('\x1b[57382u', 57382, 'KEY_F19'), ('\x1b[57383u', 57383, 'KEY_F20'), ('\x1b[57384u', 57384, 'KEY_F21'), ('\x1b[57385u', 57385, 'KEY_F22'), ('\x1b[57386u', 57386, 'KEY_F23'), ('\x1b[57387u', 57387, 'KEY_F24'), ('\x1b[57388u', 57388, 'KEY_F25'), ('\x1b[57389u', 57389, 'KEY_F26'), ('\x1b[57390u', 57390, 'KEY_F27'), ('\x1b[57391u', 57391, 'KEY_F28'), ('\x1b[57392u', 57392, 'KEY_F29'), ('\x1b[57393u', 57393, 'KEY_F30'), ('\x1b[57394u', 57394, 'KEY_F31'), ('\x1b[57395u', 57395, 'KEY_F32'), ('\x1b[57396u', 57396, 'KEY_F33'), ('\x1b[57397u', 57397, 'KEY_F34'), ('\x1b[57398u', 57398, 'KEY_F35'), ]) def test_kitty_extended_f_keys(sequence, expected_code, expected_name): """Test extended function keys F13-F35.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' @pytest.mark.parametrize("sequence,expected_code,expected_name", [ # Media control keys (57428-57440) ('\x1b[57428u', 57428, 'KEY_MEDIA_PLAY'), ('\x1b[57429u', 57429, 'KEY_MEDIA_PAUSE'), ('\x1b[57430u', 57430, 'KEY_MEDIA_PLAY_PAUSE'), ('\x1b[57431u', 57431, 'KEY_MEDIA_REVERSE'), ('\x1b[57432u', 57432, 'KEY_MEDIA_STOP'), ('\x1b[57433u', 57433, 'KEY_MEDIA_FAST_FORWARD'), ('\x1b[57434u', 57434, 'KEY_MEDIA_REWIND'), ('\x1b[57435u', 57435, 'KEY_MEDIA_TRACK_NEXT'), ('\x1b[57436u', 57436, 'KEY_MEDIA_TRACK_PREVIOUS'), ('\x1b[57437u', 57437, 'KEY_MEDIA_RECORD'), ('\x1b[57438u', 57438, 'KEY_LOWER_VOLUME'), ('\x1b[57439u', 57439, 'KEY_RAISE_VOLUME'), ('\x1b[57440u', 57440, 'KEY_MUTE_VOLUME'), ]) def test_kitty_media_keys(sequence, expected_code, expected_name): """Test media control and volume keys.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' # Functional keys don't produce text @pytest.mark.parametrize("sequence,expected_code,expected_name", [ # ISO level shift keys (57453-57454) ('\x1b[57453u', 57453, 'KEY_ISO_LEVEL3_SHIFT'), ('\x1b[57454u', 57454, 'KEY_ISO_LEVEL5_SHIFT'), ]) def test_kitty_iso_level_shift_keys(sequence, expected_code, expected_name): """Test ISO level shift keys.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' # Functional keys don't produce text @pytest.mark.parametrize("sequence,expected_code,expected_name_part", [ ('\x1b[57358;5u', 57358, 'KEY_CTRL_CAPS_LOCK'), # Ctrl+CapsLock ('\x1b[57376;3u', 57376, 'KEY_ALT_F13'), # Alt+F13 ('\x1b[57428;2u', 57428, 'KEY_SHIFT_MEDIA_PLAY'), # Shift+MediaPlay ('\x1b[57438;7u', 57438, 'KEY_CTRL_ALT_LOWER_VOLUME'), # Ctrl+Alt+LowerVolume ]) def test_kitty_functional_keys_with_modifiers(sequence, expected_code, expected_name_part): """Test functional keys with various modifiers.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name_part assert ks.value == '' # Functional keys don't produce text @pytest.mark.parametrize("sequence,expected_code,event_type", [ ('\x1b[57361u', 57361, 1), # PrintScreen press (default) ('\x1b[57361;1:1u', 57361, 1), # PrintScreen press (explicit) ('\x1b[57361;1:2u', 57361, 2), # PrintScreen repeat ('\x1b[57361;1:3u', 57361, 3), # PrintScreen release ]) def test_kitty_functional_keys_event_types(sequence, expected_code, event_type): """Test functional keys with different event types.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks._match.event_type == event_type assert ks.pressed == (event_type == 1) assert ks.repeated == (event_type == 2) assert ks.released == (event_type == 3) @pytest.mark.parametrize("sequence,expected_code,expected_name", [ # Keypad digits with Ctrl ('\x1b[57399;5u', 57399, 'KEY_CTRL_KP_0'), ('\x1b[57400;5u', 57400, 'KEY_CTRL_KP_1'), ('\x1b[57408;5u', 57408, 'KEY_CTRL_KP_9'), # Keypad digits with Alt ('\x1b[57399;3u', 57399, 'KEY_ALT_KP_0'), ('\x1b[57405;3u', 57405, 'KEY_ALT_KP_6'), # Keypad digits with Shift ('\x1b[57399;2u', 57399, 'KEY_SHIFT_KP_0'), ('\x1b[57407;2u', 57407, 'KEY_SHIFT_KP_8'), # Keypad digits with Ctrl+Alt ('\x1b[57399;7u', 57399, 'KEY_CTRL_ALT_KP_0'), ('\x1b[57404;7u', 57404, 'KEY_CTRL_ALT_KP_5'), # Keypad digits with Ctrl+Shift ('\x1b[57399;6u', 57399, 'KEY_CTRL_SHIFT_KP_0'), ('\x1b[57403;6u', 57403, 'KEY_CTRL_SHIFT_KP_4'), # Keypad operators with Ctrl ('\x1b[57411;5u', 57411, 'KEY_CTRL_KP_MULTIPLY'), ('\x1b[57413;5u', 57413, 'KEY_CTRL_KP_ADD'), ('\x1b[57410;5u', 57410, 'KEY_CTRL_KP_DIVIDE'), ('\x1b[57412;5u', 57412, 'KEY_CTRL_KP_SUBTRACT'), # Keypad operators with Alt ('\x1b[57411;3u', 57411, 'KEY_ALT_KP_MULTIPLY'), ('\x1b[57413;3u', 57413, 'KEY_ALT_KP_ADD'), # Keypad operators with Ctrl+Alt ('\x1b[57409;7u', 57409, 'KEY_CTRL_ALT_KP_DECIMAL'), ('\x1b[57415;7u', 57415, 'KEY_CTRL_ALT_KP_EQUAL'), ]) def test_kitty_pua_keypad_with_modifiers(sequence, expected_code, expected_name): """Test PUA keypad keys with modifiers.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == expected_code assert ks.code == expected_code assert ks.name == expected_name assert ks.value == '' # Keypad keys don't produce text # Verify modifier flags if 'CTRL' in expected_name: assert ks._ctrl if 'ALT' in expected_name: assert ks._alt if 'SHIFT' in expected_name: assert ks._shift @pytest.mark.parametrize("sequence,unicode_key,expected_code,expected_name,expected_value", [ ('\x1b[27u', 27, KEY_EXIT, 'KEY_ESCAPE', '\x1b'), ('\x1b[9u', 9, KEY_TAB, 'KEY_TAB', '\t'), ('\x1b[13u', 13, KEY_ENTER, 'KEY_ENTER', '\n'), ('\x1b[127u', 127, KEY_BACKSPACE, 'KEY_BACKSPACE', '\x08'), ]) def test_kitty_control_chars(sequence, unicode_key, expected_code, expected_name, expected_value): """Test control character keys via Kitty protocol.""" ks = _match_kitty_key(sequence) assert ks._mode == -1 assert ks._match.unicode_key == unicode_key assert ks.code == expected_code assert ks.name == expected_name assert ks.value == expected_value @pytest.mark.parametrize("sequence,unicode_key,expected_code,expected_name", [ ('\x1b[27;5u', 27, KEY_EXIT, 'KEY_CTRL_ESCAPE'), ('\x1b[27;3u', 27, KEY_EXIT, 'KEY_ALT_ESCAPE'), ('\x1b[27;7u', 27, KEY_EXIT, 'KEY_CTRL_ALT_ESCAPE'), ('\x1b[9;5u', 9, KEY_TAB, 'KEY_CTRL_TAB'), ('\x1b[9;3u', 9, KEY_TAB, 'KEY_ALT_TAB'), ('\x1b[13;5u', 13, KEY_ENTER, 'KEY_CTRL_ENTER'), ('\x1b[13;3u', 13, KEY_ENTER, 'KEY_ALT_ENTER'), ('\x1b[127;5u', 127, KEY_BACKSPACE, 'KEY_CTRL_BACKSPACE'), ('\x1b[127;3u', 127, KEY_BACKSPACE, 'KEY_ALT_BACKSPACE'), ]) def test_kitty_control_chars_with_modifiers(sequence, unicode_key, expected_code, expected_name): """Test control character keys with modifiers.""" ks = _match_kitty_key(sequence) assert ks._match.unicode_key == unicode_key assert ks.code == expected_code assert ks.name == expected_name @pytest.mark.parametrize("sequence,event_type", [ ('\x1b[27u', 1), ('\x1b[27;1:1u', 1), ('\x1b[27;1:2u', 2), ('\x1b[27;1:3u', 3), ]) def test_kitty_control_chars_event_types(sequence, event_type): """Test control character event types.""" ks = _match_kitty_key(sequence) assert ks._match.event_type == event_type assert ks.pressed == (event_type == 1) assert ks.repeated == (event_type == 2) assert ks.released == (event_type == 3) @pytest.mark.parametrize( "sequence,expected_name,expected_code,expected_value,is_ctrl,is_released", [ ('\x1b[27u', 'KEY_ESCAPE', KEY_EXIT, '\x1b', False, False), ('\x1b[27;5u', 'KEY_CTRL_ESCAPE', KEY_EXIT, None, True, False), ('\x1b[27;1:3u', 'KEY_ESCAPE_RELEASED', KEY_EXIT, None, False, True), ]) def test_kitty_escape_key_with_protocol_enabled( # pylint: disable=too-many-positional-arguments sequence, expected_name, expected_code, expected_value, is_ctrl, is_released): """Test Escape key with Kitty protocol explicitly enabled.""" ks = _match_kitty_key(sequence) assert ks.name == expected_name assert ks.code == expected_code if expected_value is not None: assert ks.value == expected_value if is_ctrl: assert ks._ctrl is True if is_released: assert ks.released is True @pytest.mark.parametrize("sequence,expected_name,expected_code,ctrl,alt,released,repeated", [ ('\x1b[27u', 'KEY_ESCAPE', KEY_EXIT, False, False, False, False), ('\x1b[27;1:1u', 'KEY_ESCAPE', KEY_EXIT, False, False, False, False), ('\x1b[27;1:3u', 'KEY_ESCAPE_RELEASED', KEY_EXIT, False, False, True, False), ('\x1b[27;1:2u', 'KEY_ESCAPE_REPEATED', KEY_EXIT, False, False, False, True), ('\x1b[27;5u', 'KEY_CTRL_ESCAPE', KEY_EXIT, True, False, False, False), ('\x1b[27;3u', 'KEY_ALT_ESCAPE', KEY_EXIT, False, True, False, False), ('\x1b[27;7u', 'KEY_CTRL_ALT_ESCAPE', KEY_EXIT, True, True, False, False), ]) def test_kitty_escape_key_integration( # pylint: disable=too-many-positional-arguments sequence, expected_name, expected_code, ctrl, alt, released, repeated): """Test ESC key sequences via Terminal.inkey() integration.""" @as_subprocess def child(): term = Terminal(stream=io.StringIO(), force_styling=True) term.ungetch(sequence) ks = term.inkey(timeout=0) assert ks == sequence assert ks.name == expected_name assert ks.code == expected_code assert ks._ctrl == ctrl assert ks._alt == alt assert ks.released == released assert ks.repeated == repeated if released: assert ks.value == '' else: assert ks.value == '\x1b' child() @pytest.mark.parametrize("sequence,expected_name,expected_code,expected_value,alt", [ ('\x1b[9u', 'KEY_TAB', KEY_TAB, '\t', False), ('\x1b[9;3u', 'KEY_ALT_TAB', KEY_TAB, '\t', True), ('\x1b[13u', 'KEY_ENTER', KEY_ENTER, '\n', False), ('\x1b[127u', 'KEY_BACKSPACE', KEY_BACKSPACE, '\x08', False), ]) def test_kitty_control_key_integration(sequence, expected_name, expected_code, expected_value, alt): """Test control key integration with Terminal.inkey().""" @as_subprocess def child(): term = Terminal(stream=io.StringIO(), force_styling=True) term.ungetch(sequence) ks = term.inkey(timeout=0) assert ks.name == expected_name assert ks.code == expected_code assert ks.value == expected_value assert ks._alt == alt child() @pytest.mark.skipif(not TEST_KEYBOARD, reason="TEST_KEYBOARD not specified") def test_kitty_negotiation_timing_cached_failure(): """Test timing of cached failure returns immediately.""" @as_subprocess def child(): term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True stime = time.time() flags1 = term.get_kitty_keyboard_state(timeout=0.025) assert flags1 is None assert term._kitty_kb_first_query_failed is True elapsed_ms = (time.time() - stime) * 1000 assert 24 <= elapsed_ms <= 35 # any subsequent calls return immediately (as failed) stime = time.time() flags2 = term.get_kitty_keyboard_state(timeout=1.0) elapsed_ms = (time.time() - stime) * 1000 assert flags2 is None assert elapsed_ms < 5 child() @pytest.mark.skipif(not TEST_KEYBOARD, reason="TEST_KEYBOARD not specified") def test_kitty_negotiation_force_True_incurs_second_timeout(): """Test timing of force=True incurs timeout again.""" @as_subprocess def child(): term = TestTerminal(stream=io.StringIO(), force_styling=True) term._is_a_tty = True flags1 = term.get_kitty_keyboard_state(timeout=0.025) assert flags1 is None assert term._kitty_kb_first_query_failed is True # demonstrate that the 'force=True' argument works as designed by its # side-effect of exceeding our timeout (again). stime = time.time() flags2 = term.get_kitty_keyboard_state(timeout=0.025, force=True) elapsed_ms = (time.time() - stime) * 1000 assert flags2 is None assert 20 <= elapsed_ms <= 35 child() def test_kitty_keyboard_protocol_report_all_keys_setter_false(): """Test report_all_keys setter with False value.""" protocol = KittyKeyboardProtocol(31) assert protocol.report_all_keys is True protocol.report_all_keys = False assert protocol.report_all_keys is False assert protocol.value == 23 def test_kitty_keyboard_protocol_report_text_getter_setter(): """Test report_text property getter and setter.""" protocol = KittyKeyboardProtocol(0) assert protocol.report_text is False protocol.report_text = True assert protocol.report_text is True assert protocol.value == 16 protocol.report_text = False assert protocol.report_text is False assert protocol.value == 0 @pytest.mark.parametrize("value,expected_flags", [ (0, []), (1, ['disambiguate']), (2, ['report_events']), (4, ['report_alternates']), (8, ['report_all_keys']), (16, ['report_text']), (3, ['disambiguate', 'report_events']), (12, ['report_alternates', 'report_all_keys']), (31, ['disambiguate', 'report_events', 'report_alternates', 'report_all_keys', 'report_text']), ]) def test_kitty_keyboard_protocol_repr_all_combinations(value, expected_flags): """Test __repr__ with all flag combinations.""" protocol = KittyKeyboardProtocol(value) repr_str = repr(protocol) assert f'KittyKeyboardProtocol(value={value}' in repr_str for flag in expected_flags: assert flag in repr_str if not expected_flags: assert 'flags=[]' in repr_str def test_kitty_keyboard_protocol_equality_with_protocol(): """Test __eq__ with another KittyKeyboardProtocol instance.""" proto1 = KittyKeyboardProtocol(15) proto2 = KittyKeyboardProtocol(15) proto3 = KittyKeyboardProtocol(7) assert proto1 == proto2 assert proto1 != proto3 def test_kitty_keyboard_protocol_equality_with_int(): """Test __eq__ with int values.""" protocol = KittyKeyboardProtocol(15) assert protocol == 15 assert protocol != 7 def test_kitty_keyboard_protocol_equality_with_other_types(): """Test __eq__ with types that are neither KittyKeyboardProtocol nor int.""" protocol = KittyKeyboardProtocol(15) assert protocol != "15" assert protocol != 15.0 assert protocol is not None assert protocol != [15] assert protocol != {'value': 15}