mirror of
https://github.com/vim/vim
synced 2025-07-15 16:51:57 +00:00
ea67ba718d
Problem: CI Tests favor GTK2 over GTK3
Solution: Install GTK3 dependencies and debug packages for CI workflows,
update ASAN suppression list, update required dependency
checks for the tests (Drew Vogel)
closes: #17253
Signed-off-by: Drew Vogel <dvogel@github>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2426 lines
69 KiB
VimL
2426 lines
69 KiB
VimL
" Tests for the terminal window.
|
|
" This is split in two, because it can take a lot of time.
|
|
" See test_terminal2.vim and test_terminal3.vim for further tests.
|
|
|
|
source check.vim
|
|
CheckFeature terminal
|
|
|
|
source shared.vim
|
|
source screendump.vim
|
|
source mouse.vim
|
|
source term_util.vim
|
|
|
|
let s:python = PythonProg()
|
|
let $PROMPT_COMMAND=''
|
|
|
|
func Test_terminal_basic()
|
|
call test_override('vterm_title', 1)
|
|
au TerminalOpen * let b:done = 'yes'
|
|
let buf = Run_shell_in_terminal({})
|
|
|
|
call assert_equal('t', mode())
|
|
call assert_equal('yes', b:done)
|
|
call assert_match('%aR[^\n]*running]', execute('ls'))
|
|
call assert_match('%aR[^\n]*running]', execute('ls R'))
|
|
call assert_notmatch('%[^\n]*running]', execute('ls F'))
|
|
call assert_notmatch('%[^\n]*running]', execute('ls ?'))
|
|
call assert_fails('set modifiable', 'E946:')
|
|
|
|
call StopShellInTerminal(buf)
|
|
call assert_equal('n', mode())
|
|
call assert_match('%aF[^\n]*finished]', execute('ls'))
|
|
call assert_match('%aF[^\n]*finished]', execute('ls F'))
|
|
call assert_notmatch('%[^\n]*finished]', execute('ls R'))
|
|
call assert_notmatch('%[^\n]*finished]', execute('ls ?'))
|
|
|
|
" closing window wipes out the terminal buffer a with finished job
|
|
close
|
|
call assert_equal("", bufname(buf))
|
|
|
|
au! TerminalOpen
|
|
call test_override('ALL', 0)
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_no_name()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_match('^!', bufname(buf))
|
|
0file
|
|
call assert_equal("", bufname(buf))
|
|
call assert_match('\[No Name\]', execute('file'))
|
|
call StopShellInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_TerminalWinOpen()
|
|
au TerminalWinOpen * let b:done = 'yes'
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_equal('yes', b:done)
|
|
call StopShellInTerminal(buf)
|
|
" closing window wipes out the terminal buffer with the finished job
|
|
close
|
|
|
|
if has("unix")
|
|
terminal ++hidden ++open echo
|
|
call WaitForAssert({-> assert_equal('terminal', &buftype)})
|
|
call assert_fails("echo b:done", 'E121:')
|
|
endif
|
|
|
|
au! TerminalWinOpen
|
|
endfunc
|
|
|
|
func Test_terminal_make_change()
|
|
let buf = Run_shell_in_terminal({})
|
|
call StopShellInTerminal(buf)
|
|
|
|
setlocal modifiable
|
|
exe "normal Axxx\<Esc>"
|
|
call assert_fails(buf . 'bwipe', 'E89:')
|
|
undo
|
|
|
|
exe buf . 'bwipe'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_paste_register()
|
|
let @" = "text to paste"
|
|
|
|
let buf = Run_shell_in_terminal({})
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
call feedkeys("echo \<C-W>\"\" \<C-W>\"=37 + 5\<CR>\<CR>", 'xt')
|
|
call WaitForAssert({-> assert_match("echo text to paste 42$", getline(1))})
|
|
call WaitForAssert({-> assert_equal('text to paste 42', 2->getline())})
|
|
|
|
exe buf . 'bwipe!'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_unload_buffer()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_fails(buf . 'bunload', 'E948:')
|
|
exe buf . 'bunload!'
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_wipe_buffer()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_fails(buf . 'bwipe', 'E948:')
|
|
exe buf . 'bwipe!'
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using ':confirm bwipe' on terminal works
|
|
func Test_terminal_confirm_wipe_buffer()
|
|
CheckUnix
|
|
CheckNotGui
|
|
CheckFeature dialog_con
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_fails(buf . 'bwipe', 'E948:')
|
|
call feedkeys('n', 'L')
|
|
call assert_fails('confirm ' .. buf .. 'bwipe', 'E517:')
|
|
call assert_equal(buf, bufnr())
|
|
call assert_equal(1, &modified)
|
|
call feedkeys('y', 'L')
|
|
exe 'confirm ' .. buf .. 'bwipe'
|
|
call assert_notequal(buf, bufnr())
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using :b! will hide the terminal
|
|
func Test_terminal_goto_buffer()
|
|
let buf_mod = bufnr()
|
|
let buf_term = Run_shell_in_terminal({})
|
|
call assert_equal(buf_term, bufnr())
|
|
call assert_fails(buf_mod . 'b', 'E948:')
|
|
exe buf_mod . 'b!'
|
|
call assert_equal(buf_mod, bufnr())
|
|
call assert_equal('run', job_status(g:job))
|
|
call assert_notequal('', bufname(buf_term))
|
|
exec buf_mod .. 'bwipe!'
|
|
exec buf_term .. 'bwipe!'
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using ':confirm :b' will kill terminal
|
|
func Test_terminal_confirm_goto_buffer()
|
|
CheckUnix
|
|
CheckNotGui
|
|
CheckFeature dialog_con
|
|
let buf_mod = bufnr()
|
|
let buf_term = Run_shell_in_terminal({})
|
|
call feedkeys('n', 'L')
|
|
exe 'confirm ' .. buf_mod .. 'b'
|
|
call assert_equal(buf_term, bufnr())
|
|
call feedkeys('y', 'L')
|
|
exec 'confirm ' .. buf_mod .. 'b'
|
|
call assert_equal(buf_mod, bufnr())
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf_term))
|
|
exec buf_mod .. 'bwipe!'
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using :close! will hide the terminal
|
|
func Test_terminal_close_win()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_equal(buf, bufnr())
|
|
call assert_fails('close', 'E948:')
|
|
close!
|
|
call assert_notequal(buf, bufnr())
|
|
call assert_equal('run', job_status(g:job))
|
|
call assert_notequal('', bufname(buf))
|
|
exec buf .. 'bwipe!'
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using ':confirm close' will kill terminal
|
|
func Test_terminal_confirm_close_win()
|
|
CheckUnix
|
|
CheckNotGui
|
|
CheckFeature dialog_con
|
|
let buf = Run_shell_in_terminal({})
|
|
call feedkeys('n', 'L')
|
|
confirm close
|
|
call assert_equal(buf, bufnr())
|
|
call feedkeys('y', 'L')
|
|
confirm close
|
|
call assert_notequal(buf, bufnr())
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using :quit! will kill the terminal
|
|
func Test_terminal_quit()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_equal(buf, bufnr())
|
|
call assert_fails('quit', 'E948:')
|
|
quit!
|
|
call assert_notequal(buf, bufnr())
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test that using ':confirm quit' will kill terminal
|
|
func Test_terminal_confirm_quit()
|
|
CheckUnix
|
|
CheckNotGui
|
|
CheckFeature dialog_con
|
|
let buf = Run_shell_in_terminal({})
|
|
call feedkeys('n', 'L')
|
|
confirm quit
|
|
call assert_equal(buf, bufnr())
|
|
call feedkeys('y', 'L')
|
|
confirm quit
|
|
call assert_notequal(buf, bufnr())
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Test :q or :next
|
|
|
|
func Test_terminal_split_quit()
|
|
let buf = Run_shell_in_terminal({})
|
|
split
|
|
quit!
|
|
call TermWait(buf)
|
|
sleep 50m
|
|
call assert_equal('run', job_status(g:job))
|
|
|
|
quit!
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
|
|
call assert_equal("", bufname(buf))
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_hide_buffer_job_running()
|
|
let buf = Run_shell_in_terminal({})
|
|
setlocal bufhidden=hide
|
|
quit
|
|
for nr in range(1, winnr('$'))
|
|
call assert_notequal(winbufnr(nr), buf)
|
|
endfor
|
|
call assert_true(bufloaded(buf))
|
|
call assert_true(buflisted(buf))
|
|
|
|
exe 'split ' . buf . 'buf'
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_hide_buffer_job_finished()
|
|
term echo hello
|
|
let buf = bufnr()
|
|
call WaitForAssert({-> assert_equal('finished', term_getstatus(buf))})
|
|
|
|
call assert_true(bufloaded(buf))
|
|
call assert_true(buflisted(buf))
|
|
|
|
" Test :hide
|
|
hide
|
|
call assert_true(bufloaded(buf))
|
|
call assert_true(buflisted(buf))
|
|
split
|
|
exe buf .. 'buf'
|
|
call assert_equal(buf, bufnr())
|
|
|
|
" Test bufhidden, which exercises a different code path
|
|
setlocal bufhidden=hide
|
|
edit Xasdfasdf
|
|
call assert_true(bufloaded(buf))
|
|
call assert_true(buflisted(buf))
|
|
exe buf .. 'buf'
|
|
call assert_equal(buf, bufnr())
|
|
setlocal bufhidden=
|
|
|
|
edit Xasdfasdf
|
|
call assert_false(bufloaded(buf))
|
|
call assert_false(buflisted(buf))
|
|
bwipe Xasdfasdf
|
|
endfunc
|
|
|
|
func Test_terminal_rename_buffer()
|
|
let cmd = Get_cat_123_cmd()
|
|
let buf = term_start(cmd, {'term_name': 'foo'})
|
|
call WaitForAssert({-> assert_equal('finished', term_getstatus(buf))})
|
|
call assert_equal('foo', bufname())
|
|
call assert_match('foo.*finished', execute('ls'))
|
|
file bar
|
|
call assert_equal('bar', bufname())
|
|
call assert_match('bar.*finished', execute('ls'))
|
|
exe 'bwipe! ' .. buf
|
|
call delete('Xtext')
|
|
endfunc
|
|
|
|
func s:Nasty_exit_cb(job, st)
|
|
exe g:buf . 'bwipe!'
|
|
let g:buf = 0
|
|
endfunc
|
|
|
|
func Get_cat_123_cmd()
|
|
if has('win32')
|
|
if !has('conpty')
|
|
return 'cmd /D /c "cls && color 2 && echo 123"'
|
|
else
|
|
" When clearing twice, extra sequence is not output.
|
|
return 'cmd /D /c "cls && cls && color 2 && echo 123"'
|
|
endif
|
|
else
|
|
call writefile(["\<Esc>[32m123"], 'Xtext')
|
|
return "cat Xtext"
|
|
endif
|
|
endfunc
|
|
|
|
func Test_terminal_nasty_cb()
|
|
let cmd = Get_cat_123_cmd()
|
|
let g:buf = term_start(cmd, {'exit_cb': function('s:Nasty_exit_cb')})
|
|
let g:job = term_getjob(g:buf)
|
|
|
|
call WaitForAssert({-> assert_equal("dead", job_status(g:job))})
|
|
call WaitForAssert({-> assert_equal(0, g:buf)})
|
|
unlet g:job
|
|
unlet g:buf
|
|
call delete('Xtext')
|
|
endfunc
|
|
|
|
func Check_123(buf)
|
|
let l = term_scrape(a:buf, 0)
|
|
call assert_true(len(l) == 0)
|
|
let l = term_scrape(a:buf, 999)
|
|
call assert_true(len(l) == 0)
|
|
let l = a:buf->term_scrape(1)
|
|
call assert_true(len(l) > 0)
|
|
call assert_equal('1', l[0].chars)
|
|
call assert_equal('2', l[1].chars)
|
|
call assert_equal('3', l[2].chars)
|
|
call assert_equal('#00e000', l[0].fg)
|
|
call assert_equal(0, term_getattr(l[0].attr, 'bold'))
|
|
call assert_equal(0, l[0].attr->term_getattr('italic'))
|
|
if has('win32')
|
|
" On Windows 'background' always defaults to dark, even though the terminal
|
|
" may use a light background. Therefore accept both white and black.
|
|
call assert_match('#ffffff\|#000000', l[0].bg)
|
|
else
|
|
if &background == 'light'
|
|
call assert_equal('#ffffff', l[0].bg)
|
|
else
|
|
call assert_equal('#000000', l[0].bg)
|
|
endif
|
|
endif
|
|
|
|
let l = term_getline(a:buf, -1)
|
|
call assert_equal('', l)
|
|
let l = term_getline(a:buf, 0)
|
|
call assert_equal('', l)
|
|
let l = term_getline(a:buf, 999)
|
|
call assert_equal('', l)
|
|
let l = term_getline(a:buf, 1)
|
|
call assert_equal('123', l)
|
|
endfunc
|
|
|
|
func Test_terminal_scrape_123()
|
|
let cmd = Get_cat_123_cmd()
|
|
let buf = term_start(cmd)
|
|
|
|
let termlist = term_list()
|
|
call assert_equal(1, len(termlist))
|
|
call assert_equal(buf, termlist[0])
|
|
|
|
" Nothing happens with invalid buffer number
|
|
call term_wait(1234)
|
|
|
|
call TermWait(buf)
|
|
" On MS-Windows we first get a startup message of two lines, wait for the
|
|
" "cls" to happen, after that we have one line with three characters.
|
|
call WaitForAssert({-> assert_equal(3, len(term_scrape(buf, 1)))})
|
|
call Check_123(buf)
|
|
|
|
" Must still work after the job ended.
|
|
let job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
call TermWait(buf)
|
|
call Check_123(buf)
|
|
|
|
exe buf . 'bwipe'
|
|
call delete('Xtext')
|
|
endfunc
|
|
|
|
func Test_terminal_scrape_multibyte()
|
|
call writefile(["léttまrs"], 'Xtext', 'D')
|
|
if has('win32')
|
|
" Run cmd with UTF-8 codepage to make the type command print the expected
|
|
" multibyte characters.
|
|
let buf = term_start("cmd /D /K chcp 65001")
|
|
call term_sendkeys(buf, "type Xtext\<CR>")
|
|
eval buf->term_sendkeys("exit\<CR>")
|
|
let line = 4
|
|
else
|
|
let buf = term_start("cat Xtext")
|
|
let line = 1
|
|
endif
|
|
|
|
call WaitFor({-> len(term_scrape(buf, line)) >= 7 && term_scrape(buf, line)[0].chars == "l"})
|
|
let l = term_scrape(buf, line)
|
|
call assert_true(len(l) >= 7)
|
|
call assert_equal('l', l[0].chars)
|
|
call assert_equal('é', l[1].chars)
|
|
call assert_equal(1, l[1].width)
|
|
call assert_equal('t', l[2].chars)
|
|
call assert_equal('t', l[3].chars)
|
|
call assert_equal('ま', l[4].chars)
|
|
call assert_equal(2, l[4].width)
|
|
call assert_equal('r', l[5].chars)
|
|
call assert_equal('s', l[6].chars)
|
|
|
|
let job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
call TermWait(buf)
|
|
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
func Test_terminal_one_column()
|
|
" This creates a terminal, displays a double-wide character and makes the
|
|
" window one column wide. This used to cause a crash.
|
|
let width = &columns
|
|
botright vert term
|
|
let buf = bufnr('$')
|
|
call TermWait(buf, 100)
|
|
exe "set columns=" .. (width / 2)
|
|
redraw
|
|
call term_sendkeys(buf, "キ")
|
|
call TermWait(buf, 10)
|
|
exe "set columns=" .. width
|
|
exe buf . 'bwipe!'
|
|
endfunc
|
|
|
|
func Test_terminal_scroll()
|
|
call writefile(range(1, 200), 'Xtext', 'D')
|
|
if has('win32')
|
|
let cmd = 'cmd /D /c "type Xtext"'
|
|
else
|
|
let cmd = "cat Xtext"
|
|
endif
|
|
let buf = term_start(cmd)
|
|
|
|
let job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
call TermWait(buf)
|
|
|
|
" wait until the scrolling stops
|
|
while 1
|
|
let scrolled = buf->term_getscrolled()
|
|
sleep 20m
|
|
if scrolled == buf->term_getscrolled()
|
|
break
|
|
endif
|
|
endwhile
|
|
|
|
call assert_equal('1', getline(1))
|
|
call assert_equal('1', term_getline(buf, 1 - scrolled))
|
|
call assert_equal('49', getline(49))
|
|
call assert_equal('49', term_getline(buf, 49 - scrolled))
|
|
call assert_equal('200', getline(200))
|
|
call assert_equal('200', term_getline(buf, 200 - scrolled))
|
|
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
func Test_terminal_scrollback()
|
|
let buf = Run_shell_in_terminal({'term_rows': 15})
|
|
set termwinscroll=100
|
|
call writefile(range(150), 'Xtext', 'D')
|
|
if has('win32')
|
|
call term_sendkeys(buf, "type Xtext\<CR>")
|
|
else
|
|
call term_sendkeys(buf, "cat Xtext\<CR>")
|
|
endif
|
|
let rows = term_getsize(buf)[0]
|
|
" On MS-Windows there is an empty line, check both last line and above it.
|
|
call WaitForAssert({-> assert_match( '149', term_getline(buf, rows - 1) . term_getline(buf, rows - 2))})
|
|
let lines = line('$')
|
|
call assert_inrange(91, 100, lines)
|
|
|
|
" When 'termwinscroll' becomes small, the scrollback should become small.
|
|
set termwinscroll=20
|
|
call term_sendkeys(buf, "echo set20\<CR>")
|
|
call WaitForAssert({-> assert_true([term_getline(buf, rows - 1), term_getline(buf, rows - 2)]->index('set20') >= 0)})
|
|
let lines = line('$')
|
|
call assert_inrange(19, 20, lines)
|
|
|
|
" When 'termwinscroll' under 10 which means 10% of it will be 0,
|
|
" the scrollback should become small.
|
|
set termwinscroll=1
|
|
call term_sendkeys(buf, "echo set1\<CR>")
|
|
call WaitForAssert({-> assert_true([term_getline(buf, rows - 1), term_getline(buf, rows - 2)]->index('set1') >= 0)})
|
|
let lines = line('$')
|
|
call assert_inrange(1, 2, lines)
|
|
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
set termwinscroll&
|
|
endfunc
|
|
|
|
func Test_terminal_postponed_scrollback()
|
|
CheckScreendump
|
|
" tail -f only works on Unix
|
|
CheckUnix
|
|
|
|
call writefile(range(50), 'Xtext', 'D')
|
|
call writefile([
|
|
\ 'set shell=/bin/sh noruler',
|
|
\ 'terminal',
|
|
\ 'sleep 200m',
|
|
\ 'call feedkeys("tail -n 100 -f Xtext\<CR>", "xt")',
|
|
\ 'sleep 100m',
|
|
\ 'call feedkeys("\<C-W>N", "xt")',
|
|
\ ], 'XTest_postponed', 'D')
|
|
let buf = RunVimInTerminal('-S XTest_postponed', {})
|
|
" Check that the Xtext lines are displayed and in Terminal-Normal mode
|
|
call VerifyScreenDump(buf, 'Test_terminal_scrollback_1', {})
|
|
|
|
silent !echo 'one more line' >>Xtext
|
|
" Screen will not change, move cursor to get a different dump
|
|
call term_sendkeys(buf, "k")
|
|
call VerifyScreenDump(buf, 'Test_terminal_scrollback_2', {})
|
|
|
|
" Back to Terminal-Job mode, text will scroll and show the extra line.
|
|
call term_sendkeys(buf, "a")
|
|
call VerifyScreenDump(buf, 'Test_terminal_scrollback_3', {})
|
|
|
|
" stop "tail -f"
|
|
call term_sendkeys(buf, "\<C-C>")
|
|
call TermWait(buf, 25)
|
|
" stop shell
|
|
call term_sendkeys(buf, "exit\<CR>")
|
|
call TermWait(buf, 50)
|
|
" close terminal window
|
|
let tsk_ret = term_sendkeys(buf, ":q\<CR>")
|
|
|
|
" check type of term_sendkeys() return value
|
|
echo type(tsk_ret)
|
|
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
" Run diff on two dumps with different size.
|
|
func Test_terminal_dumpdiff_size()
|
|
call assert_equal(1, winnr('$'))
|
|
call term_dumpdiff('dumps/Test_incsearch_search_01.dump', 'dumps/Test_popup_command_01.dump')
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_match('Test_incsearch_search_01.dump', getline(10))
|
|
call assert_match(' +++++$', getline(11))
|
|
call assert_match('Test_popup_command_01.dump', getline(31))
|
|
call assert_equal(repeat('+', 75), getline(30))
|
|
quit
|
|
endfunc
|
|
|
|
func Test_terminal_size()
|
|
let cmd = Get_cat_123_cmd()
|
|
|
|
exe 'terminal ++rows=5 ' . cmd
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal(5, size[0])
|
|
|
|
call term_start(cmd, {'term_rows': 6})
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal(6, size[0])
|
|
|
|
vsplit
|
|
exe 'terminal ++rows=5 ++cols=33 ' . cmd
|
|
call assert_equal([5, 33], ''->term_getsize())
|
|
|
|
call term_setsize('', 6, 0)
|
|
call assert_equal([6, 33], term_getsize(''))
|
|
|
|
eval ''->term_setsize(0, 35)
|
|
call assert_equal([6, 35], term_getsize(''))
|
|
|
|
call term_setsize('', 7, 30)
|
|
call assert_equal([7, 30], term_getsize(''))
|
|
|
|
bwipe!
|
|
call assert_fails("call term_setsize('', 7, 30)", "E955:")
|
|
|
|
call term_start(cmd, {'term_rows': 6, 'term_cols': 36})
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal([6, 36], size)
|
|
|
|
exe 'vertical terminal ++cols=20 ' . cmd
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal(20, size[1])
|
|
|
|
eval cmd->term_start({'vertical': 1, 'term_cols': 26})
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal(26, size[1])
|
|
|
|
split
|
|
exe 'vertical terminal ++rows=6 ++cols=20 ' . cmd
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal([6, 20], size)
|
|
|
|
call term_start(cmd, {'vertical': 1, 'term_rows': 7, 'term_cols': 27})
|
|
let size = term_getsize('')
|
|
bwipe!
|
|
call assert_equal([7, 27], size)
|
|
|
|
call assert_fails("call term_start(cmd, {'term_rows': -1})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_rows': 1001})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_rows': 10.0})", 'E805:')
|
|
|
|
call assert_fails("call term_start(cmd, {'term_cols': -1})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_cols': 1001})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_cols': 10.0})", 'E805:')
|
|
|
|
call delete('Xtext')
|
|
endfunc
|
|
|
|
func Test_terminal_zero_height()
|
|
split
|
|
wincmd j
|
|
anoremenu 1.1 WinBar.test :
|
|
terminal ++curwin
|
|
wincmd k
|
|
wincmd _
|
|
redraw
|
|
|
|
call term_sendkeys(bufnr(), "exit\r")
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_curwin()
|
|
let cmd = Get_cat_123_cmd()
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
split Xdummy
|
|
call setline(1, 'dummy')
|
|
write
|
|
call assert_equal(1, getbufinfo('Xdummy')[0].loaded)
|
|
exe 'terminal ++curwin ' . cmd
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(0, getbufinfo('Xdummy')[0].loaded)
|
|
bwipe!
|
|
|
|
split Xdummy
|
|
call term_start(cmd, {'curwin': 1})
|
|
call assert_equal(2, winnr('$'))
|
|
bwipe!
|
|
|
|
split Xdummy
|
|
call setline(1, 'change')
|
|
call assert_fails('terminal ++curwin ' . cmd, 'E37:')
|
|
call assert_equal(2, winnr('$'))
|
|
exe 'terminal! ++curwin ' . cmd
|
|
call assert_equal(2, winnr('$'))
|
|
bwipe!
|
|
|
|
split Xdummy
|
|
call setline(1, 'change')
|
|
call assert_fails("call term_start(cmd, {'curwin': 1})", 'E37:')
|
|
call assert_equal(2, winnr('$'))
|
|
bwipe!
|
|
|
|
split Xdummy
|
|
bwipe!
|
|
call delete('Xtext')
|
|
call delete('Xdummy')
|
|
endfunc
|
|
|
|
func s:get_sleep_cmd()
|
|
if s:python != ''
|
|
let cmd = s:python . " test_short_sleep.py"
|
|
" 500 was not enough for Travis
|
|
let waittime = 900
|
|
else
|
|
echo 'This will take five seconds...'
|
|
let waittime = 2000
|
|
if has('win32')
|
|
let cmd = $windir . '\system32\timeout.exe 1'
|
|
else
|
|
let cmd = 'sleep 1'
|
|
endif
|
|
endif
|
|
return [cmd, waittime]
|
|
endfunc
|
|
|
|
func Test_terminal_finish_open_close()
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
let [cmd, waittime] = s:get_sleep_cmd()
|
|
|
|
" shell terminal closes automatically
|
|
terminal
|
|
let buf = bufnr('%')
|
|
call assert_equal(2, winnr('$'))
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
call StopShellInTerminal(buf)
|
|
call WaitForAssert({-> assert_equal(1, winnr('$'))}, waittime)
|
|
|
|
" shell terminal that does not close automatically
|
|
terminal ++noclose
|
|
let buf = bufnr('%')
|
|
call assert_equal(2, winnr('$'))
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
call StopShellInTerminal(buf)
|
|
call assert_equal(2, winnr('$'))
|
|
quit
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
exe 'terminal ++close ' . cmd
|
|
call assert_equal(2, winnr('$'))
|
|
wincmd p
|
|
call WaitForAssert({-> assert_equal(1, winnr('$'))}, waittime)
|
|
|
|
call term_start(cmd, {'term_finish': 'close'})
|
|
call assert_equal(2, winnr('$'))
|
|
wincmd p
|
|
call WaitForAssert({-> assert_equal(1, winnr('$'))}, waittime)
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
exe 'terminal ++open ' . cmd
|
|
close!
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
bwipe
|
|
|
|
call term_start(cmd, {'term_finish': 'open'})
|
|
close!
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
bwipe
|
|
|
|
exe 'terminal ++hidden ++open ' . cmd
|
|
call assert_equal(1, winnr('$'))
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
bwipe
|
|
|
|
call term_start(cmd, {'term_finish': 'open', 'hidden': 1})
|
|
call assert_equal(1, winnr('$'))
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
bwipe
|
|
|
|
call assert_fails("call term_start(cmd, {'term_opencmd': 'open'})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_opencmd': 'split %x'})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_opencmd': 'split %d and %s'})", 'E475:')
|
|
call assert_fails("call term_start(cmd, {'term_opencmd': 'split % and %d'})", 'E475:')
|
|
|
|
call term_start(cmd, {'term_finish': 'open', 'term_opencmd': '4split | buffer %d | let g:result = "opened the buffer in a window"'})
|
|
close!
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
call assert_equal(4, winheight(0))
|
|
call assert_equal('opened the buffer in a window', g:result)
|
|
unlet g:result
|
|
bwipe
|
|
endfunc
|
|
|
|
func Test_terminal_cwd()
|
|
if has('win32')
|
|
let cmd = 'cmd /D /c cd'
|
|
else
|
|
CheckExecutable pwd
|
|
let cmd = 'pwd'
|
|
endif
|
|
call mkdir('Xtermdir')
|
|
let buf = term_start(cmd, {'cwd': 'Xtermdir'})
|
|
" if the path is very long it may be split over two lines, join them
|
|
" together
|
|
call WaitForAssert({-> assert_equal('Xtermdir', fnamemodify(getline(1) .. getline(2), ":t"))})
|
|
|
|
exe buf . 'bwipe'
|
|
call delete('Xtermdir', 'rf')
|
|
endfunc
|
|
|
|
func Test_terminal_cwd_failure()
|
|
" Case 1: Provided directory is not actually a directory. Attempt to make
|
|
" the file executable as well.
|
|
call writefile([], 'Xtcfile', 'D')
|
|
call setfperm('Xtcfile', 'rwx------')
|
|
call assert_fails("call term_start(&shell, {'cwd': 'Xtcfile'})", 'E475:')
|
|
|
|
" Case 2: Directory does not exist.
|
|
call assert_fails("call term_start(&shell, {'cwd': 'Xdir'})", 'E475:')
|
|
|
|
" Case 3: Directory exists but is not accessible.
|
|
" Skip this for root, it will be accessible anyway.
|
|
if !IsRoot()
|
|
call mkdir('XdirNoAccess', '', '0600')
|
|
" return early if the directory permissions could not be set properly
|
|
if getfperm('XdirNoAccess')[2] == 'x'
|
|
call delete('XdirNoAccess', 'rf')
|
|
return
|
|
endif
|
|
call assert_fails("call term_start(&shell, {'cwd': 'XdirNoAccess'})", 'E475:')
|
|
call delete('XdirNoAccess', 'rf')
|
|
endif
|
|
endfunc
|
|
|
|
func Test_terminal_servername()
|
|
CheckFeature clientserver
|
|
call s:test_environment("VIM_SERVERNAME", v:servername)
|
|
endfunc
|
|
|
|
func Test_terminal_version()
|
|
call s:test_environment("VIM_TERMINAL", string(v:version))
|
|
endfunc
|
|
|
|
func s:test_environment(name, value)
|
|
let buf = Run_shell_in_terminal({})
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
if has('win32')
|
|
call term_sendkeys(buf, "echo %" . a:name . "%\r")
|
|
else
|
|
call term_sendkeys(buf, "echo $" . a:name . "\r")
|
|
endif
|
|
call TermWait(buf)
|
|
call StopShellInTerminal(buf)
|
|
call WaitForAssert({-> assert_equal(a:value, getline(2))})
|
|
|
|
exe buf . 'bwipe'
|
|
unlet buf
|
|
endfunc
|
|
|
|
func Test_terminal_env()
|
|
let buf = Run_shell_in_terminal({'env': {'TESTENV': 'correct'}})
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
if has('win32')
|
|
call term_sendkeys(buf, "echo %TESTENV%\r")
|
|
else
|
|
call term_sendkeys(buf, "echo $TESTENV\r")
|
|
endif
|
|
eval buf->TermWait()
|
|
call StopShellInTerminal(buf)
|
|
call WaitForAssert({-> assert_equal('correct', getline(2))})
|
|
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
func Test_terminal_list_args()
|
|
let buf = term_start([&shell, &shellcmdflag, 'echo "123"'])
|
|
call assert_fails(buf . 'bwipe', 'E948:')
|
|
exe buf . 'bwipe!'
|
|
call assert_equal("", bufname(buf))
|
|
endfunction
|
|
|
|
func Test_terminal_noblock()
|
|
let g:test_is_flaky = 1
|
|
let buf = term_start(&shell)
|
|
" Starting a terminal can be slow, esp. on busy CI machines.
|
|
let wait_time = 7500
|
|
let letters = 'abcdefghijklmnopqrstuvwxyz'
|
|
if has('bsd') || has('mac') || has('sun')
|
|
" The shell or something else has a problem dealing with more than 1000
|
|
" characters at the same time. It's very slow too.
|
|
let len = 1000
|
|
let wait_time = 15000
|
|
let letters = 'abcdefghijklm'
|
|
" NPFS is used in Windows, nonblocking mode does not work properly.
|
|
elseif has('win32')
|
|
let len = 1
|
|
else
|
|
let len = 5000
|
|
endif
|
|
|
|
" Send a lot of text lines, should be buffered properly.
|
|
for c in split(letters, '\zs')
|
|
call term_sendkeys(buf, 'echo ' . repeat(c, len) . "\<cr>")
|
|
endfor
|
|
call term_sendkeys(buf, "echo done\<cr>")
|
|
|
|
" On MS-Windows there is an extra empty line below "done". Find "done" in
|
|
" the last-but-one or the last-but-two line.
|
|
let lnum = term_getsize(buf)[0] - 1
|
|
call WaitForAssert({-> assert_match('done', term_getline(buf, lnum - 1) .. '//' .. term_getline(buf, lnum))}, wait_time)
|
|
let line = term_getline(buf, lnum)
|
|
if line !~ 'done'
|
|
let line = term_getline(buf, lnum - 1)
|
|
endif
|
|
call assert_match('done', line)
|
|
|
|
let g:job = term_getjob(buf)
|
|
call StopShellInTerminal(buf)
|
|
unlet g:job
|
|
bwipe
|
|
endfunc
|
|
|
|
func Test_terminal_write_stdin()
|
|
" TODO: enable once writing to stdin works on MS-Windows
|
|
CheckNotMSWindows
|
|
CheckExecutable wc
|
|
let g:test_is_flaky = 1
|
|
|
|
call setline(1, ['one', 'two', 'three'])
|
|
%term wc
|
|
call WaitForAssert({-> assert_match('3', getline("$"))})
|
|
let nrs = split(getline('$'))
|
|
call assert_equal(['3', '3', '14'], nrs)
|
|
%bwipe!
|
|
|
|
call setline(1, ['one', 'two', 'three', 'four'])
|
|
2,3term wc
|
|
call WaitForAssert({-> assert_match('2', getline("$"))})
|
|
let nrs = split(getline('$'))
|
|
call assert_equal(['2', '2', '10'], nrs)
|
|
%bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_eof_arg()
|
|
call CheckPython(s:python)
|
|
let g:test_is_flaky = 1
|
|
|
|
call setline(1, ['print("hello")'])
|
|
exe '1term ++eof=exit(123) ' .. s:python
|
|
" MS-Windows echoes the input, Unix doesn't.
|
|
if has('win32')
|
|
call WaitFor({-> getline('$') =~ 'exit(123)'})
|
|
call assert_equal('hello', getline(line('$') - 1))
|
|
else
|
|
call WaitFor({-> getline('$') =~ 'hello'})
|
|
call assert_equal('hello', getline('$'))
|
|
endif
|
|
let exitval = bufnr()->term_getjob()->job_info().exitval
|
|
if !has('win32')
|
|
call assert_equal(123, exitval)
|
|
else
|
|
" python 3.13 on Windows returns exit code 1
|
|
" older versions returned correctly exit code 123
|
|
" https://github.com/python/cpython/issues/129900
|
|
call assert_match('1\|123', exitval)
|
|
endif
|
|
%bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_eof_arg_win32_ctrl_z()
|
|
CheckMSWindows
|
|
call CheckPython(s:python)
|
|
let g:test_is_flaky = 1
|
|
|
|
call setline(1, ['print("hello")'])
|
|
exe '1term ++eof=<C-Z> ' .. s:python
|
|
call WaitForAssert({-> assert_match('\^Z', getline(line('$') - 1) .. getline(line('$')))})
|
|
" until python 3.12 there was an extra line break, with 3.13 it was removed,
|
|
" so depending on the python version the ^Z is on the last or second-last line
|
|
call assert_match('\^Z', getline(line('$') - 1) .. getline(line('$')))
|
|
%bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_duplicate_eof_arg()
|
|
call CheckPython(s:python)
|
|
let g:test_is_flaky = 1
|
|
|
|
" Check the last specified ++eof arg is used and does not leak memory.
|
|
new
|
|
call setline(1, ['print("hello")'])
|
|
exe '1term ++eof=<C-Z> ++eof=exit(123) ' .. s:python
|
|
" MS-Windows echoes the input, Unix doesn't.
|
|
if has('win32')
|
|
call WaitFor({-> getline('$') =~ 'exit(123)'})
|
|
call assert_equal('hello', getline(line('$') - 1))
|
|
else
|
|
call WaitFor({-> getline('$') =~ 'hello'})
|
|
call assert_equal('hello', getline('$'))
|
|
endif
|
|
let exitval = bufnr()->term_getjob()->job_info().exitval
|
|
if !has('win32')
|
|
call assert_equal(123, exitval)
|
|
else
|
|
" python 3.13 on Windows returns exit code 1
|
|
" older versions returned correctly exit code 123
|
|
" https://github.com/python/cpython/issues/129900
|
|
call assert_match('1\|123', exitval)
|
|
endif
|
|
%bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_no_cmd()
|
|
let g:test_is_flaky = 1
|
|
let buf = term_start('NONE', {})
|
|
call assert_notequal(0, buf)
|
|
|
|
let pty = job_info(term_getjob(buf))['tty_out']
|
|
call assert_notequal('', pty)
|
|
if has('gui_running') && !has('win32')
|
|
" In the GUI job_start() doesn't work, it does not read from the pty.
|
|
call system('echo "look here" > ' . pty)
|
|
else
|
|
" Otherwise using a job works on all systems.
|
|
call job_start([&shell, &shellcmdflag, 'echo "look here" > ' . pty])
|
|
endif
|
|
call WaitForAssert({-> assert_match('look here', term_getline(buf, 1))})
|
|
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_special_chars()
|
|
" this file name only works on Unix
|
|
CheckUnix
|
|
|
|
call mkdir('Xdir with spaces', 'R')
|
|
call writefile(['x'], 'Xdir with spaces/quoted"file')
|
|
term ls Xdir\ with\ spaces/quoted\"file
|
|
call WaitForAssert({-> assert_match('quoted"file', term_getline('', 1))})
|
|
" make sure the job has finished
|
|
call WaitForAssert({-> assert_match('finish', term_getstatus(bufnr()))})
|
|
|
|
bwipe
|
|
endfunc
|
|
|
|
func Test_terminal_wrong_options()
|
|
call assert_fails('call term_start(&shell, {
|
|
\ "in_io": "file",
|
|
\ "in_name": "xxx",
|
|
\ "out_io": "file",
|
|
\ "out_name": "xxx",
|
|
\ "err_io": "file",
|
|
\ "err_name": "xxx"
|
|
\ })', 'E474:')
|
|
call assert_fails('call term_start(&shell, {
|
|
\ "out_buf": bufnr("%")
|
|
\ })', 'E474:')
|
|
call assert_fails('call term_start(&shell, {
|
|
\ "err_buf": bufnr("%")
|
|
\ })', 'E474:')
|
|
endfunc
|
|
|
|
func Test_terminal_redir_file()
|
|
let g:test_is_flaky = 1
|
|
let cmd = Get_cat_123_cmd()
|
|
let buf = term_start(cmd, {'out_io': 'file', 'out_name': 'Xtrfile'})
|
|
call TermWait(buf)
|
|
" ConPTY may precede escape sequence. There are things that are not so.
|
|
if !has('conpty')
|
|
call WaitForAssert({-> assert_notequal(0, len(readfile("Xtrfile")))})
|
|
call assert_match('123', readfile('Xtrfile')[0])
|
|
endif
|
|
let g:job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("dead", job_status(g:job))})
|
|
|
|
if has('win32')
|
|
" On Windows we cannot delete a file being used by a process. When
|
|
" job_status() returns "dead", the process remains for a short time.
|
|
" Just wait for a moment.
|
|
sleep 50m
|
|
endif
|
|
call delete('Xtrfile')
|
|
bwipe
|
|
|
|
if has('unix')
|
|
call writefile(['one line'], 'Xtrfile', 'D')
|
|
let buf = term_start('cat', {'in_io': 'file', 'in_name': 'Xtrfile'})
|
|
call TermWait(buf)
|
|
call WaitForAssert({-> assert_equal('one line', term_getline(buf, 1))})
|
|
let g:job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
bwipe
|
|
endif
|
|
|
|
call delete('Xtext')
|
|
endfunc
|
|
|
|
func TerminalTmap(remap)
|
|
let buf = Run_shell_in_terminal({})
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
call assert_equal('t', mode())
|
|
|
|
if a:remap
|
|
tmap 123 456
|
|
else
|
|
tnoremap 123 456
|
|
endif
|
|
" don't use abcde, it's an existing command
|
|
tmap 456 abxde
|
|
call assert_equal('456', maparg('123', 't'))
|
|
call assert_equal('abxde', maparg('456', 't'))
|
|
call feedkeys("123", 'tx')
|
|
call WaitForAssert({-> assert_match('abxde\|456', term_getline(buf, term_getcursor(buf)[0]))})
|
|
let lnum = term_getcursor(buf)[0]
|
|
if a:remap
|
|
call assert_match('abxde', term_getline(buf, lnum))
|
|
else
|
|
call assert_match('456', term_getline(buf, lnum))
|
|
endif
|
|
|
|
call term_sendkeys(buf, "\r")
|
|
call StopShellInTerminal(buf)
|
|
|
|
tunmap 123
|
|
tunmap 456
|
|
call assert_equal('', maparg('123', 't'))
|
|
exe buf . 'bwipe'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_tmap()
|
|
call TerminalTmap(1)
|
|
call TerminalTmap(0)
|
|
endfunc
|
|
|
|
func Test_terminal_wall()
|
|
let buf = Run_shell_in_terminal({})
|
|
wall
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_wqall()
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_fails('wqall', 'E948:')
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_terminal_composing_unicode()
|
|
let g:test_is_flaky = 1
|
|
let save_enc = &encoding
|
|
set encoding=utf-8
|
|
|
|
if has('win32')
|
|
let cmd = "cmd /D /K chcp 65001"
|
|
let lnum = [3, 6, 9]
|
|
else
|
|
let cmd = &shell
|
|
let lnum = [1, 3, 5]
|
|
endif
|
|
|
|
enew
|
|
let buf = term_start(cmd, {'curwin': 1})
|
|
let g:job = term_getjob(buf)
|
|
call WaitFor({-> term_getline(buf, 1) !=# ''}, 1000)
|
|
|
|
if has('win32')
|
|
call assert_equal('cmd', job_info(g:job).cmd[0])
|
|
else
|
|
call assert_equal(&shell, job_info(g:job).cmd[0])
|
|
endif
|
|
|
|
" ascii + composing
|
|
let txt = "a\u0308bc"
|
|
call term_sendkeys(buf, "echo " . txt)
|
|
call TermWait(buf, 25)
|
|
call assert_match("echo " . txt, term_getline(buf, lnum[0]))
|
|
call term_sendkeys(buf, "\<cr>")
|
|
call WaitForAssert({-> assert_equal(txt, term_getline(buf, lnum[0] + 1))}, 1000)
|
|
let l = term_scrape(buf, lnum[0] + 1)
|
|
call assert_equal("a\u0308", l[0].chars)
|
|
call assert_equal("b", l[1].chars)
|
|
call assert_equal("c", l[2].chars)
|
|
|
|
" multibyte + composing: がぎぐげご
|
|
let txt = "\u304b\u3099\u304e\u304f\u3099\u3052\u3053\u3099"
|
|
call term_sendkeys(buf, "echo " . txt)
|
|
call TermWait(buf, 25)
|
|
call assert_match("echo " . txt, term_getline(buf, lnum[1]))
|
|
call term_sendkeys(buf, "\<cr>")
|
|
call WaitForAssert({-> assert_equal(txt, term_getline(buf, lnum[1] + 1))}, 1000)
|
|
let l = term_scrape(buf, lnum[1] + 1)
|
|
call assert_equal("\u304b\u3099", l[0].chars)
|
|
call assert_equal(2, l[0].width)
|
|
call assert_equal("\u304e", l[1].chars)
|
|
call assert_equal(2, l[1].width)
|
|
call assert_equal("\u304f\u3099", l[2].chars)
|
|
call assert_equal(2, l[2].width)
|
|
call assert_equal("\u3052", l[3].chars)
|
|
call assert_equal(2, l[3].width)
|
|
call assert_equal("\u3053\u3099", l[4].chars)
|
|
call assert_equal(2, l[4].width)
|
|
|
|
" \u00a0 + composing
|
|
let txt = "abc\u00a0\u0308"
|
|
call term_sendkeys(buf, "echo " . txt)
|
|
call TermWait(buf, 25)
|
|
call assert_match("echo " . txt, term_getline(buf, lnum[2]))
|
|
call term_sendkeys(buf, "\<cr>")
|
|
call WaitForAssert({-> assert_equal(txt, term_getline(buf, lnum[2] + 1))}, 1000)
|
|
let l = term_scrape(buf, lnum[2] + 1)
|
|
call assert_equal("\u00a0\u0308", l[3].chars)
|
|
|
|
call term_sendkeys(buf, "exit\r")
|
|
call WaitForAssert({-> assert_equal('dead', job_status(g:job))})
|
|
bwipe!
|
|
unlet g:job
|
|
let &encoding = save_enc
|
|
endfunc
|
|
|
|
func Test_terminal_aucmd_on_close()
|
|
fun Nop()
|
|
let s:called = 1
|
|
endfun
|
|
|
|
aug repro
|
|
au!
|
|
au BufWinLeave * call Nop()
|
|
aug END
|
|
|
|
let [cmd, waittime] = s:get_sleep_cmd()
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
new
|
|
call setline(1, ['one', 'two'])
|
|
exe 'term ++close ' . cmd
|
|
wincmd p
|
|
call WaitForAssert({-> assert_equal(2, winnr('$'))}, waittime)
|
|
call assert_equal(1, s:called)
|
|
bwipe!
|
|
|
|
unlet s:called
|
|
au! repro
|
|
delfunc Nop
|
|
endfunc
|
|
|
|
func Test_terminal_term_start_empty_command()
|
|
let cmd = "call term_start('', {'curwin' : 1, 'term_finish' : 'close'})"
|
|
call assert_fails(cmd, 'E474:')
|
|
let cmd = "call term_start('', {'curwin' : 1, 'term_finish' : 'close'})"
|
|
call assert_fails(cmd, 'E474:')
|
|
let cmd = "call term_start({}, {'curwin' : 1, 'term_finish' : 'close'})"
|
|
call assert_fails(cmd, 'E474:')
|
|
let cmd = "call term_start(0, {'curwin' : 1, 'term_finish' : 'close'})"
|
|
call assert_fails(cmd, 'E474:')
|
|
let cmd = "call term_start('', {'term_name' : []})"
|
|
call assert_fails(cmd, 'E730:')
|
|
let cmd = "call term_start('', {'term_finish' : 'axby'})"
|
|
call assert_fails(cmd, 'E475:')
|
|
let cmd = "call term_start('', {'eof_chars' : []})"
|
|
call assert_fails(cmd, 'E730:')
|
|
let cmd = "call term_start('', {'term_kill' : []})"
|
|
call assert_fails(cmd, 'E730:')
|
|
let cmd = "call term_start('', {'tty_type' : []})"
|
|
call assert_fails(cmd, 'E730:')
|
|
let cmd = "call term_start('', {'tty_type' : 'abc'})"
|
|
call assert_fails(cmd, 'E475:')
|
|
let cmd = "call term_start('', {'term_highlight' : []})"
|
|
call assert_fails(cmd, 'E730:')
|
|
if has('gui') || has('termguicolors')
|
|
let cmd = "call term_start('', {'ansi_colors' : 'abc'})"
|
|
call assert_fails(cmd, 'E475:')
|
|
let cmd = "call term_start('', {'ansi_colors' : [[]]})"
|
|
call assert_fails(cmd, 'E730:')
|
|
let cmd = "call term_start('', {'ansi_colors' : repeat(['blue'], 18)})"
|
|
if has('gui_running') || has('termguicolors')
|
|
call assert_fails(cmd, 'E475:')
|
|
else
|
|
call assert_fails(cmd, 'E254:')
|
|
endif
|
|
endif
|
|
endfunc
|
|
|
|
func Test_terminal_response_to_control_sequence()
|
|
CheckUnix
|
|
|
|
let buf = Run_shell_in_terminal({})
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
call term_sendkeys(buf, "cat\<CR>")
|
|
call WaitForAssert({-> assert_match('cat', term_getline(buf, 1))})
|
|
|
|
" Request the cursor position.
|
|
call term_sendkeys(buf, "\x1b[6n\<CR>")
|
|
|
|
" Wait for output from tty to display, below an empty line.
|
|
call WaitForAssert({-> assert_match('3;1R', term_getline(buf, 4))})
|
|
|
|
" End "cat" gently.
|
|
call term_sendkeys(buf, "\<CR>\<C-D>")
|
|
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
unlet g:job
|
|
endfunc
|
|
|
|
" Run this first, it fails when run after other tests.
|
|
func Test_aa_terminal_focus_events()
|
|
CheckScreendump
|
|
CheckNotGui
|
|
CheckUnix
|
|
CheckRunVimInTerminal
|
|
|
|
let save_term = &term
|
|
let save_ttymouse = &ttymouse
|
|
set term=xterm ttymouse=xterm2
|
|
|
|
let lines =<< trim END
|
|
set term=xterm ttymouse=xterm2
|
|
au FocusLost * call setline(1, 'I am lost') | set nomod
|
|
au FocusGained * call setline(1, 'I am back') | set nomod
|
|
END
|
|
call writefile(lines, 'XtermFocus', 'D')
|
|
let buf = RunVimInTerminal('-S XtermFocus', #{rows: 6})
|
|
|
|
" Send a focus event to ourselves, it should be forwarded to the terminal
|
|
call feedkeys("\<Esc>[O", "Lx!")
|
|
call VerifyScreenDump(buf, 'Test_terminal_focus_1', {})
|
|
|
|
call feedkeys("\<Esc>[I", "Lx!")
|
|
call VerifyScreenDump(buf, 'Test_terminal_focus_2', {})
|
|
|
|
" check that a command line being edited is redrawn in place
|
|
call term_sendkeys(buf, ":" .. repeat('x', 80))
|
|
call TermWait(buf)
|
|
call feedkeys("\<Esc>[O", "Lx!")
|
|
call VerifyScreenDump(buf, 'Test_terminal_focus_3', {})
|
|
call term_sendkeys(buf, "\<Esc>")
|
|
|
|
call StopVimInTerminal(buf)
|
|
let &term = save_term
|
|
let &ttymouse = save_ttymouse
|
|
endfunc
|
|
|
|
" Run Vim, start a terminal in that Vim with the kill argument,
|
|
" :qall works.
|
|
func Run_terminal_qall_kill(line1, line2)
|
|
" 1. Open a terminal window and wait for the prompt to appear
|
|
" 2. set kill using term_setkill()
|
|
" 3. make Vim exit, it will kill the shell
|
|
let after = [
|
|
\ a:line1,
|
|
\ 'let buf = bufnr("%")',
|
|
\ 'while term_getline(buf, 1) =~ "^\\s*$"',
|
|
\ ' sleep 10m',
|
|
\ 'endwhile',
|
|
\ a:line2,
|
|
\ 'au VimLeavePre * call writefile(["done"], "Xdone")',
|
|
\ 'qall',
|
|
\ ]
|
|
if !RunVim([], after, '')
|
|
return
|
|
endif
|
|
call assert_equal("done", readfile("Xdone")[0])
|
|
call delete("Xdone")
|
|
endfunc
|
|
|
|
" Run Vim in a terminal, then start a terminal in that Vim with a kill
|
|
" argument, check that :qall works.
|
|
func Test_terminal_qall_kill_arg()
|
|
call Run_terminal_qall_kill('term ++kill=kill', '')
|
|
endfunc
|
|
|
|
" Run Vim, start a terminal in that Vim, set the kill argument with
|
|
" term_setkill(), check that :qall works.
|
|
func Test_terminal_qall_kill_func()
|
|
call Run_terminal_qall_kill('term', 'eval buf->term_setkill("kill")')
|
|
endfunc
|
|
|
|
" Run Vim, start a terminal in that Vim without the kill argument,
|
|
" check that :qall does not exit, :qall! does.
|
|
func Test_terminal_qall_exit()
|
|
let after =<< trim [CODE]
|
|
term
|
|
let buf = bufnr("%")
|
|
while term_getline(buf, 1) =~ "^\\s*$"
|
|
sleep 10m
|
|
endwhile
|
|
set nomore
|
|
au VimLeavePre * call writefile(["too early"], "Xdone")
|
|
qall
|
|
au! VimLeavePre * exe buf . "bwipe!" | call writefile(["done"], "Xdone")
|
|
cquit
|
|
[CODE]
|
|
|
|
if !RunVim([], after, '')
|
|
return
|
|
endif
|
|
call assert_equal("done", readfile("Xdone")[0])
|
|
call delete("Xdone")
|
|
endfunc
|
|
|
|
" Run Vim in a terminal, then start a terminal in that Vim without a kill
|
|
" argument, check that :confirm qall works.
|
|
func Test_terminal_qall_prompt()
|
|
CheckRunVimInTerminal
|
|
|
|
let buf = RunVimInTerminal('', {})
|
|
|
|
" the shell may set the window title, we don't want that here
|
|
call term_sendkeys(buf, ":call test_override('vterm_title', 1)\<CR>")
|
|
|
|
" Open a terminal window and wait for the prompt to appear
|
|
call term_sendkeys(buf, ":term\<CR>")
|
|
call WaitForAssert({-> assert_match('\[running]', term_getline(buf, 10))})
|
|
call WaitForAssert({-> assert_notmatch('^\s*$', term_getline(buf, 1))})
|
|
|
|
" make Vim exit, it will prompt to kill the shell
|
|
call term_sendkeys(buf, "\<C-W>:confirm qall\<CR>")
|
|
call WaitForAssert({-> assert_match('\[Y\]es, (N)o:', term_getline(buf, 20))})
|
|
call term_sendkeys(buf, "y")
|
|
call WaitForAssert({-> assert_equal('finished', term_getstatus(buf))})
|
|
|
|
" close the terminal window where Vim was running
|
|
quit
|
|
endfunc
|
|
|
|
" Run Vim in a terminal, then start a terminal window with a shell and check
|
|
" that Vim exits if it is closed.
|
|
func Test_terminal_exit()
|
|
CheckRunVimInTerminal
|
|
|
|
let lines =<< trim END
|
|
let winid = win_getid()
|
|
help
|
|
term
|
|
let termid = win_getid()
|
|
call win_gotoid(winid)
|
|
close
|
|
call win_gotoid(termid)
|
|
END
|
|
call writefile(lines, 'XtermExit', 'D')
|
|
let buf = RunVimInTerminal('-S XtermExit', #{rows: 10})
|
|
let job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("run", job_status(job))})
|
|
|
|
" quit the shell, it will make Vim exit
|
|
call term_sendkeys(buf, "exit\<CR>")
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
endfunc
|
|
|
|
func Test_terminal_open_autocmd()
|
|
augroup repro
|
|
au!
|
|
au TerminalOpen * let s:called += 1
|
|
augroup END
|
|
|
|
let s:called = 0
|
|
|
|
" Open a terminal window with :terminal
|
|
terminal
|
|
call assert_equal(1, s:called)
|
|
bwipe!
|
|
|
|
" Open a terminal window with term_start()
|
|
call term_start(&shell)
|
|
call assert_equal(2, s:called)
|
|
bwipe!
|
|
|
|
" Open a hidden terminal buffer with :terminal
|
|
terminal ++hidden
|
|
call assert_equal(3, s:called)
|
|
for buf in term_list()
|
|
exe buf . "bwipe!"
|
|
endfor
|
|
|
|
" Open a hidden terminal buffer with term_start()
|
|
let buf = term_start(&shell, {'hidden': 1})
|
|
call assert_equal(4, s:called)
|
|
exe buf . "bwipe!"
|
|
|
|
unlet s:called
|
|
au! repro
|
|
endfunc
|
|
|
|
func Test_open_term_from_cmd()
|
|
CheckScreendump
|
|
CheckUnix
|
|
CheckRunVimInTerminal
|
|
|
|
let lines =<< trim END
|
|
call setline(1, ['a', 'b', 'c'])
|
|
3
|
|
set incsearch
|
|
cnoremap <F3> <Cmd>call term_start(['/bin/sh', '-c', ':'])<CR>
|
|
END
|
|
call writefile(lines, 'Xopenterm', 'D')
|
|
let buf = RunVimInTerminal('-S Xopenterm', {})
|
|
|
|
" this opens a window, incsearch should not use the old cursor position
|
|
call term_sendkeys(buf, "/\<F3>")
|
|
call VerifyScreenDump(buf, 'Test_terminal_from_cmd', {})
|
|
call term_sendkeys(buf, "\<Esc>")
|
|
call term_sendkeys(buf, ":q\<CR>")
|
|
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_combining_double_width()
|
|
CheckScreendump
|
|
CheckUnix
|
|
CheckRunVimInTerminal
|
|
|
|
call writefile(["\xe3\x83\x9b\xe3\x82\x9a"], 'Xonedouble', 'D')
|
|
let lines =<< trim END
|
|
call term_start(['/bin/sh', '-c', 'cat Xonedouble'])
|
|
END
|
|
call writefile(lines, 'Xcombining', 'D')
|
|
let buf = RunVimInTerminal('-S Xcombining', #{rows: 9})
|
|
|
|
" this opens a window, incsearch should not use the old cursor position
|
|
call VerifyScreenDump(buf, 'Test_terminal_combining', {})
|
|
call term_sendkeys(buf, ":q\<CR>")
|
|
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_popup_with_cmd()
|
|
" this was crashing
|
|
let buf = term_start(&shell, #{hidden: v:true})
|
|
let s:winid = popup_create(buf, {})
|
|
tnoremap <F3> <Cmd>call popup_close(s:winid)<CR>
|
|
call feedkeys("\<F3>", 'xt')
|
|
|
|
tunmap <F3>
|
|
exe 'bwipe! ' .. buf
|
|
unlet s:winid
|
|
endfunc
|
|
|
|
func Test_terminal_popup_bufload()
|
|
let termbuf = term_start(&shell, #{hidden: v:true, term_finish: 'close'})
|
|
let winid = popup_create(termbuf, {})
|
|
sleep 50m
|
|
|
|
let newbuf = bufadd('')
|
|
call bufload(newbuf)
|
|
call setbufline(newbuf, 1, 'foobar')
|
|
|
|
" must not have switched to another window
|
|
call assert_equal(winid, win_getid())
|
|
|
|
call StopShellInTerminal(termbuf)
|
|
call WaitFor({-> win_getid() != winid})
|
|
exe 'bwipe! ' .. newbuf
|
|
endfunc
|
|
|
|
func Test_terminal_popup_two_windows()
|
|
CheckRunVimInTerminal
|
|
CheckUnix
|
|
|
|
" use "sh" instead of "&shell" in the hope it will use a short prompt
|
|
let lines =<< trim END
|
|
let termbuf = term_start('sh', #{hidden: v:true, term_finish: 'close'})
|
|
exe 'buffer ' .. termbuf
|
|
|
|
let winid = popup_create(termbuf, #{line: 2, minwidth: 30, border: []})
|
|
sleep 50m
|
|
|
|
call term_sendkeys(termbuf, "echo 'test'")
|
|
END
|
|
call writefile(lines, 'XpopupScript', 'D')
|
|
let buf = RunVimInTerminal('-S XpopupScript', {})
|
|
|
|
" typed text appears both in normal window and in popup
|
|
call WaitForAssert({-> assert_match("echo 'test'", term_getline(buf, 1))})
|
|
call WaitForAssert({-> assert_match("echo 'test'", term_getline(buf, 3))})
|
|
|
|
call term_sendkeys(buf, "\<CR>\<CR>exit\<CR>")
|
|
call TermWait(buf)
|
|
call term_sendkeys(buf, ":q\<CR>")
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_popup_insert_cmd()
|
|
CheckUnix
|
|
|
|
inoremap <F3> <Cmd>call StartTermInPopup()<CR>
|
|
func StartTermInPopup()
|
|
call term_start(['/bin/sh', '-c', 'cat'], #{hidden: v:true, term_finish: 'close'})->popup_create(#{highlight: 'Pmenu'})
|
|
endfunc
|
|
call feedkeys("i\<F3>")
|
|
sleep 10m
|
|
call assert_equal('n', mode())
|
|
|
|
call feedkeys("\<C-D>", 'xt')
|
|
call WaitFor({-> popup_list() == []})
|
|
delfunc StartTermInPopup
|
|
iunmap <F3>
|
|
endfunc
|
|
|
|
func Check_dump01(off)
|
|
call assert_equal('one two three four five', trim(getline(a:off + 1)))
|
|
call assert_equal('~ Select Word', trim(getline(a:off + 7)))
|
|
call assert_equal(':popup PopUp', trim(getline(a:off + 20)))
|
|
endfunc
|
|
|
|
func Test_terminal_dumpwrite_composing()
|
|
CheckRunVimInTerminal
|
|
|
|
let save_enc = &encoding
|
|
set encoding=utf-8
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
let text = " a\u0300 e\u0302 o\u0308"
|
|
call writefile([text], 'Xcomposing', 'D')
|
|
let buf = RunVimInTerminal('--cmd "set encoding=utf-8" Xcomposing', {})
|
|
call WaitForAssert({-> assert_match(text, term_getline(buf, 1))})
|
|
eval 'Xdump'->term_dumpwrite(buf)
|
|
let dumpline = readfile('Xdump')[0]
|
|
call assert_match('|à| |ê| |ö', dumpline)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xdump')
|
|
let &encoding = save_enc
|
|
endfunc
|
|
|
|
" Tests for failures in the term_dumpwrite() function
|
|
func Test_terminal_dumpwrite_errors()
|
|
CheckRunVimInTerminal
|
|
call assert_fails("call term_dumpwrite({}, 'Xtest.dump')", 'E728:')
|
|
let buf = RunVimInTerminal('', {})
|
|
call TermWait(buf)
|
|
call assert_fails("call term_dumpwrite(buf, 'Xtest.dump', '')", 'E1206:')
|
|
call assert_fails("call term_dumpwrite(buf, [])", 'E730:')
|
|
call writefile([], 'Xtest.dump')
|
|
call assert_fails("call term_dumpwrite(buf, 'Xtest.dump')", 'E953:')
|
|
call delete('Xtest.dump')
|
|
call assert_fails("call term_dumpwrite(buf, '')", 'E482:')
|
|
call assert_fails("call term_dumpwrite(buf, test_null_string())", 'E482:')
|
|
call test_garbagecollect_now()
|
|
call StopVimInTerminal(buf, 0)
|
|
call TermWait(buf)
|
|
call assert_fails("call term_dumpwrite(buf, 'Xtest.dump')", 'E958:')
|
|
call assert_fails('call term_sendkeys([], ":q\<CR>")', 'E745:')
|
|
call assert_equal(0, term_sendkeys(buf, ":q\<CR>"))
|
|
endfunc
|
|
|
|
" just testing basic functionality.
|
|
func Test_terminal_dumpload()
|
|
let curbuf = winbufnr('')
|
|
call assert_equal(1, winnr('$'))
|
|
let buf = term_dumpload('dumps/Test_popup_command_01.dump')
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(20, line('$'))
|
|
call Check_dump01(0)
|
|
|
|
" Load another dump in the same window
|
|
let buf2 = 'dumps/Test_diff_01.dump'->term_dumpload({'bufnr': buf})
|
|
call assert_equal(buf, buf2)
|
|
call assert_notequal('one two three four five', trim(getline(1)))
|
|
|
|
" Load the first dump again in the same window
|
|
let buf2 = term_dumpload('dumps/Test_popup_command_01.dump', {'bufnr': buf})
|
|
call assert_equal(buf, buf2)
|
|
call Check_dump01(0)
|
|
|
|
call assert_fails("call term_dumpload('dumps/Test_popup_command_01.dump', {'bufnr': curbuf})", 'E475:')
|
|
call assert_fails("call term_dumpload('dumps/Test_popup_command_01.dump', {'bufnr': 9999})", 'E86:')
|
|
new
|
|
let closedbuf = winbufnr('')
|
|
quit
|
|
call assert_fails("call term_dumpload('dumps/Test_popup_command_01.dump', {'bufnr': closedbuf})", 'E475:')
|
|
call assert_fails('call term_dumpload([])', 'E730:')
|
|
call assert_fails('call term_dumpload("xabcy.dump")', 'E485:')
|
|
|
|
quit
|
|
endfunc
|
|
|
|
func Test_terminal_dumpload_dump()
|
|
CheckScreendump
|
|
CheckRunVimInTerminal
|
|
|
|
let lines =<< trim END
|
|
call term_dumpload('dumps/Test_popupwin_22.dump', #{term_rows: 12})
|
|
END
|
|
call writefile(lines, 'XtermDumpload', 'D')
|
|
let buf = RunVimInTerminal('-S XtermDumpload', #{rows: 15})
|
|
call VerifyScreenDump(buf, 'Test_terminal_dumpload', {})
|
|
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_dumpdiff()
|
|
call assert_equal(1, winnr('$'))
|
|
eval 'dumps/Test_popup_command_01.dump'->term_dumpdiff('dumps/Test_popup_command_02.dump')
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(62, line('$'))
|
|
call Check_dump01(0)
|
|
call Check_dump01(42)
|
|
call assert_equal(' bbbbbbbbbbbbbbbbbb ', getline(26)[0:29])
|
|
quit
|
|
|
|
call assert_fails('call term_dumpdiff("X1.dump", [])', 'E730:')
|
|
call assert_fails('call term_dumpdiff("X1.dump", "X2.dump")', 'E485:')
|
|
call writefile([], 'X1.dump', 'D')
|
|
call assert_fails('call term_dumpdiff("X1.dump", "X2.dump")', 'E485:')
|
|
endfunc
|
|
|
|
func Test_terminal_dumpdiff_swap()
|
|
call assert_equal(1, winnr('$'))
|
|
call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_popup_command_03.dump')
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(62, line('$'))
|
|
call assert_match('Test_popup_command_01.dump', getline(21))
|
|
call assert_match('Test_popup_command_03.dump', getline(42))
|
|
call assert_match('Undo', getline(3))
|
|
call assert_match('three four five', getline(45))
|
|
|
|
normal s
|
|
call assert_match('Test_popup_command_03.dump', getline(21))
|
|
call assert_match('Test_popup_command_01.dump', getline(42))
|
|
call assert_match('three four five', getline(3))
|
|
call assert_match('Undo', getline(45))
|
|
quit
|
|
|
|
" Diff two terminal dump files with different number of rows
|
|
" Swap the diffs
|
|
call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_winline_rnu.dump')
|
|
call assert_match('Test_popup_command_01.dump', getline(21))
|
|
call assert_match('Test_winline_rnu.dump', getline(42))
|
|
normal s
|
|
call assert_match('Test_winline_rnu.dump', getline(6))
|
|
call assert_match('Test_popup_command_01.dump', getline(27))
|
|
quit
|
|
endfunc
|
|
|
|
func Test_terminal_dumpdiff_options()
|
|
set laststatus=0
|
|
call assert_equal(1, winnr('$'))
|
|
let height = winheight(0)
|
|
call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_popup_command_02.dump', {'vertical': 1, 'term_cols': 33})
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(height, winheight(winnr()))
|
|
call assert_equal(33, winwidth(winnr()))
|
|
call assert_equal('dump diff dumps/Test_popup_command_01.dump', bufname('%'))
|
|
quit
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_popup_command_02.dump', {'vertical': 0, 'term_rows': 13, 'term_name': 'something else'})
|
|
call assert_equal(2, winnr('$'))
|
|
call assert_equal(&columns, winwidth(0))
|
|
call assert_equal(13, winheight(0))
|
|
call assert_equal('something else', bufname('%'))
|
|
quit
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_popup_command_02.dump', {'curwin': 1})
|
|
call assert_equal(1, winnr('$'))
|
|
call assert_fails("call term_dumpdiff('dumps/Test_popup_command_01.dump', 'dumps/Test_popup_command_02.dump', {'bufnr': -1})", 'E475:')
|
|
bwipe
|
|
|
|
set laststatus&
|
|
endfunc
|
|
|
|
" When drawing the statusline the cursor position may not have been updated
|
|
" yet.
|
|
" 1. create a terminal, make it show 2 lines
|
|
" 2. 0.5 sec later: leave terminal window, execute "i"
|
|
" 3. 0.5 sec later: clear terminal window, now it's 1 line
|
|
" 4. 0.5 sec later: redraw, including statusline (used to trigger bug)
|
|
" 4. 0.5 sec later: should be done, clean up
|
|
func Test_terminal_statusline()
|
|
CheckUnix
|
|
CheckFeature timers
|
|
|
|
set statusline=x
|
|
terminal
|
|
let tbuf = bufnr('')
|
|
call term_sendkeys(tbuf, "clear; echo a; echo b; sleep 1; clear\n")
|
|
call timer_start(500, { tid -> feedkeys("\<C-w>j", 'tx') })
|
|
call timer_start(1500, { tid -> feedkeys("\<C-l>", 'tx') })
|
|
au BufLeave * if &buftype == 'terminal' | silent! normal i | endif
|
|
|
|
sleep 2
|
|
exe tbuf . 'bwipe!'
|
|
au! BufLeave
|
|
set statusline=
|
|
endfunc
|
|
|
|
func CheckTerminalWindowWorks(buf)
|
|
call WaitForAssert({-> assert_match('!sh \[running\]', term_getline(a:buf, 10))})
|
|
call term_sendkeys(a:buf, "exit\<CR>")
|
|
call WaitForAssert({-> assert_match('!sh \[finished\]', term_getline(a:buf, 10))})
|
|
call term_sendkeys(a:buf, ":q\<CR>")
|
|
call WaitForAssert({-> assert_match('^\~', term_getline(a:buf, 10))})
|
|
endfunc
|
|
|
|
func Test_start_terminal_from_timer()
|
|
CheckUnix
|
|
CheckFeature timers
|
|
|
|
" Open a terminal window from a timer, typed text goes to the terminal
|
|
call writefile(["call timer_start(100, { -> term_start('sh') })"], 'XtimerTerm', 'D')
|
|
let buf = RunVimInTerminal('-S XtimerTerm', {})
|
|
call CheckTerminalWindowWorks(buf)
|
|
|
|
" do the same in Insert mode
|
|
call term_sendkeys(buf, ":call timer_start(200, { -> term_start('sh') })\<CR>a")
|
|
call CheckTerminalWindowWorks(buf)
|
|
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_window_focus()
|
|
let winid1 = win_getid()
|
|
terminal
|
|
let winid2 = win_getid()
|
|
call feedkeys("\<C-W>j", 'xt')
|
|
call assert_equal(winid1, win_getid())
|
|
call feedkeys("\<C-W>k", 'xt')
|
|
call assert_equal(winid2, win_getid())
|
|
" can use a cursor key here
|
|
call feedkeys("\<C-W>\<Down>", 'xt')
|
|
call assert_equal(winid1, win_getid())
|
|
call feedkeys("\<C-W>\<Up>", 'xt')
|
|
call assert_equal(winid2, win_getid())
|
|
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Api_drop_common(options)
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
" Use the title termcap entries to output the escape sequence.
|
|
call writefile([
|
|
\ 'set title',
|
|
\ 'exe "set t_ts=\<Esc>]51; t_fs=\x07"',
|
|
\ 'let &titlestring = ''["drop","Xtextfile"' . a:options . ']''',
|
|
\ 'redraw',
|
|
\ "set t_ts=",
|
|
\ ], 'Xscript')
|
|
let buf = RunVimInTerminal('-S Xscript', {})
|
|
call WaitFor({-> bufnr('Xtextfile') > 0})
|
|
call assert_equal('Xtextfile', expand('%:t'))
|
|
call assert_true(winnr('$') >= 3)
|
|
return buf
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common('')
|
|
call assert_equal(0, &bin)
|
|
call assert_equal('', &fenc)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_bin()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"bin":1}')
|
|
call assert_equal(1, &bin)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_binary()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"binary":1}')
|
|
call assert_equal(1, &bin)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_nobin()
|
|
CheckRunVimInTerminal
|
|
set binary
|
|
let buf = Api_drop_common(',{"nobin":1}')
|
|
call assert_equal(0, &bin)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
set nobinary
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_nobinary()
|
|
CheckRunVimInTerminal
|
|
set binary
|
|
let buf = Api_drop_common(',{"nobinary":1}')
|
|
call assert_equal(0, &bin)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
set nobinary
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_ff()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"ff":"dos"}')
|
|
call assert_equal("dos", &ff)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_fileformat()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"fileformat":"dos"}')
|
|
call assert_equal("dos", &ff)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_enc()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"enc":"utf-16"}')
|
|
call assert_equal("utf-16", &fenc)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_newwin_encoding()
|
|
CheckRunVimInTerminal
|
|
let buf = Api_drop_common(',{"encoding":"utf-16"}')
|
|
call assert_equal("utf-16", &fenc)
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Test_terminal_api_drop_oldwin()
|
|
CheckRunVimInTerminal
|
|
let firstwinid = win_getid()
|
|
split Xtextfile
|
|
let textfile_winid = win_getid()
|
|
call assert_equal(2, winnr('$'))
|
|
call win_gotoid(firstwinid)
|
|
|
|
" Use the title termcap entries to output the escape sequence.
|
|
call writefile([
|
|
\ 'set title',
|
|
\ 'exe "set t_ts=\<Esc>]51; t_fs=\x07"',
|
|
\ 'let &titlestring = ''["drop","Xtextfile"]''',
|
|
\ 'redraw',
|
|
\ "set t_ts=",
|
|
\ ], 'Xscript', 'D')
|
|
let buf = RunVimInTerminal('-S Xscript', {'rows': 10})
|
|
call WaitForAssert({-> assert_equal('Xtextfile', expand('%:t'))})
|
|
call assert_equal(textfile_winid, win_getid())
|
|
|
|
call StopVimInTerminal(buf)
|
|
bwipe Xtextfile
|
|
endfunc
|
|
|
|
func Tapi_TryThis(bufnum, arg)
|
|
let g:called_bufnum = a:bufnum
|
|
let g:called_arg = a:arg
|
|
endfunc
|
|
|
|
func WriteApiCall(funcname)
|
|
" Use the title termcap entries to output the escape sequence.
|
|
call writefile([
|
|
\ 'set title',
|
|
\ 'exe "set t_ts=\<Esc>]51; t_fs=\x07"',
|
|
\ 'let &titlestring = ''["call","' . a:funcname . '",["hello",123]]''',
|
|
\ 'redraw',
|
|
\ "set t_ts=",
|
|
\ ], 'Xscript')
|
|
endfunc
|
|
|
|
func Test_terminal_api_call()
|
|
CheckRunVimInTerminal
|
|
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
|
|
call WriteApiCall('Tapi_TryThis')
|
|
|
|
" Default
|
|
let buf = RunVimInTerminal('-S Xscript', {})
|
|
call WaitFor({-> exists('g:called_bufnum')})
|
|
call assert_equal(buf, g:called_bufnum)
|
|
call assert_equal(['hello', 123], g:called_arg)
|
|
call StopVimInTerminal(buf)
|
|
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
|
|
" Enable explicitly
|
|
let buf = RunVimInTerminal('-S Xscript', {'term_api': 'Tapi_Try'})
|
|
call WaitFor({-> exists('g:called_bufnum')})
|
|
call assert_equal(buf, g:called_bufnum)
|
|
call assert_equal(['hello', 123], g:called_arg)
|
|
call StopVimInTerminal(buf)
|
|
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
|
|
func! ApiCall_TryThis(bufnum, arg)
|
|
let g:called_bufnum2 = a:bufnum
|
|
let g:called_arg2 = a:arg
|
|
endfunc
|
|
|
|
call WriteApiCall('ApiCall_TryThis')
|
|
|
|
" Use prefix match
|
|
let buf = RunVimInTerminal('-S Xscript', {'term_api': 'ApiCall_'})
|
|
call WaitFor({-> exists('g:called_bufnum2')})
|
|
call assert_equal(buf, g:called_bufnum2)
|
|
call assert_equal(['hello', 123], g:called_arg2)
|
|
call StopVimInTerminal(buf)
|
|
|
|
call assert_fails("call term_start('ls', {'term_api' : []})", 'E730:')
|
|
|
|
unlet! g:called_bufnum2
|
|
unlet! g:called_arg2
|
|
|
|
call delete('Xscript')
|
|
delfunction! ApiCall_TryThis
|
|
unlet! g:called_bufnum2
|
|
unlet! g:called_arg2
|
|
endfunc
|
|
|
|
func Test_terminal_api_call_fails()
|
|
CheckRunVimInTerminal
|
|
|
|
func! TryThis(bufnum, arg)
|
|
let g:called_bufnum3 = a:bufnum
|
|
let g:called_arg3 = a:arg
|
|
endfunc
|
|
|
|
call WriteApiCall('TryThis')
|
|
|
|
unlet! g:called_bufnum3
|
|
unlet! g:called_arg3
|
|
|
|
" Not permitted
|
|
call ch_logfile('Xlog', 'w')
|
|
let buf = RunVimInTerminal('-S Xscript', {'term_api': ''})
|
|
call WaitForAssert({-> assert_match('Unpermitted function: TryThis', string(readfile('Xlog')))})
|
|
call assert_false(exists('g:called_bufnum3'))
|
|
call assert_false(exists('g:called_arg3'))
|
|
call StopVimInTerminal(buf)
|
|
|
|
" No match
|
|
call ch_logfile('Xlog', 'w')
|
|
let buf = RunVimInTerminal('-S Xscript', {'term_api': 'TryThat'})
|
|
call WaitFor({-> string(readfile('Xlog')) =~ 'Unpermitted function: TryThis'})
|
|
call assert_false(exists('g:called_bufnum3'))
|
|
call assert_false(exists('g:called_arg3'))
|
|
call StopVimInTerminal(buf)
|
|
|
|
call delete('Xscript')
|
|
call ch_logfile('')
|
|
call delete('Xlog')
|
|
delfunction! TryThis
|
|
unlet! g:called_bufnum3
|
|
unlet! g:called_arg3
|
|
endfunc
|
|
|
|
let s:caught_e937 = 0
|
|
|
|
func Tapi_Delete(bufnum, arg)
|
|
try
|
|
execute 'bdelete!' a:bufnum
|
|
catch /E937:/
|
|
let s:caught_e937 = 1
|
|
endtry
|
|
endfunc
|
|
|
|
func Test_terminal_api_call_fail_delete()
|
|
CheckRunVimInTerminal
|
|
|
|
call WriteApiCall('Tapi_Delete')
|
|
let buf = RunVimInTerminal('-S Xscript', {})
|
|
call WaitForAssert({-> assert_equal(1, s:caught_e937)})
|
|
|
|
call StopVimInTerminal(buf)
|
|
call delete('Xscript')
|
|
call ch_logfile('', '')
|
|
endfunc
|
|
|
|
func Test_terminal_setapi_and_call()
|
|
CheckRunVimInTerminal
|
|
|
|
call WriteApiCall('Tapi_TryThis')
|
|
call ch_logfile('Xlog', 'w')
|
|
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
|
|
let buf = RunVimInTerminal('-S Xscript', {'term_api': ''})
|
|
call WaitForAssert({-> assert_match('Unpermitted function: Tapi_TryThis', string(readfile('Xlog')))})
|
|
call assert_false(exists('g:called_bufnum'))
|
|
call assert_false(exists('g:called_arg'))
|
|
|
|
eval buf->term_setapi('Tapi_')
|
|
call term_sendkeys(buf, ":set notitle\<CR>")
|
|
call term_sendkeys(buf, ":source Xscript\<CR>")
|
|
call WaitFor({-> exists('g:called_bufnum')})
|
|
call assert_equal(buf, g:called_bufnum)
|
|
call assert_equal(['hello', 123], g:called_arg)
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
call delete('Xscript')
|
|
call ch_logfile('')
|
|
call delete('Xlog')
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
endfunc
|
|
|
|
func Test_terminal_api_arg()
|
|
CheckRunVimInTerminal
|
|
|
|
call WriteApiCall('Tapi_TryThis')
|
|
call ch_logfile('Xlog', 'w')
|
|
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
|
|
execute 'term ++api= ' .. GetVimCommandCleanTerm() .. '-S Xscript'
|
|
let buf = bufnr('%')
|
|
call WaitForAssert({-> assert_match('Unpermitted function: Tapi_TryThis', string(readfile('Xlog')))})
|
|
call assert_false(exists('g:called_bufnum'))
|
|
call assert_false(exists('g:called_arg'))
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
call ch_logfile('Xlog', 'w')
|
|
|
|
execute 'term ++api=Tapi_ ' .. GetVimCommandCleanTerm() .. '-S Xscript'
|
|
let buf = bufnr('%')
|
|
call WaitFor({-> exists('g:called_bufnum')})
|
|
call assert_equal(buf, g:called_bufnum)
|
|
call assert_equal(['hello', 123], g:called_arg)
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
call delete('Xscript')
|
|
call ch_logfile('')
|
|
call delete('Xlog')
|
|
unlet! g:called_bufnum
|
|
unlet! g:called_arg
|
|
endfunc
|
|
|
|
func Test_terminal_ansicolors_default()
|
|
CheckFunction term_getansicolors
|
|
|
|
let colors = [
|
|
\ '#000000', '#e00000',
|
|
\ '#00e000', '#e0e000',
|
|
\ '#0000e0', '#e000e0',
|
|
\ '#00e0e0', '#e0e0e0',
|
|
\ '#808080', '#ff4040',
|
|
\ '#40ff40', '#ffff40',
|
|
\ '#4040ff', '#ff40ff',
|
|
\ '#40ffff', '#ffffff',
|
|
\]
|
|
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_equal(colors, term_getansicolors(buf))
|
|
call StopShellInTerminal(buf)
|
|
call assert_equal([], term_getansicolors(buf))
|
|
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
func Test_terminal_ansicolors_default_reset_tgc()
|
|
CheckScreendump
|
|
CheckFeature termguicolors
|
|
CheckRunVimInTerminal
|
|
|
|
let $PS1="$ "
|
|
let buf = RunVimInTerminal('-c "term sh"', {'rows': 12})
|
|
call TermWait(buf)
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
call term_sendkeys(buf, "printf '\\033[0;30;41mhello world\\033[0m\\n'\<CR>")
|
|
call WaitForAssert({-> assert_match('hello world', term_getline(buf, 2))})
|
|
call term_sendkeys(buf, "\<C-W>:set notgc\<CR>")
|
|
call term_sendkeys(buf, "printf '\\033[0;30;41mhello world\\033[0m\\n'\<CR>")
|
|
call WaitForAssert({-> assert_match('hello world', term_getline(buf, 4))})
|
|
|
|
call VerifyScreenDump(buf, 'Test_terminal_ansi_reset_tgc', {})
|
|
|
|
call term_sendkeys(buf, "exit\<CR>")
|
|
call TermWait(buf)
|
|
call StopVimInTerminal(buf)
|
|
unlet! $PS1
|
|
endfunc
|
|
|
|
let s:test_colors = [
|
|
\ '#616e64', '#0d0a79',
|
|
\ '#6d610d', '#0a7373',
|
|
\ '#690d0a', '#6d696e',
|
|
\ '#0d0a6f', '#616e0d',
|
|
\ '#0a6479', '#6d0d0a',
|
|
\ '#617373', '#0d0a69',
|
|
\ '#6d690d', '#0a6e6f',
|
|
\ '#610d0a', '#6e6479',
|
|
\]
|
|
|
|
func Test_terminal_ansicolors_global()
|
|
CheckFeature termguicolors
|
|
CheckFunction term_getansicolors
|
|
|
|
if has('vtp') && !has('vcon') && !has('gui_running')
|
|
throw 'Skipped: does not support termguicolors'
|
|
endif
|
|
|
|
set tgc
|
|
let g:terminal_ansi_colors = reverse(copy(s:test_colors))
|
|
let buf = Run_shell_in_terminal({})
|
|
call assert_equal(g:terminal_ansi_colors, term_getansicolors(buf))
|
|
call StopShellInTerminal(buf)
|
|
set tgc&
|
|
|
|
exe buf . 'bwipe'
|
|
unlet g:terminal_ansi_colors
|
|
endfunc
|
|
|
|
func Test_terminal_ansicolors_func()
|
|
CheckFeature termguicolors
|
|
CheckFunction term_getansicolors
|
|
|
|
if has('vtp') && !has('vcon') && !has('gui_running')
|
|
throw 'Skipped: does not support termguicolors'
|
|
endif
|
|
|
|
set tgc
|
|
let g:terminal_ansi_colors = reverse(copy(s:test_colors))
|
|
let buf = Run_shell_in_terminal({'ansi_colors': s:test_colors})
|
|
call assert_equal(s:test_colors, term_getansicolors(buf))
|
|
|
|
call term_setansicolors(buf, g:terminal_ansi_colors)
|
|
call assert_equal(g:terminal_ansi_colors, buf->term_getansicolors())
|
|
|
|
let colors = [
|
|
\ 'ivory', 'AliceBlue',
|
|
\ 'grey67', 'dark goldenrod',
|
|
\ 'SteelBlue3', 'PaleVioletRed4',
|
|
\ 'MediumPurple2', 'yellow2',
|
|
\ 'RosyBrown3', 'OrangeRed2',
|
|
\ 'white smoke', 'navy blue',
|
|
\ 'grey47', 'gray97',
|
|
\ 'MistyRose2', 'DodgerBlue4',
|
|
\]
|
|
eval buf->term_setansicolors(colors)
|
|
|
|
let colors[4] = 'Invalid'
|
|
call assert_fails('call term_setansicolors(buf, colors)', 'E254:')
|
|
call assert_fails('call term_setansicolors(buf, {})', 'E1211:')
|
|
call assert_fails('call term_setansicolors(buf, [])', 'E475: Invalid value for argument "colors"')
|
|
set tgc&
|
|
|
|
call StopShellInTerminal(buf)
|
|
call assert_equal(0, term_setansicolors(buf, []))
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
func Test_terminal_all_ansi_colors()
|
|
CheckScreendump
|
|
CheckRunVimInTerminal
|
|
|
|
" Use all the ANSI colors.
|
|
call writefile([
|
|
\ 'call setline(1, "AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPP XXYYZZ")',
|
|
\ 'hi Tblack ctermfg=0 ctermbg=8',
|
|
\ 'hi Tdarkred ctermfg=1 ctermbg=9',
|
|
\ 'hi Tdarkgreen ctermfg=2 ctermbg=10',
|
|
\ 'hi Tbrown ctermfg=3 ctermbg=11',
|
|
\ 'hi Tdarkblue ctermfg=4 ctermbg=12',
|
|
\ 'hi Tdarkmagenta ctermfg=5 ctermbg=13',
|
|
\ 'hi Tdarkcyan ctermfg=6 ctermbg=14',
|
|
\ 'hi Tlightgrey ctermfg=7 ctermbg=15',
|
|
\ 'hi Tdarkgrey ctermfg=8 ctermbg=0',
|
|
\ 'hi Tred ctermfg=9 ctermbg=1',
|
|
\ 'hi Tgreen ctermfg=10 ctermbg=2',
|
|
\ 'hi Tyellow ctermfg=11 ctermbg=3',
|
|
\ 'hi Tblue ctermfg=12 ctermbg=4',
|
|
\ 'hi Tmagenta ctermfg=13 ctermbg=5',
|
|
\ 'hi Tcyan ctermfg=14 ctermbg=6',
|
|
\ 'hi Twhite ctermfg=15 ctermbg=7',
|
|
\ 'hi TdarkredBold ctermfg=1 cterm=bold',
|
|
\ 'hi TgreenBold ctermfg=10 cterm=bold',
|
|
\ 'hi TmagentaBold ctermfg=13 cterm=bold ctermbg=5',
|
|
\ '',
|
|
\ 'call matchadd("Tblack", "A")',
|
|
\ 'call matchadd("Tdarkred", "B")',
|
|
\ 'call matchadd("Tdarkgreen", "C")',
|
|
\ 'call matchadd("Tbrown", "D")',
|
|
\ 'call matchadd("Tdarkblue", "E")',
|
|
\ 'call matchadd("Tdarkmagenta", "F")',
|
|
\ 'call matchadd("Tdarkcyan", "G")',
|
|
\ 'call matchadd("Tlightgrey", "H")',
|
|
\ 'call matchadd("Tdarkgrey", "I")',
|
|
\ 'call matchadd("Tred", "J")',
|
|
\ 'call matchadd("Tgreen", "K")',
|
|
\ 'call matchadd("Tyellow", "L")',
|
|
\ 'call matchadd("Tblue", "M")',
|
|
\ 'call matchadd("Tmagenta", "N")',
|
|
\ 'call matchadd("Tcyan", "O")',
|
|
\ 'call matchadd("Twhite", "P")',
|
|
\ 'call matchadd("TdarkredBold", "X")',
|
|
\ 'call matchadd("TgreenBold", "Y")',
|
|
\ 'call matchadd("TmagentaBold", "Z")',
|
|
\ 'redraw',
|
|
\ ], 'Xcolorscript', 'D')
|
|
let buf = RunVimInTerminal('-S Xcolorscript', {'rows': 10})
|
|
call VerifyScreenDump(buf, 'Test_terminal_all_ansi_colors', {})
|
|
|
|
call term_sendkeys(buf, ":q\<CR>")
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
function On_BufFilePost()
|
|
doautocmd <nomodeline> User UserEvent
|
|
endfunction
|
|
|
|
func Test_terminal_nested_autocmd()
|
|
new
|
|
call setline(1, range(500))
|
|
$
|
|
let lastline = line('.')
|
|
|
|
augroup TermTest
|
|
autocmd BufFilePost * call On_BufFilePost()
|
|
autocmd User UserEvent silent
|
|
augroup END
|
|
|
|
let cmd = Get_cat_123_cmd()
|
|
let buf = term_start(cmd, #{term_finish: 'close', hidden: 1})
|
|
call assert_equal(lastline, line('.'))
|
|
|
|
let job = term_getjob(buf)
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
call delete('Xtext')
|
|
augroup TermTest
|
|
au!
|
|
augroup END
|
|
endfunc
|
|
|
|
func Test_terminal_adds_jump()
|
|
clearjumps
|
|
call term_start("ls", #{curwin: 1})
|
|
call assert_equal(1, getjumplist()[0]->len())
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Close_cb(ch, ctx)
|
|
call term_wait(a:ctx.bufnr)
|
|
let g:close_done = 'done'
|
|
endfunc
|
|
|
|
func Test_term_wait_in_close_cb()
|
|
let g:close_done = ''
|
|
let ctx = {}
|
|
let ctx.bufnr = term_start('echo "HELLO WORLD"',
|
|
\ {'close_cb': {ch -> Close_cb(ch, ctx)}})
|
|
|
|
call WaitForAssert({-> assert_equal("done", g:close_done)})
|
|
|
|
unlet g:close_done
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Test_term_TextChangedT()
|
|
augroup TermTest
|
|
autocmd TextChangedT * ++once
|
|
\ execute expand('<abuf>') . 'buffer' |
|
|
\ let b:called = 1 |
|
|
\ split |
|
|
\ enew
|
|
augroup END
|
|
|
|
terminal
|
|
|
|
let term_buf = bufnr()
|
|
|
|
let b:called = 0
|
|
|
|
call term_sendkeys(term_buf, "aaabbc\r")
|
|
call TermWait(term_buf)
|
|
|
|
call assert_equal(1, getbufvar(term_buf, 'called'))
|
|
|
|
" Current buffer will be restored
|
|
call assert_equal(bufnr(), term_buf)
|
|
|
|
bwipe!
|
|
augroup TermTest
|
|
au!
|
|
augroup END
|
|
endfunc
|
|
|
|
func Test_term_TextChangedT_close()
|
|
augroup TermTest
|
|
autocmd TextChangedT * ++once split | enew | 1close!
|
|
augroup END
|
|
|
|
terminal
|
|
|
|
let term_buf = bufnr()
|
|
|
|
call term_sendkeys(term_buf, "aaabbc\r")
|
|
call TermWait(term_buf)
|
|
|
|
" Current buffer will be restored
|
|
call assert_equal(bufnr(), term_buf)
|
|
|
|
bwipe!
|
|
augroup TermTest
|
|
au!
|
|
augroup END
|
|
endfunc
|
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|