mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
On Linux and BSD, kitty now falls back to rendering on the CPU with the Mesa lavapipe (Vulkan) or llvmpipe (OpenGL) software renderers when no usable GPU is found, such as in virtual machines or with broken GPU drivers. This is the new software value of the gpu_driver option, last in the default list. Drivers are now told which kind of renderer they may use. The software candidates use only software renderers: Vulkan selects CPU devices and OpenGL sets LIBGL_ALWAYS_SOFTWARE and __GLX_VENDOR_LIBRARY_NAME while the renderer is chosen, restoring them afterwards so they are not passed on to child programs. The other candidates reject software renderers, unless they are last, so that a working GPU, even one usable only by a later driver, is always preferred to the CPU. Previously, on systems with a GPU usable only with OpenGL, kitty would use lavapipe. Drivers report whether they render in software in their capabilities. Failing to initialize the GPU driver for the first window is no longer fatal: the window is recreated with the next driver, as is already done for failures creating surfaces. OpenGL can only detect that it is using llvmpipe once a context is current. When software rendering is used, a message saying so is shown at the top of every OS window for five seconds after it is first rendered.
677 lines
30 KiB
Python
677 lines
30 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
|
|
from kitty.constants import SOFTWARE_GPU_DRIVERS, available_gpu_drivers, gpu_driver_path, kitty_exe
|
|
from kitty.fast_data_types import Color, test_cursor_blink_easing_function
|
|
from kitty.options.utils import DELETE_ENV_VAR, EasingFunction, build_action_aliases, to_color
|
|
from kitty.utils import log_error, shlex_split
|
|
|
|
from .base import BaseTest
|
|
|
|
|
|
class TestConfParsing(BaseTest):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.error_messages = []
|
|
log_error.redirect = self.error_messages.append
|
|
self.tdir = tempfile.mkdtemp()
|
|
|
|
def tearDown(self):
|
|
del log_error.redirect
|
|
shutil.rmtree(self.tdir)
|
|
super().tearDown()
|
|
|
|
def test_conf_parsing(self):
|
|
conf_parsing(self)
|
|
|
|
def test_launcher(self):
|
|
launcher(self)
|
|
|
|
def test_cli_parsing(self):
|
|
cli_parsing(self)
|
|
|
|
def test_font_size_clamping(self):
|
|
font_size_clamping(self)
|
|
|
|
def test_patch_global_special_colors(self):
|
|
from kitty.fast_data_types import patch_global_colors
|
|
|
|
self.set_options()
|
|
try:
|
|
for name, value in (
|
|
('wayland_titlebar_color', 0x80000002),
|
|
('scrollbar_handle_color', 0xFF000002),
|
|
('scrollbar_track_color', 0xFFFFFF02),
|
|
('macos_titlebar_color', -1),
|
|
('macos_titlebar_color', -2),
|
|
):
|
|
with self.subTest(name=name, value=value):
|
|
patch_global_colors({name: value}, False)
|
|
# These options are decoded as unsigned, so negative values must be
|
|
# rejected on all platforms, not silently stored.
|
|
for name in ('wayland_titlebar_color', 'scrollbar_handle_color', 'scrollbar_track_color'):
|
|
with self.subTest(name=name, value=-1), self.assertRaises(OverflowError):
|
|
patch_global_colors({name: -1}, False)
|
|
finally:
|
|
self.set_options()
|
|
|
|
def test_session_launch_option_expansion(self) -> None:
|
|
from kitty.launch import LaunchSpec
|
|
from kitty.options.types import defaults
|
|
from kitty.session import parse_session
|
|
|
|
for command in (
|
|
'--title bash --cwd $SESSION_DIR bash $COMMAND_ARG',
|
|
'--title=bash --cwd=$SESSION_DIR bash $COMMAND_ARG',
|
|
'--title bash --cwd $SESSION_DIR -- bash $COMMAND_ARG',
|
|
'--title other --cwd $SESSION_DIR bash $COMMAND_ARG',
|
|
):
|
|
with self.subTest(command=command):
|
|
(session,) = parse_session(f'launch {command}', defaults, environ={'SESSION_DIR': '/tmp/session', 'COMMAND_ARG': 'expanded'})
|
|
spec = session.tabs[0].windows[0].launch_spec
|
|
assert isinstance(spec, LaunchSpec)
|
|
self.ae(spec.opts.cwd, '/tmp/session')
|
|
self.ae(spec.args, ['bash', '$COMMAND_ARG'])
|
|
|
|
def test_session_discovery(self):
|
|
from unittest.mock import patch
|
|
|
|
from kitty.config import load_config
|
|
from kitty.constants import config_dir
|
|
from kitty.fast_data_types import set_options
|
|
from kitty.session import get_all_known_sessions, seen_session_paths
|
|
|
|
def discover(*lines):
|
|
bad_lines = []
|
|
opts = load_config(overrides=('clear_all_shortcuts yes', *lines), accumulate_bad_lines=bad_lines)
|
|
self.assertFalse(bad_lines)
|
|
set_options(opts)
|
|
return get_all_known_sessions()
|
|
|
|
with patch.dict(seen_session_paths, {}, clear=True):
|
|
for args, name in (
|
|
('work.kitty-session', 'work'),
|
|
('--sort-by alphabetical work.kitty-session', 'work'),
|
|
('--sort-by=alphabetical work.kitty-session', 'work'),
|
|
('--active-only=no --sort-by recent work.kitty-session', 'work'),
|
|
('work.kitty-session --sort-by alphabetical', 'work'),
|
|
('-- "-work project.kitty-session"', '-work project'),
|
|
('-- -0', '-0'),
|
|
('', ''),
|
|
('--sort-by alphabetical', ''),
|
|
('--sort-by=alphabetical', ''),
|
|
('--active-only', ''),
|
|
('-1', ''),
|
|
('-- -1', ''),
|
|
('--sort-by alphabetical -- -2', ''),
|
|
('--sort-by', ''),
|
|
('--sort-by invalid work.kitty-session', ''),
|
|
('--unknown work.kitty-session', ''),
|
|
('--active-only=invalid work.kitty-session', ''),
|
|
):
|
|
with self.subTest(args=args):
|
|
filename = f'{name}.kitty-session' if name != '-0' else name
|
|
expected = {name: os.path.join(config_dir, filename)} if name else {}
|
|
self.ae(discover(f'map f7 goto_session {args}'), expected)
|
|
|
|
seen_path = os.path.join(self.tdir, 'work.kitty-session')
|
|
seen_session_paths['work'] = seen_path
|
|
self.ae(
|
|
discover(
|
|
'action_alias project goto_session --sort-by alphabetical',
|
|
'map f7 project work.kitty-session',
|
|
'map f8 combine : goto_session --sort-by : project other.kitty-session',
|
|
),
|
|
{'work': seen_path, 'other': os.path.join(config_dir, 'other.kitty-session')},
|
|
)
|
|
|
|
def test_launch_transparent_color_overrides(self) -> None:
|
|
from kitty.launch import apply_colors
|
|
from kitty.window import Window
|
|
|
|
cases = (
|
|
(('transparent_background_colors=#ffffff@0.5', 'foreground=red'), ((Color(255, 255, 255), 0.5),)),
|
|
(('foreground=red', 'transparent_background_colors=#ffffff@0.5'), ((Color(255, 255, 255), 0.5),)),
|
|
(('transparent_background_colors=#ffffff@0.5', 'foreground=red', 'transparent_background_colors='), ()),
|
|
(('transparent_background_colors=#ffffff@0.5', 'transparent_background_colors=#000000@0.25', 'foreground=red'), ((Color(0, 0, 0), 0.25),)),
|
|
)
|
|
for colors, expected in cases:
|
|
with self.subTest(colors=colors):
|
|
window = Window.__new__(Window)
|
|
window.screen = self.create_screen()
|
|
apply_colors(window, colors)
|
|
actual = window.screen.color_profile.as_dict()
|
|
self.ae(actual.get('transparent_background_colors', ()), expected)
|
|
self.ae(actual['foreground'], 0xFF0000)
|
|
|
|
# colors that do not mention transparent_background_colors must leave existing ones unchanged
|
|
window = Window.__new__(Window)
|
|
window.screen = self.create_screen()
|
|
apply_colors(window, ('transparent_background_colors=#ffffff@0.5',))
|
|
apply_colors(window, ('foreground=red',))
|
|
self.ae(window.screen.color_profile.as_dict().get('transparent_background_colors', ()), ((Color(255, 255, 255), 0.5),))
|
|
apply_colors(window, ('transparent_background_colors=',))
|
|
self.ae(window.screen.color_profile.as_dict().get('transparent_background_colors', ()), ())
|
|
|
|
|
|
def cli_parsing(self):
|
|
from kitty.cli import CLIOptions, Options, parse_cmdline, parse_option_spec
|
|
|
|
seq, disabled = parse_option_spec("""\
|
|
--simple-string -s
|
|
a simple string
|
|
|
|
|
|
--list -l
|
|
type=list
|
|
a list
|
|
|
|
|
|
--choice -c
|
|
choices=a,b,c
|
|
some choices
|
|
|
|
|
|
--bool-set -1
|
|
type=bool-set
|
|
set a bool
|
|
|
|
|
|
--bool-reset -0
|
|
type=bool-reset
|
|
unset a bool
|
|
|
|
|
|
--int -i
|
|
type=int
|
|
a integer
|
|
|
|
|
|
--float -f
|
|
type=float
|
|
a float
|
|
|
|
|
|
--version -v
|
|
type=bool-set
|
|
version
|
|
""")
|
|
oc = Options(seq, usage='xxx', message='yyy', appname='test')
|
|
oc.do_print = False
|
|
|
|
def t(args, leftover=(), fails=False, version_called=False, help_called=False, **expected):
|
|
oc.help_called = oc.version_called = False
|
|
args = list(shlex_split(args))
|
|
ans = CLIOptions()
|
|
if fails:
|
|
if isinstance(fails, str):
|
|
with self.assertRaisesRegex(SystemExit, fails):
|
|
parse_cmdline(oc, disabled, ans, args=args)
|
|
else:
|
|
with self.assertRaises(SystemExit):
|
|
parse_cmdline(oc, disabled, ans, args=args)
|
|
else:
|
|
actual_leftover = parse_cmdline(oc, disabled, ans, args=args)
|
|
self.assertEqual(tuple(leftover), tuple(actual_leftover), f'{args}\n{ans}')
|
|
for dest, defval in oc.values_map.items():
|
|
val = expected.get(dest, defval)
|
|
self.assertEqual(val, getattr(ans, dest, BaseTest), f'Failed to parse {dest} correctly for: {args}\n{ans}')
|
|
self.assertEqual(version_called, oc.version_called, f'Failed to call version for: {args}\n{ans}')
|
|
self.assertEqual(help_called, oc.help_called, f'Failed to call help for: {args}\n{ans}')
|
|
|
|
t('-1', bool_set=True)
|
|
t('-01', bool_reset=False, bool_set=True)
|
|
t('-01=y', bool_reset=False, bool_set=True)
|
|
t('-01=n', bool_reset=False, bool_set=False)
|
|
t('--simple-string xx moo -1', leftover=['moo', '-1'], simple_string='xx')
|
|
t('--si -0 -- -1', leftover=['-1'], simple_string='-0')
|
|
t('--simple-string=-0 -- -1', leftover=['-1'], simple_string='-0')
|
|
t('--simple-string=--help -- -1', leftover=['-1'], simple_string='--help')
|
|
t('--simple-string --help -- -1', leftover=['-1'], simple_string='--help')
|
|
t('-1l=a --list=b -c b --list c', bool_set=True, choice='b', list=list('abc'))
|
|
t('-1s= -l "" --list= x', leftover=['x'], bool_set=True, simple_string='', list=['', ''])
|
|
t('--choice moo', fails=r'moo')
|
|
t('--bool', fails='mbiguous')
|
|
t('-1c moo', fails=r'moo')
|
|
t('-10c=moo', fails=r'moo')
|
|
t('-1 -h', fails=True, help_called=True)
|
|
t('-1 --help', fails=True, help_called=True)
|
|
t('-1 -0v', fails=True, version_called=True)
|
|
t('-1 -v0', fails=True, version_called=True)
|
|
t('-1 --version', fails=True, version_called=True)
|
|
t('-f=3.142 --int 17', float=3.142, int=17)
|
|
|
|
|
|
def font_size_clamping(self: 'BaseTest') -> None:
|
|
from kitty.options.utils import MAXIMUM_FONT_SIZE, MINIMUM_FONT_SIZE, clamp_font_size
|
|
|
|
# the floor applies whatever the configured size
|
|
self.ae(clamp_font_size(0, 11), MINIMUM_FONT_SIZE)
|
|
self.ae(clamp_font_size(-100, 11), MINIMUM_FONT_SIZE)
|
|
|
|
# sizes inside the range come back untouched
|
|
self.ae(clamp_font_size(11, 11), 11)
|
|
self.ae(clamp_font_size(64, 11), 64)
|
|
|
|
# the ceiling is the larger of the multiple and the absolute maximum, so a
|
|
# small configured size no longer implies a small maximum zoom
|
|
self.ae(clamp_font_size(1e6, 4), MAXIMUM_FONT_SIZE)
|
|
self.ae(clamp_font_size(1e6, 11), MAXIMUM_FONT_SIZE)
|
|
self.ae(clamp_font_size(200, 4), 200)
|
|
|
|
# a large configured size keeps its proportional ceiling
|
|
self.ae(clamp_font_size(1e6, 40), 400)
|
|
self.ae(clamp_font_size(1e6, 100), 1000)
|
|
|
|
# and the ceiling is never below the absolute maximum
|
|
for configured in (1, 4, 11, 25.6, 40, 100):
|
|
self.assertGreaterEqual(clamp_font_size(1e6, configured), MAXIMUM_FONT_SIZE)
|
|
|
|
|
|
def launcher(self):
|
|
import tempfile
|
|
|
|
from kitty.constants import is_macos
|
|
|
|
kexe = kitty_exe()
|
|
cfgdir = None
|
|
|
|
def get_report(cmdline: str, launch_services=False, config_dir: str = ''):
|
|
nonlocal cfgdir
|
|
args = list(shlex_split(cmdline))
|
|
env = dict(os.environ)
|
|
if launch_services:
|
|
env['KITTY_LAUNCHED_BY_LAUNCH_SERVICES'] = '1'
|
|
if config_dir:
|
|
env['KITTY_CONFIG_DIRECTORY'] = config_dir
|
|
cp = subprocess.run([kexe, '+testing-launcher-code'] + args, env=env, stdout=subprocess.PIPE)
|
|
self.assertEqual(cp.returncode, 0)
|
|
ans = {}
|
|
for line in cp.stdout.decode().split('\n'):
|
|
if not line:
|
|
continue
|
|
try:
|
|
key, val = line.split(':')
|
|
except ValueError:
|
|
raise AssertionError(f'Unexpected output from launcher: {line!r}\n{cp.stdout.decode()}')
|
|
if '\x1e' in val:
|
|
val = [x for x in val.split('\x1e') if x]
|
|
else:
|
|
val = val.strip()
|
|
ans[key] = val
|
|
if key == 'config_dir':
|
|
cfgdir = val
|
|
return ans, cp.stdout.decode().replace('\x1e', ' ')
|
|
|
|
def test(cmdline, assertions):
|
|
r, output = get_report(cmdline, launch_services=assertions.get('launched_by_launch_services', '0') != '0')
|
|
for key, expected in assertions.items():
|
|
self.assertEqual(expected, r.get(key), f'Failed for {key} with command line: {cmdline}\nOutput:\n{output}')
|
|
return output
|
|
|
|
def t(cmdline, **assertions):
|
|
assertions['is_quick_access_terminal'] = '0'
|
|
if cfgdir:
|
|
assertions['config_dir'] = cfgdir
|
|
assertions.setdefault('launched_by_launch_services', '0')
|
|
test(cmdline, assertions)
|
|
|
|
def si(cmdline, **assertions):
|
|
assertions['single_instance'] = '1'
|
|
test(cmdline, assertions)
|
|
|
|
def dt(cmdline, **assertions):
|
|
assertions['detach'] = 'true'
|
|
test(cmdline, assertions)
|
|
|
|
def k(cmdline):
|
|
assertions = {}
|
|
assertions['argv'] = ['kitten'] + cmdline.split()
|
|
for prefix in ('+kitten', '+ kitten'):
|
|
output = test(prefix + ' ' + cmdline, assertions)
|
|
self.assertIn('kitten_exe:', output)
|
|
|
|
def pn(cmdline, **assertions):
|
|
ig = assertions.get('instance_group')
|
|
assertions['instance_group'] = f'panel-{ig}' if ig else 'panel'
|
|
assertions['single_instance'] = '1'
|
|
assertions['session'] = ''
|
|
test(cmdline, assertions)
|
|
|
|
t('', original_argv=[kexe], argv=[])
|
|
t(
|
|
'--title=xxx --start-as maximized -c=a -c b cat',
|
|
title='xxx',
|
|
start_as='maximized',
|
|
config=['a', 'b'],
|
|
original_argv=[kexe, '--title=xxx', '--start-as', 'maximized', '-c=a', '-c', 'b', 'cat'],
|
|
argv=['cat'],
|
|
)
|
|
k('icat abc xyz')
|
|
t('+kitten unwrapped xyz', argv=['+kitten', 'unwrapped', 'xyz'])
|
|
t('+ kitten unwrapped xyz', original_argv=[kexe, '+', 'kitten', 'unwrapped', 'xyz'])
|
|
si('--single-instance --instance-group=g -T 3', argv=[kexe, '--single-instance', '--instance-group=g', '-T', '3'])
|
|
t('+open --help', argv=['+open', '--help'])
|
|
t('+open -1 --help', argv=['+open', '-1', '--help'])
|
|
si('+open -1 moose', argv=[kexe, '+open', '-1', 'moose'], open_urls=['moose'])
|
|
si('+open -1 --instance-group=g x y', instance_group='g', open_urls=['x', 'y'])
|
|
dt('--detach --session=moose --detached-log=xyz', detached_log='xyz', session='moose')
|
|
pn('+kitten panel -1 --edge=left', edge='left')
|
|
|
|
if is_macos:
|
|
with tempfile.TemporaryDirectory() as tdir:
|
|
with open(tdir + '/macos-launch-services-cmdline', 'w') as f:
|
|
f.write('kitty --title from-file\n')
|
|
# File args are used when launched by launch services
|
|
r, output = get_report('', launch_services=True, config_dir=tdir)
|
|
self.assertEqual(r.get('title'), 'from-file', f'Expected title=from-file in:\n{output}')
|
|
# User args passed via open --args are appended after file args (and override them)
|
|
r, output = get_report('--title from-args', launch_services=True, config_dir=tdir)
|
|
self.assertEqual(r.get('title'), 'from-args', f'Expected title=from-args to override from-file in:\n{output}')
|
|
|
|
|
|
def conf_parsing(self):
|
|
from kitty.config import defaults, load_config
|
|
from kitty.constants import is_macos
|
|
from kitty.fast_data_types import LEFT_EDGE, RIGHT_EDGE
|
|
from kitty.fonts import FontModification, ModificationType, ModificationUnit, ModificationValue
|
|
from kitty.options.utils import to_modifiers
|
|
|
|
bad_lines = []
|
|
|
|
def p(*lines, bad_line_num=0, num_err=None):
|
|
del bad_lines[:]
|
|
del self.error_messages[:]
|
|
ans = load_config(overrides=lines, accumulate_bad_lines=bad_lines)
|
|
if bad_line_num:
|
|
self.ae(len(bad_lines), bad_line_num)
|
|
else:
|
|
self.assertFalse(bad_lines)
|
|
if num_err is not None:
|
|
self.ae(len(self.error_messages), num_err, '\n'.join(self.error_messages))
|
|
return ans
|
|
|
|
def keys_for_func(opts, name):
|
|
for key, defns in opts.keyboard_modes[''].keymap.items():
|
|
for action in opts.alias_map.resolve_aliases(defns[0].definition):
|
|
if action.func == name:
|
|
yield key
|
|
|
|
opts = p('font_size 11.37', 'clear_all_shortcuts y', 'color23 red')
|
|
self.ae(opts.font_size, 11.37)
|
|
self.ae(defaults.gpu_driver, ('metal', 'vulkan', 'opengl', 'software'))
|
|
self.ae(p('gpu_driver vulkan, opengl opengl').gpu_driver, ('vulkan', 'opengl'))
|
|
self.ae(p('gpu_driver software opengl').gpu_driver, ('software', 'opengl'))
|
|
present = {name for name in ('metal', 'vulkan', 'opengl') if os.path.exists(gpu_driver_path(name))}
|
|
self.ae(
|
|
available_gpu_drivers(defaults.gpu_driver),
|
|
[(name, gpu_driver_path(name), False) for name in ('metal', 'vulkan', 'opengl') if name in present]
|
|
+ [(name, gpu_driver_path(name), True) for name in SOFTWARE_GPU_DRIVERS if name in present],
|
|
)
|
|
self.ae(p('gpu_driver opengl,vulkan').gpu_driver, ('opengl', 'vulkan'))
|
|
self.ae(p('gpu_driver directx opengl', bad_line_num=1).gpu_driver, defaults.gpu_driver)
|
|
radius_opts = p('window_border_radius 7px')
|
|
self.ae(radius_opts.window_border_radius, (7.0, 'px'))
|
|
self.ae(defaults.hyperlink_target_position, 'top')
|
|
for pos in ('top', 'bottom', 'below', 'tooltip'):
|
|
self.ae(p(f'hyperlink_target_position {pos}').hyperlink_target_position, pos)
|
|
self.ae(p('hyperlink_target_position xxx', bad_line_num=1).hyperlink_target_position, 'top')
|
|
radius_opts = p('window_border_radius -2')
|
|
self.ae(radius_opts.window_border_radius, (0.0, 'pt'))
|
|
self.ae(opts.mouse_hide_wait[0], 0 if is_macos else 3)
|
|
self.ae(opts.mouse_hide_wait[1], 0)
|
|
self.ae(opts.mouse_hide_wait[2], 40)
|
|
self.ae(opts.mouse_hide_wait[3], True)
|
|
self.ae(opts.color23, Color(255, 0, 0))
|
|
self.assertFalse(opts.keyboard_modes[''].keymap)
|
|
opts = p("url_excluded_characters '''")
|
|
self.ae(opts.url_excluded_characters, "'''")
|
|
opts = p("url_excluded_characters abc'")
|
|
self.ae(opts.url_excluded_characters, "abc'")
|
|
opts = p('tab_bar_edge left')
|
|
self.ae(opts.tab_bar_edge, LEFT_EDGE)
|
|
opts = p('tab_bar_edge right')
|
|
self.ae(opts.tab_bar_edge, RIGHT_EDGE)
|
|
opts = p('tab_bar_align start')
|
|
self.ae(opts.tab_bar_align, 'start')
|
|
opts = p('tab_bar_align end')
|
|
self.ae(opts.tab_bar_align, 'end')
|
|
opts = p('tab_bar_align left')
|
|
self.ae(opts.tab_bar_align, 'left')
|
|
opts = p('tab_bar_align right')
|
|
self.ae(opts.tab_bar_align, 'right')
|
|
opts = p('clear_all_shortcuts y', 'map f1 next_window')
|
|
self.ae(len(opts.keyboard_modes[''].keymap), 1)
|
|
opts = p('clear_all_mouse_actions y', 'mouse_map left click ungrabbed mouse_click_url_or_select')
|
|
self.ae(len(opts.mousemap), 1)
|
|
opts = p(
|
|
'clear_all_mouse_actions y',
|
|
'mouse_map ctrl+wheel_up press ungrabbed,grabbed change_font_size all +1',
|
|
'mouse_map shift+wheel_right press ungrabbed next_tab',
|
|
)
|
|
self.ae(
|
|
{k.human_repr() for k in opts.mousemap},
|
|
{'ctrl+wheel_up press ungrabbed', 'ctrl+wheel_up press grabbed', 'shift+wheel_right press ungrabbed'},
|
|
)
|
|
opts = p('strip_trailing_spaces always')
|
|
self.ae(opts.strip_trailing_spaces, 'always')
|
|
self.assertFalse(bad_lines)
|
|
opts = p('pointer_shape_when_grabbed XXX', bad_line_num=1)
|
|
self.ae(opts.pointer_shape_when_grabbed, defaults.pointer_shape_when_grabbed)
|
|
opts = p('modify_font underline_position -2', 'modify_font underline_thickness 150%', 'modify_font size Test -1px')
|
|
self.ae(
|
|
opts.modify_font,
|
|
{
|
|
'underline_position': FontModification(ModificationType.underline_position, ModificationValue(-2.0, ModificationUnit.pt)),
|
|
'underline_thickness': FontModification(ModificationType.underline_thickness, ModificationValue(150, ModificationUnit.percent)),
|
|
'size:Test': FontModification(ModificationType.size, ModificationValue(-1.0, ModificationUnit.pixel), 'Test'),
|
|
},
|
|
)
|
|
|
|
# test the aliasing options
|
|
opts = p('env A=1', 'env B=x$A', 'env C=', 'env D', 'clear_all_shortcuts y', 'kitten_alias a b --moo', 'map f1 kitten a arg')
|
|
self.ae(opts.env, {'A': '1', 'B': 'x1', 'C': '', 'D': DELETE_ENV_VAR})
|
|
|
|
def ac(which=0):
|
|
ka = tuple(opts.keyboard_modes[''].keymap.values())[0][0]
|
|
acs = opts.alias_map.resolve_aliases(ka.definition)
|
|
return acs[which]
|
|
|
|
ka = ac()
|
|
self.ae(ka.func, 'kitten')
|
|
self.ae(ka.args, ('b', '--moo', 'arg'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'kitten_alias hints hints --hi', 'map f1 kitten hints XXX')
|
|
ka = ac()
|
|
self.ae(ka.func, 'kitten')
|
|
self.ae(ka.args, ('hints', '--hi', 'XXX'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias la launch --moo', 'map f1 la XXX')
|
|
ka = ac()
|
|
self.ae(ka.func, 'launch')
|
|
self.ae(ka.args, ('--moo', 'XXX'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias one launch --moo', 'action_alias two one recursive', 'map f1 two XXX')
|
|
ka = ac()
|
|
self.ae(ka.func, 'launch')
|
|
self.ae(ka.args, ('--moo', 'recursive', 'XXX'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias launch two 1', 'action_alias two launch 2', 'map f1 launch 3')
|
|
ka = ac()
|
|
self.ae(ka.func, 'launch')
|
|
self.ae(ka.args, ('2', '1', '3'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias launch launch --moo', 'map f1 launch XXX')
|
|
ka = ac()
|
|
self.ae(ka.func, 'launch')
|
|
self.ae(ka.args, ('--moo', 'XXX'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias cfs change_font_size current', 'map f1 cfs +2')
|
|
ka = ac()
|
|
self.ae(ka.func, 'change_font_size')
|
|
self.ae(ka.args, (False, '+', 2.0))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias la launch --moo', 'map f1 combine : new_window : la ')
|
|
self.ae((ac().func, ac(1).func), ('new_window', 'launch'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias cc combine : new_window : launch --moo', 'map f1 cc XXX')
|
|
self.ae((ac().func, ac(1).func), ('new_window', 'launch'))
|
|
self.ae(ac(1).args, ('--moo', 'XXX'))
|
|
|
|
opts = p('clear_all_shortcuts y', 'action_alias ss kitten "space 1"', 'map f1 ss "space 2"')
|
|
self.ae(ac().args, ('space 1', 'space 2'))
|
|
|
|
am = build_action_aliases({'la': 'launch --moo'})
|
|
self.ae(am.resolve_aliases('la XXX')[0].args, ('--moo', 'XXX'))
|
|
am.update(build_action_aliases({'la': 'launch --baa'}))
|
|
self.ae(am.resolve_aliases('la XXX')[0].args, ('--baa', 'XXX'))
|
|
|
|
opts = p('kitty_mod alt')
|
|
self.ae(opts.kitty_mod, to_modifiers('alt'))
|
|
self.ae(next(keys_for_func(opts, 'next_layout')).mods, opts.kitty_mod)
|
|
|
|
opts = p('inactive_text_alpha 0.25')
|
|
self.ae(opts.inactive_text_alpha, 0.25)
|
|
opts = p('inactive_text_alpha -0.25')
|
|
self.ae(opts.inactive_text_alpha, -0.25)
|
|
opts = p('inactive_text_alpha 2')
|
|
self.ae(opts.inactive_text_alpha, 1.0)
|
|
opts = p('inactive_text_alpha -2')
|
|
self.ae(opts.inactive_text_alpha, -1.0)
|
|
|
|
# deprecation handling
|
|
opts = p('clear_all_shortcuts y', 'send_text all f1 hello')
|
|
self.ae(len(opts.keyboard_modes[''].keymap), 1)
|
|
opts = p('macos_hide_titlebar y' if is_macos else 'x11_hide_window_decorations y')
|
|
self.assertTrue(opts.hide_window_decorations)
|
|
self.ae(len(self.error_messages), 1)
|
|
|
|
# line breaks
|
|
opts = p(' font', ' \t \t \\_size', ' \\ 12', '\\.35', 'col', '\\o', '\t \t\\r', '\\25', ' \\ blue')
|
|
self.ae(opts.font_size, 12.35)
|
|
self.ae(opts.color25, Color(0, 0, 255))
|
|
|
|
# cursor_blink_interval
|
|
def cb(src, interval=-1, first=EasingFunction(), second=EasingFunction()):
|
|
opts = p('cursor_blink_interval ' + src)
|
|
self.ae((float(interval), first, second), (float(opts.cursor_blink_interval[0]), opts.cursor_blink_interval[1], opts.cursor_blink_interval[2]))
|
|
|
|
cb('3', 3)
|
|
cb('-2.3', -2.3)
|
|
cb('linear', first=EasingFunction('cubic-bezier', cubic_bezier_points=(0, 0.0, 1.0, 1.0)))
|
|
cb('linear 19', 19, EasingFunction('cubic-bezier', cubic_bezier_points=(0, 0.0, 1.0, 1.0)))
|
|
cb(
|
|
'ease-in-out cubic-bezier(0.1, 0.2, 0.3, 0.4) 11',
|
|
11,
|
|
EasingFunction('cubic-bezier', cubic_bezier_points=(0.42, 0, 0.58, 1)),
|
|
EasingFunction('cubic-bezier', cubic_bezier_points=(0.1, 0.2, 0.3, 0.4)),
|
|
)
|
|
cb('step-start', first=EasingFunction('steps', num_steps=1, jump_type='start'))
|
|
cb('steps(7, jump-none)', first=EasingFunction('steps', num_steps=7, jump_type='none'))
|
|
cb('linear(0, 0.25, 1)', first=EasingFunction('linear', linear_x=(0.0, 0.5, 1.0), linear_y=(0, 0.25, 1.0)))
|
|
cb('linear(0, 0.25 75%, 1)', first=EasingFunction('linear', linear_x=(0.0, 0.75, 1.0), linear_y=(0, 0.25, 1.0)))
|
|
cb('linear(0, 0.25 25% 75%, 1)', first=EasingFunction('linear', linear_x=(0.0, 0.25, 0.75, 1.0), linear_y=(0, 0.25, 0.25, 1.0)))
|
|
|
|
# test that easing functions give expected values
|
|
def ef(spec, tests, only_single=True, duration=0.5, accuracy=0):
|
|
cfv = p('cursor_blink_interval ' + spec).cursor_blink_interval
|
|
self.set_options({'cursor_blink_interval': cfv})
|
|
for t, expected in tests.items():
|
|
actual = test_cursor_blink_easing_function(t, only_single, duration)
|
|
if abs(actual - expected) > accuracy:
|
|
self.ae(expected, actual, f'Failed for {spec=} with {t=}: {expected} != {actual}')
|
|
|
|
ef('linear', {0: 1, 0.25: 0.5, 0.5: 0, 0.75: 0.5, 1: 1}, only_single=False)
|
|
|
|
ef('linear(0, 0.25 25% 75%, 1)', {0: 0, 0.25: 0.25, 0.3: 0.25, 0.75: 0.25, 1: 1})
|
|
linear_vals = {0: 0, 1: 1, 0.1234: 0.1234, 0.6453: 0.6453}
|
|
for spec in ('linear', 'linear(0, 1)', 'cubic-bezier(0, 0, 1, 1)', 'cubic-bezier(0.2, 0.2, 0.7, 0.7)'):
|
|
ef(spec, linear_vals)
|
|
# test an almost linear function to test cubic bezier implementation
|
|
ef('cubic-bezier(0.2, 0.2, 0.7, 0.71)', linear_vals, accuracy=0.01)
|
|
ef('cubic-bezier(0.23, 0.2, 0.7, 0.71)', linear_vals, accuracy=0.01)
|
|
|
|
ef('steps(5)', {0: 0, 0.1: 0, 0.3: 0.2, 0.9: 0.8})
|
|
ef('steps(5, start)', {0: 0.2, 0.1: 0.2, 0.3: 0.4, 0.9: 1})
|
|
ef('steps(4, jump-both)', {0: 0.2, 0.1: 0.2, 0.3: 0.4, 0.9: 1})
|
|
ef('steps(6, jump-none)', {0: 0, 0.1: 0.0, 0.3: 0.2, 0.9: 1})
|
|
|
|
# test various include modes
|
|
base = os.path.join(self.tdir, 'glob')
|
|
os.mkdir(base)
|
|
with open(os.path.join(base, 'fg'), 'w') as f:
|
|
print('foreground red', file=f)
|
|
opts = p(f'include {f.name}', num_err=0)
|
|
self.ae(opts.foreground, to_color('red'))
|
|
with open(os.path.join(self.tdir, 'bg'), 'w') as f:
|
|
print('background white', file=f)
|
|
print('globinclude glob/*', file=f)
|
|
print('envinclude ENVINCLUDE', file=f)
|
|
print('geninclude g.py', file=f)
|
|
print('geninclude g', file=f)
|
|
with open(os.path.join(self.tdir, 'g.py'), 'w') as g:
|
|
print('print("background_opacity .77")', file=g)
|
|
print('print("background_blur 77")', file=g)
|
|
with open(os.path.join(self.tdir, 'g'), 'w') as g:
|
|
print('#!/bin/sh', file=g)
|
|
print('echo background_image_linear y', file=g)
|
|
print('echo background_image_layout clamped', file=g)
|
|
os.chmod(g.fileno(), 0o700)
|
|
os.environ['ENVINCLUDE'] = 'cursor yellow'
|
|
opts = p(f'include {f.name}', num_err=0)
|
|
os.environ.pop('ENVINCLUDE')
|
|
self.ae(opts.foreground, to_color('red'))
|
|
self.ae(opts.background, to_color('white'))
|
|
self.ae(opts.cursor, to_color('yellow'))
|
|
self.ae(opts.background_opacity, 0.77)
|
|
self.ae(opts.background_blur, 77)
|
|
self.ae(opts.background_image_linear, True)
|
|
self.ae(opts.background_image_layout, 'clamped')
|
|
with open(os.path.join(self.tdir, 'a'), 'w') as a:
|
|
print('background red', file=a)
|
|
print('include b', file=a)
|
|
with open(os.path.join(self.tdir, 'b'), 'w') as a:
|
|
print('foreground red', file=a)
|
|
print('include a', file=a)
|
|
opts = p(f'include {a.name}', num_err=0, bad_line_num=1)
|
|
self.ae(opts.foreground, to_color('red'))
|
|
self.ae(opts.background, to_color('red'))
|
|
|
|
# remap_modifier. NOTE: parsing only. Whether the permutation is applied
|
|
# simultaneously rather than sequentially is a property of
|
|
# apply_modifier_remap() in C and is NOT observable from this dict - a
|
|
# sequential implementation would produce an identical one. That property is
|
|
# covered end to end by tests/test-remap-e2e.sh, which asserts that the
|
|
# encoded bytes actually exchange.
|
|
self.ae(p().remap_modifiers, {})
|
|
ctrl, hyper, sup = to_modifiers('ctrl'), to_modifiers('hyper'), to_modifiers('super')
|
|
self.ae(p('remap_modifiers ctrl:hyper').remap_modifiers, {ctrl: hyper})
|
|
# both directions of a swap are recorded
|
|
self.ae(p('remap_modifiers ctrl:hyper hyper:ctrl').remap_modifiers, {ctrl: hyper, hyper: ctrl})
|
|
# the last declaration for a given source wins, wherever it appears
|
|
self.ae(p('remap_modifiers ctrl:hyper', 'kitty_mod ctrl', 'remap_modifiers ctrl:super').remap_modifiers, {ctrl: sup})
|
|
# the destination may name more than one modifier
|
|
self.ae(p('remap_modifiers ctrl:ctrl+shift').remap_modifiers, {ctrl: to_modifiers('ctrl+shift')})
|
|
# every rejection must be REPORTED, never silently ignored: wrong arity, unknown
|
|
# or non-remappable modifier names, a source naming more than one modifier, and
|
|
# a mapping that does nothing
|
|
for bad in (
|
|
'remap_modifiers ctrl',
|
|
'remap_modifiers ctrl:hyper super',
|
|
'remap_modifiers ctrl:nosuchmod',
|
|
'remap_modifiers nosuchmod:ctrl',
|
|
'remap_modifiers ctrl+shift:hyper',
|
|
'remap_modifiers ctrl:none',
|
|
'remap_modifiers none:ctrl',
|
|
'remap_modifiers ctrl:kitty_mod',
|
|
'remap_modifiers kitty_mod:ctrl',
|
|
'remap_modifiers caps_lock:ctrl',
|
|
'remap_modifiers ctrl:num_lock',
|
|
'remap_modifiers ctrl:ctrl',
|
|
):
|
|
self.ae(p(bad, num_err=1).remap_modifiers, {}, f'not rejected: {bad}')
|