#!/usr/bin/env python # License: GPL v3 Copyright: 2016, Kovid Goyal import fcntl import io import os import select import shlex import shutil import signal import struct import sys import termios import time from contextlib import contextmanager, suppress from functools import wraps from unittest import TestCase from kitty.config import finalize_keys, finalize_mouse_mappings from kitty.fast_data_types import TEXT_SIZE_CODE, Cursor, HistoryBuf, LineBuf, Screen, get_options, monotonic, set_options from kitty.options.parse import merge_result_dicts from kitty.options.types import Options, defaults from kitty.options.utils import mouse_wheel_buttons from kitty.rgb import to_color from kitty.types import MouseEvent from kitty.window import da1, decode_cmdline, process_remote_print, process_title_from_child from . import is_ci def parse_bytes(screen, data, dump_callback=None): data = memoryview(data) while data: dest = screen.test_create_write_buffer() s = screen.test_commit_write_buffer(data, dest) data = data[s:] screen.test_parse_written_data(dump_callback) def draw_multicell( screen: Screen, text: str, width: int = 0, scale: int = 1, subscale_n: int = 0, subscale_d: int = 0, vertical_align: int = 0, horizontal_align: int = 0 ) -> None: cmd = f'\x1b]{TEXT_SIZE_CODE};w={width}:s={scale}:n={subscale_n}:d={subscale_d}:v={vertical_align}:h={horizontal_align};{text}\a' parse_bytes(screen, cmd.encode()) class Callbacks: def __init__(self, pty=None) -> None: self.clear() self.pty = pty self.ftc = None self.set_pointer_shape = lambda data: None self.last_cmd_at = 0 self.last_cmd_cmdline = '' self.last_cmd_exit_status = sys.maxsize def write(self, data) -> None: self.wtcbuf += bytes(data) def notify_child_of_resize(self): self.num_of_resize_events += 1 def on_reset(self, is_hard_reset: bool = True) -> None: if self.pty is not None: self.pty.reset_termios_state() def color_control(self, code, data) -> None: from kitty.fast_data_types import base64_decode from kitty.window import color_control response = color_control(self.color_profile, code, data) if response: def p(x): if '@' in x: return (to_color(x.partition('@')[0]), int(255 * float(x.partition('@')[2]))) ans = to_color(x) if ans is None: ans = x return ans parts = {} for x in response.split(';')[1:]: k, _, v = x.partition('=') if k == 'unknown': # unknown field names are base64 encoded, collect the decoded names in a list parts.setdefault('unknown', []).append(base64_decode(v).decode('ascii')) else: parts[k] = p(v) self.color_control_responses.append(parts) def title_changed(self, data, is_base64=False) -> None: self.titlebuf.append(process_title_from_child(data, is_base64, '')) def on_cwd_change(self, raw_url) -> None: self.cwd_changes.append(raw_url) def osc_context(self, data): pass def program_status_report(self, data): self.program_status_reports.append(str(data, 'utf-8')) def icon_changed(self, data) -> None: self.iconbuf += str(data, 'utf-8') def set_dynamic_color(self, code, data='') -> None: if code == 22: self.set_pointer_shape(data) else: self.colorbuf += str(data or b'', 'utf-8') def set_color_table_color(self, code, data='') -> None: self.ctbuf += '' def color_profile_popped(self, x) -> None: pass def cmd_output_marking(self, is_start: bool | None, data: str = '') -> None: if is_start: self.last_cmd_at = monotonic() self.last_cmd_cmdline = decode_cmdline(data) if data else data else: if self.last_cmd_at != 0: self.last_cmd_at = 0 with suppress(Exception): self.last_cmd_exit_status = int(data) def request_capabilities(self, q) -> None: from kitty.terminfo import get_capabilities for c in get_capabilities(q, None): self.write(c.encode('ascii')) def desktop_notify(self, osc_code: int, raw_data: memoryview) -> None: self.notifications.append((osc_code, str(raw_data, 'utf-8'))) def open_url(self, url: str, hyperlink_id: int) -> None: self.open_urls.append((url, hyperlink_id)) def clipboard_control(self, data: memoryview, is_partial: bool = False) -> None: self.cc_buf.append((str(data, 'utf-8'), is_partial)) def clear(self) -> None: self.wtcbuf = b'' self.iconbuf = self.colorbuf = self.ctbuf = '' self.titlebuf = [] self.cwd_changes = [] self.printbuf = [] self.color_control_responses = [] self.notifications = [] self.program_status_reports = [] self.open_urls = [] self.cc_buf = [] self.bell_count = 0 self.clone_cmds = [] self.current_clone_data = '' self.last_cmd_exit_status = sys.maxsize self.last_cmd_cmdline = '' self.last_cmd_at = 0 self.num_of_resize_events = 0 self.da1 = [] def on_bell(self) -> None: self.bell_count += 1 def on_da1(self) -> None: opts = None with suppress(RuntimeError): opts = get_options() if opts is None: opts = defaults payload = da1(opts) self.da1.append(payload) if self.pty and self.pty.needs_da1: self.pty.send_da1_response(payload) def on_activity_since_last_focus(self) -> None: pass def finish_scroll_animation(self) -> None: pass def on_mouse_event(self, event): steps = 1 if event['button'] in mouse_wheel_buttons: # repeat_count is the number of wheel steps steps, event['repeat_count'] = event['repeat_count'], 1 ev = MouseEvent(**event) opts = get_options() action_def = opts.mousemap.get(ev) if not action_def: return False self.current_mouse_button = ev.button for _ in range(steps): for action in opts.alias_map.resolve_aliases(action_def, 'mouse_map'): getattr(self, action.func)(*action.args) self.current_mouse_button = 0 return True def handle_remote_print(self, msg): text = process_remote_print(msg) self.printbuf.append(text) def handle_remote_cmd(self, msg): pass def handle_remote_clone(self, msg): msg = str(msg, 'utf-8') if not msg: if self.current_clone_data: cdata, self.current_clone_data = self.current_clone_data, '' from kitty.launch import CloneCmd self.clone_cmds.append(CloneCmd(cdata)) self.current_clone_data = '' return num, rest = msg.split(':', 1) if num == '0' or len(self.current_clone_data) > 1024 * 1024: self.current_clone_data = '' self.current_clone_data += rest def handle_remote_ssh(self, msg): from kittens.ssh.utils import get_ssh_data if self.pty: for line in get_ssh_data(msg, 'testing'): self.pty.write_to_child(line) def handle_remote_echo(self, msg): from base64 import standard_b64decode if self.pty: data = standard_b64decode(msg) self.pty.write_to_child(data) def file_transmission(self, data): if self.ftc: self.ftc.handle_serialized_command(data) def filled_line_buf(ynum=5, xnum=5, cursor=Cursor()): ans = LineBuf(ynum, xnum) cursor.x = 0 for i in range(ynum): t = (f'{i}') * xnum ans.line(i).set_text(t, 0, xnum, cursor) return ans def filled_cursor(): ans = Cursor() ans.bold = ans.italic = ans.reverse = ans.strikethrough = ans.dim = True ans.fg = 0x101 ans.bg = 0x201 ans.decoration_fg = 0x301 return ans def filled_history_buf(ynum=5, xnum=5, cursor=Cursor()): lb = filled_line_buf(ynum, xnum, cursor) ans = HistoryBuf(ynum, xnum) for i in range(ynum): ans.push(lb.line(i)) return ans max_attempts = 4 if is_ci else 2 sleep_duration = 4 if is_ci else 2 def retry_on_failure(max_attempts=max_attempts, sleep_duration=sleep_duration): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): for attempt in range(max_attempts): try: return func(*args, **kwargs) except Exception: if attempt < max_attempts - 1: # Don't sleep on the last attempt time.sleep(sleep_duration) print(f'{func.__name__} failed, retrying in {sleep_duration} seconds', file=sys.stderr) else: raise # Re-raise the last exception return wrapper return decorator class BaseTest(TestCase): ae = TestCase.assertEqual maxDiff = 2048 is_ci = is_ci def rmtree_ignoring_errors(self, tdir): try: shutil.rmtree(tdir) except FileNotFoundError as err: print('Failed to delete the directory:', tdir, 'with error:', err, file=sys.stderr) def tearDown(self): set_options(None) def set_options(self, options=None): final_options = {'scrollback_pager_history_size': 1024, 'click_interval': 0.5} if options: final_options.update(options) options = Options(merge_result_dicts(defaults._asdict(), final_options)) finalize_keys(options, {}) finalize_mouse_mappings(options, {}) set_options(options) return options def cmd_to_run_python_code(self, code): from kitty.constants import kitty_exe return [kitty_exe(), '+runpy', code] def create_screen(self, cols=5, lines=5, scrollback=5, cell_width=10, cell_height=20, options=None): self.set_options(options) c = Callbacks() s = Screen(c, lines, cols, scrollback, cell_width, cell_height, 0, c) c.color_profile = s.color_profile return s def create_pty( self, argv=None, cols=80, lines=100, scrollback=100, cell_width=10, cell_height=20, options=None, cwd=None, env=None, stdin_fd=None, needs_da1=False, ): self.set_options(options) return PTY( argv, lines, cols, scrollback, cell_width, cell_height, cwd, env, stdin_fd=stdin_fd, needs_da1=needs_da1, ) def assertEqualAttributes(self, c1, c2): x1, y1, c1.x, c1.y = c1.x, c1.y, 0, 0 x2, y2, c2.x, c2.y = c2.x, c2.y, 0, 0 try: self.assertEqual(c1, c2) finally: c1.x, c1.y, c2.x, c2.y = x1, y1, x2, y2 debug_stdout = debug_stderr = -1 @contextmanager def forwardable_stdio(): global debug_stderr, debug_stdout debug_stdout = fd = os.dup(sys.stdout.fileno()) os.set_inheritable(fd, True) debug_stderr = fd = os.dup(sys.stderr.fileno()) os.set_inheritable(fd, True) try: yield finally: os.close(debug_stderr) os.close(debug_stdout) debug_stderr = debug_stdout = -1 class PTY: def __init__( self, argv=None, rows=25, columns=80, scrollback=100, cell_width=10, cell_height=20, cwd=None, env=None, stdin_fd=None, needs_da1=True, window_id=0, log_data_flow=False, ): self.log_data_flow = log_data_flow if isinstance(argv, str): argv = shlex.split(argv) self.write_buf = b'' self.child_pid = 0 self.child_waited_for = False self.cell_width = cell_width self.cell_height = cell_height if argv is None: from kitty.child import openpty self.master_fd, self.slave_fd = openpty() self.initial_termios_state = termios.tcgetattr(self.master_fd) else: self.child_pid, self.master_fd = self.spawn_child(argv, rows, columns, cwd, env, stdin_fd) if stdin_fd is not None: os.close(stdin_fd) os.set_blocking(self.master_fd, False) self.set_window_size(rows=rows, columns=columns) self.needs_da1 = needs_da1 self.callbacks = Callbacks(self) self.screen = Screen(self.callbacks, rows, columns, scrollback, cell_width, cell_height, window_id, self.callbacks) self.received_bytes = b'' def spawn_child(self, argv, rows, columns, cwd, env, stdin_fd): # Do not use pty.fork() as that runs Python code in the forked child # before exec(), and macOS (since Tahoe 26.2) sometimes kills processes # that do anything non-trivial between fork() and exec() with SIGKILL. # spawn() does all the child setup in C using only async-signal-safe # functions. The window size is set before spawning so that the child # sees the correct size from the start. from kitty.child import openpty from kitty.constants import kitten_exe from kitty.fast_data_types import spawn master, slave = openpty() try: s = struct.pack('HHHH', rows, columns, columns * self.cell_width, rows * self.cell_height) fcntl.ioctl(master, termios.TIOCSWINSZ, s) env = dict(os.environ if env is None else env) pass_fds: tuple[int, ...] = () if debug_stdout > -1: env['KITTY_STDIO_FORWARDED'] = str(debug_stdout) pass_fds = (debug_stdout, debug_stderr) ready_read_fd, ready_write_fd = os.pipe() try: pid = spawn( argv[0], cwd or os.getcwd(), tuple(argv), tuple(f'{k}={v}' for k, v in env.items()), master, slave, -1 if stdin_fd is None else stdin_fd, -1, ready_read_fd, ready_write_fd, (), kitten_exe(), False, pass_fds, ) finally: os.close(ready_read_fd) # Closing the write end tells the child it can exec os.close(ready_write_fd) except BaseException: os.close(master) raise finally: os.close(slave) return pid, master def reset_termios_state(self): if s := getattr(self, 'initial_termios_state', None): termios.tcsetattr(self.master_fd, termios.TCSANOW, s) def turn_off_echo(self): s = termios.tcgetattr(self.master_fd) s[3] &= ~termios.ECHO termios.tcsetattr(self.master_fd, termios.TCSANOW, s) def is_echo_on(self): s = termios.tcgetattr(self.master_fd) return True if s[3] & termios.ECHO else False def __enter__(self): return self def __exit__(self, *a): self.__del__() def __del__(self): if hasattr(self, 'master_fd'): os.close(self.master_fd) del self.master_fd if hasattr(self, 'slave_fd'): os.close(self.slave_fd) del self.slave_fd if getattr(self, 'child_pid', 0) > 0 and not self.child_waited_for: st = time.monotonic() while time.monotonic() - st < 2: pid, ec = os.waitpid(self.child_pid, os.WNOHANG) if pid == self.child_pid: self.child_waited_for = True break time.sleep(0.1) if not self.child_waited_for: os.kill(self.child_pid, signal.SIGKILL) os.waitpid(self.child_pid, 0) self.child_waited_for = True def write_to_child(self, data, flush=False): if isinstance(data, str): data = data.encode('utf-8') if self.log_data_flow: print('t -> c:', bytes(data)) self.write_buf += data if flush: self.process_input_from_child(0) def send_da1_response(self, data: str) -> None: self.write_to_child('\x1b[' + data, flush=False) # ]]]]]] def send_cmd_to_child(self, cmd, flush=False): self.callbacks.last_cmd_exit_status = sys.maxsize self.last_cmd = cmd self.write_to_child(cmd + '\r', flush=flush) def process_input_from_child(self, timeout=10): rd, wd, _ = select.select([self.master_fd], [self.master_fd] if self.write_buf else [], [], max(0, timeout)) if wd: n = os.write(self.master_fd, self.write_buf) self.write_buf = self.write_buf[n:] bytes_read = 0 if rd: data = os.read(self.master_fd, io.DEFAULT_BUFFER_SIZE) bytes_read += len(data) self.received_bytes += data if self.log_data_flow: print('c -> t:', data) parse_bytes(self.screen, data) return bytes_read def wait_till(self, q, timeout=10, timeout_msg=None): end_time = time.monotonic() + timeout while not q() and time.monotonic() <= end_time: try: self.process_input_from_child(timeout=end_time - time.monotonic()) except OSError as e: if not q(): raise Exception(f'Failed to read from pty with error: {e}. {self.screen_contents_for_error()}') from e return if not q(): msg = 'The condition was not met' if timeout_msg is not None: msg = timeout_msg() if not msg.endswith('\n'): msg += '. ' raise TimeoutError(f'Timed out after {timeout} seconds: {msg}{self.screen_contents_for_error()}') def wait_till_child_exits(self, timeout=30 if BaseTest.is_ci else 10, require_exit_code=None): end_time = time.monotonic() + timeout while time.monotonic() <= end_time: si_pid, status = os.waitpid(self.child_pid, os.WNOHANG) if si_pid == self.child_pid: # The child has been reaped, calling waitpid() on it again # would fail with ECHILD, so handle every kind of termination # here, not just a normal exit. self.child_waited_for = True with suppress(OSError): while self.process_input_from_child(timeout=0): pass if os.WIFSIGNALED(status): sig = os.WTERMSIG(status) try: signame = signal.Signals(sig).name except ValueError: signame = str(sig) raise AssertionError(f'Child was killed by signal: {signame}. {self.screen_contents_for_error()}') ec = os.waitstatus_to_exitcode(status) if require_exit_code is not None and ec != require_exit_code: raise AssertionError(f'Child exited with exit status: {status} code: {ec} != {require_exit_code}. {self.screen_contents_for_error()}') return status with suppress(OSError): self.process_input_from_child(timeout=0.02) raise AssertionError(f'Child did not exit in {timeout} seconds. {self.screen_contents_for_error()}') def set_window_size(self, rows=25, columns=80, send_signal=True): if hasattr(self, 'screen'): self.screen.resize(rows, columns) if send_signal: x_pixels = columns * self.cell_width y_pixels = rows * self.cell_height s = struct.pack('HHHH', rows, columns, x_pixels, y_pixels) fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, s) def screen_contents_for_error(self): from kitty.window import as_text ans = as_text(self.screen, add_history=True, as_ansi=False) return f'Screen contents as repr:\n{ans!r}\nScreen contents:\n{ans.rstrip()}' def screen_contents(self): lines = [] for i in range(self.screen.lines): x = str(self.screen.line(i)) if x: lines.append(x) return '\n'.join(lines) def last_cmd_output(self, as_ansi=False, add_wrap_markers=False): from kitty.window import cmd_output return cmd_output(self.screen, as_ansi=as_ansi, add_wrap_markers=add_wrap_markers)