mirror of
https://github.com/vim/vim.git
synced 2025-10-23 08:44:20 -04:00
eb380b991c
Problem: tests: testdir is a bit messy Solution: move test scripts into testdir/util/ directory src/testdir/ has become a dumping ground mixing test cases with utility functions. Let's fix this by moving all utility functions into the testdir/util/ directory Also a few related changes had to be done: - Update Filelist - update README.txt and mention the new directory layout - fix shadowbuild by linking the util directory into the shadow dir closes: #17677 Signed-off-by: Christian Brabandt <cb@256bit.org>
712 lines
22 KiB
VimL
712 lines
22 KiB
VimL
" Tests for the terminal window.
|
|
" This is split in two, because it can take a lot of time.
|
|
" See test_terminal.vim and test_terminal3.vim for further tests.
|
|
|
|
CheckFeature terminal
|
|
|
|
source util/screendump.vim
|
|
source util/mouse.vim
|
|
|
|
let $PROMPT_COMMAND=''
|
|
|
|
func Test_terminal_termwinsize_option_fixed()
|
|
CheckRunVimInTerminal
|
|
set termwinsize=6x40
|
|
let text = []
|
|
for n in range(10)
|
|
call add(text, repeat(n, 50))
|
|
endfor
|
|
call writefile(text, 'Xwinsize', 'D')
|
|
let buf = RunVimInTerminal('Xwinsize', {})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([6, 40], term_getsize(buf))
|
|
call assert_equal(6, winheight(win))
|
|
call assert_equal(40, winwidth(win))
|
|
|
|
" resizing the window doesn't resize the terminal.
|
|
resize 10
|
|
vertical resize 60
|
|
call assert_equal([6, 40], term_getsize(buf))
|
|
call assert_equal(10, winheight(win))
|
|
call assert_equal(60, winwidth(win))
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
call assert_fails('set termwinsize=40', 'E474:')
|
|
call assert_fails('set termwinsize=10+40', 'E474:')
|
|
call assert_fails('set termwinsize=abc', 'E474:')
|
|
|
|
set termwinsize=
|
|
endfunc
|
|
|
|
func Test_terminal_termwinsize_option_zero()
|
|
set termwinsize=0x0
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([winheight(win), winwidth(win)], term_getsize(buf))
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
set termwinsize=7x0
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([7, winwidth(win)], term_getsize(buf))
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
set termwinsize=0x33
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([winheight(win), 33], term_getsize(buf))
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
" This used to crash Vim
|
|
set termwinsize=10000*10000
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([1000, 1000], term_getsize(buf))
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
set termwinsize=
|
|
endfunc
|
|
|
|
func Test_terminal_termwinsize_minimum()
|
|
set termwinsize=10*50
|
|
vsplit
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_inrange(10, 1000, winheight(win))
|
|
call assert_inrange(50, 1000, winwidth(win))
|
|
call assert_equal([winheight(win), winwidth(win)], term_getsize(buf))
|
|
|
|
resize 15
|
|
vertical resize 60
|
|
redraw
|
|
call assert_equal([15, 60], term_getsize(buf))
|
|
call assert_equal(15, winheight(win))
|
|
call assert_equal(60, winwidth(win))
|
|
|
|
resize 7
|
|
vertical resize 30
|
|
redraw
|
|
call assert_equal([10, 50], term_getsize(buf))
|
|
call assert_equal(7, winheight(win))
|
|
call assert_equal(30, winwidth(win))
|
|
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
set termwinsize=0*0
|
|
let buf = Run_shell_in_terminal({})
|
|
let win = bufwinid(buf)
|
|
call assert_equal([winheight(win), winwidth(win)], term_getsize(buf))
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
|
|
set termwinsize=
|
|
endfunc
|
|
|
|
func Test_terminal_termwinsize_overruled()
|
|
let cmd = GetDummyCmd()
|
|
set termwinsize=5x43
|
|
let buf = term_start(cmd, #{term_rows: 7, term_cols: 50})
|
|
call TermWait(buf)
|
|
call assert_equal([7, 50], term_getsize(buf))
|
|
exe "bwipe! " .. buf
|
|
|
|
let buf = term_start(cmd, #{term_cols: 50})
|
|
call TermWait(buf)
|
|
call assert_equal([5, 50], term_getsize(buf))
|
|
exe "bwipe! " .. buf
|
|
|
|
let buf = term_start(cmd, #{term_rows: 7})
|
|
call TermWait(buf)
|
|
call assert_equal([7, 43], term_getsize(buf))
|
|
exe "bwipe! " .. buf
|
|
|
|
set termwinsize=
|
|
endfunc
|
|
|
|
" hidden terminal must not change current window size
|
|
func Test_terminal_hidden_winsize()
|
|
let cmd = GetDummyCmd()
|
|
let rows = winheight(0)
|
|
let buf = term_start(cmd, #{hidden: 1, term_rows: 10})
|
|
call TermWait(buf)
|
|
call assert_equal(rows, winheight(0))
|
|
call assert_equal([10, &columns], term_getsize(buf))
|
|
exe "bwipe! " .. buf
|
|
endfunc
|
|
|
|
func Test_terminal_termwinkey()
|
|
" make three tabpages, terminal in the middle
|
|
0tabnew
|
|
tabnext
|
|
tabnew
|
|
tabprev
|
|
call assert_equal(1, winnr('$'))
|
|
call assert_equal(2, tabpagenr())
|
|
let thiswin = win_getid()
|
|
|
|
let buf = Run_shell_in_terminal({})
|
|
let termwin = bufwinid(buf)
|
|
set termwinkey=<C-L>
|
|
call feedkeys("\<C-L>w", 'tx')
|
|
call assert_equal(thiswin, win_getid())
|
|
call feedkeys("\<C-W>w", 'tx')
|
|
call assert_equal(termwin, win_getid())
|
|
|
|
if has('langmap')
|
|
set langmap=xjyk
|
|
call feedkeys("\<C-L>x", 'tx')
|
|
call assert_equal(thiswin, win_getid())
|
|
call feedkeys("\<C-W>y", 'tx')
|
|
call assert_equal(termwin, win_getid())
|
|
set langmap=
|
|
endif
|
|
|
|
call feedkeys("\<C-L>gt", "xt")
|
|
call assert_equal(3, tabpagenr())
|
|
tabprev
|
|
call assert_equal(2, tabpagenr())
|
|
call assert_equal(termwin, win_getid())
|
|
|
|
call feedkeys("\<C-L>gT", "xt")
|
|
call assert_equal(1, tabpagenr())
|
|
tabnext
|
|
call assert_equal(2, tabpagenr())
|
|
call assert_equal(termwin, win_getid())
|
|
|
|
let job = term_getjob(buf)
|
|
call feedkeys("\<C-L>\<C-C>", 'tx')
|
|
call WaitForAssert({-> assert_equal("dead", job_status(job))})
|
|
|
|
set termwinkey&
|
|
tabnext
|
|
tabclose
|
|
tabprev
|
|
tabclose
|
|
endfunc
|
|
|
|
func Test_terminal_out_err()
|
|
CheckUnix
|
|
|
|
call writefile([
|
|
\ '#!/bin/sh',
|
|
\ 'echo "this is standard error" >&2',
|
|
\ 'echo "this is standard out" >&1',
|
|
\ ], 'Xechoerrout.sh', 'D')
|
|
call setfperm('Xechoerrout.sh', 'rwxrwx---')
|
|
|
|
let outfile = 'Xtermstdout'
|
|
let buf = term_start(['./Xechoerrout.sh'], {'out_io': 'file', 'out_name': outfile})
|
|
call TermWait(buf)
|
|
|
|
call WaitFor({-> !empty(readfile(outfile)) && !empty(term_getline(buf, 1))})
|
|
call assert_equal(['this is standard out'], readfile(outfile))
|
|
call assert_equal('this is standard error', term_getline(buf, 1))
|
|
|
|
call WaitForAssert({-> assert_equal('dead', job_status(term_getjob(buf)))})
|
|
exe buf . 'bwipe'
|
|
call delete(outfile)
|
|
endfunc
|
|
|
|
func Test_termwinscroll()
|
|
CheckUnix
|
|
" TODO: Somehow this test sometimes hangs in the GUI
|
|
CheckNotGui
|
|
let g:test_is_flaky = 1
|
|
|
|
" Let the terminal output more than 'termwinscroll' lines, some at the start
|
|
" will be dropped.
|
|
exe 'set termwinscroll=' . &lines
|
|
let buf = term_start('/bin/sh')
|
|
call TermWait(buf)
|
|
for i in range(1, &lines)
|
|
call feedkeys("echo " . i . "\<CR>", 'xt')
|
|
call WaitForAssert({-> assert_match(string(i), term_getline(buf, term_getcursor(buf)[0] - 1))})
|
|
endfor
|
|
" Go to Terminal-Normal mode to update the buffer.
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
call assert_inrange(&lines, &lines * 110 / 100 + winheight(0), line('$'))
|
|
|
|
" Every "echo nr" must only appear once
|
|
let lines = getline(1, line('$'))
|
|
for i in range(&lines - len(lines) / 2 + 2, &lines)
|
|
let filtered = filter(copy(lines), {idx, val -> val =~ 'echo ' . i . '\>'})
|
|
call assert_equal(1, len(filtered), 'for "echo ' . i . '"')
|
|
endfor
|
|
exe buf . 'bwipe!'
|
|
endfunc
|
|
|
|
func Test_termwinscroll_topline()
|
|
" TODO: why does this fail on Appveyor and Github?
|
|
CheckNotMSWindows
|
|
|
|
set termwinscroll=1000 mouse=a
|
|
terminal
|
|
call assert_equal(2, winnr('$'))
|
|
let buf = bufnr()
|
|
call WaitFor({-> !empty(term_getline(buf, 1))})
|
|
|
|
let num1 = &termwinscroll / 100 * 99
|
|
call writefile(range(num1), '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(string(num1 - 1), term_getline(buf, rows - 1) .. term_getline(buf, rows - 2))})
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
call feedkeys("i", 'xt')
|
|
|
|
let num2 = &termwinscroll / 100 * 10
|
|
call writefile(range(num2), 'Xtext', 'D')
|
|
if has('win32')
|
|
call term_sendkeys(buf, "timeout /t 1 && type Xtext\<CR>")
|
|
else
|
|
call term_sendkeys(buf, "sleep 1; cat Xtext\<CR>")
|
|
endif
|
|
" Change the normal window to the current window with keystrokes.
|
|
call feedkeys("\<C-W>w", 'xt')
|
|
call WaitForAssert({-> assert_notequal(buf, bufnr())})
|
|
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(string(num2 - 1), term_getline(buf, rows - 1) .. term_getline(buf, rows - 2))})
|
|
" Change the terminal window to the current window using mouse operation.
|
|
call test_setmouse(1, 1)
|
|
call feedkeys("\<LeftMouse>", "xt")
|
|
call WaitForAssert({-> assert_equal(buf, bufnr())})
|
|
" Before the fix, E340 and E315 would occur multiple times at this point.
|
|
let wm = winheight(0) * 2
|
|
let num3 = num1 + num2 - (num1 / 10) - wm
|
|
call assert_inrange(num3 - wm, num3 + wm, getwininfo(bufwinid(buf))[0].topline)
|
|
exe buf . 'bwipe!'
|
|
set termwinscroll& mouse&
|
|
endfunc
|
|
|
|
func Test_termwinscroll_topline2()
|
|
" calling the terminal API doesn't work on Windows
|
|
CheckNotMSWindows
|
|
|
|
set termwinscroll=50000 mouse=a
|
|
set shell=sh
|
|
let norm_winid = win_getid()
|
|
terminal
|
|
call assert_equal(2, winnr('$'))
|
|
let buf = bufnr()
|
|
let win = winnr()
|
|
call WaitFor({-> !empty(term_getline(buf, 1))})
|
|
|
|
let num1 = &termwinscroll / 1000 * 999
|
|
call writefile(range(num1), 'Xtext', 'D')
|
|
call term_sendkeys(buf, "cat Xtext\<CR>")
|
|
call term_sendkeys(buf, "printf '" .. TermNotifyParentCmd(v:false) .. "'\<cr>")
|
|
let rows = term_getsize(buf)[0]
|
|
let cnt = 0
|
|
while !g:child_notification && cnt <= 50000
|
|
" Spin wait to process the terminal print as quickly as possible. This is
|
|
" more efficient than calling WaitForChildNotification() as we don't want
|
|
" to sleep here as the print is I/O-bound.
|
|
let cnt += 1
|
|
call term_wait(buf, 0)
|
|
endwhile
|
|
call WaitForAssert({-> assert_match(string(num1 - 1), term_getline(buf, rows - 1) .. '\|' .. term_getline(buf, rows - 2))})
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
call feedkeys("i", 'xt')
|
|
|
|
let num2 = &termwinscroll / 1000 * 8
|
|
call writefile(range(num2), 'Xtext', 'D')
|
|
call term_sendkeys(buf, "sleep 2; cat Xtext\<CR>")
|
|
let winrow = get(get(filter(getwininfo(), 'v:val.winid == norm_winid'), 0, {}), 'winrow', -1)
|
|
|
|
call test_setmouse(winrow, 1)
|
|
call feedkeys("\<LeftMouse>", "xt")
|
|
call WaitForAssert({-> assert_notequal(buf, bufnr())})
|
|
|
|
" Change the terminal window row size
|
|
call win_move_statusline(win,1)
|
|
" Before the fix, E340 and E315 would occur multiple times at this point.
|
|
let winrow2 = get(get(filter(getwininfo(), 'v:val.winid == norm_winid'), 0, {}), 'winrow', -1)
|
|
call assert_equal(winrow + 1, winrow2)
|
|
|
|
call test_setmouse(1, 1)
|
|
call feedkeys("\<LeftMouse>", "xt")
|
|
call WaitForAssert({-> assert_equal(buf, bufnr())})
|
|
|
|
exe buf . 'bwipe!'
|
|
set termwinscroll& mouse& sh&
|
|
endfunc
|
|
|
|
" Resizing the terminal window caused an ml_get error.
|
|
" TODO: This does not reproduce the original problem.
|
|
" TODO: This test starts timing out in Github CI Gui test, why????
|
|
func Test_terminal_resize()
|
|
if has('gui_running') && expand('$GITHUB_ACTIONS') ==# 'true'
|
|
throw 'Skipped: FIXME: this test times-out in Github Actions CI with GUI. Why?'
|
|
endif
|
|
set statusline=x
|
|
terminal
|
|
call assert_equal(2, winnr('$'))
|
|
let buf = bufnr()
|
|
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
" Fill the terminal with text.
|
|
if has('win32')
|
|
call feedkeys("dir\<CR>", 'xt')
|
|
else
|
|
call feedkeys("ls\<CR>", 'xt')
|
|
endif
|
|
" Wait for some output
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 3))})
|
|
|
|
" Go to Terminal-Normal mode for a moment.
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
" Open a new window
|
|
call feedkeys("i\<C-W>n", 'xt')
|
|
call assert_equal(3, winnr('$'))
|
|
redraw
|
|
|
|
close
|
|
call assert_equal(2, winnr('$'))
|
|
call feedkeys("exit\<CR>", 'xt')
|
|
call TermWait(buf)
|
|
set statusline&
|
|
endfunc
|
|
|
|
" TODO: This test starts timing out in Github CI Gui test, why????
|
|
func Test_terminal_resize2()
|
|
CheckNotMSWindows
|
|
if has('gui_running') && expand('$GITHUB_ACTIONS') ==# 'true'
|
|
throw 'Skipped: FIXME: this test times-out in Github Actions CI with GUI. Why?'
|
|
endif
|
|
set statusline=x
|
|
terminal
|
|
call assert_equal(2, winnr('$'))
|
|
let buf = bufnr()
|
|
|
|
" Wait for the shell to display a prompt
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
" This used to crash Vim
|
|
call feedkeys("printf '\033[8;99999;99999t'\<CR>", 'xt')
|
|
redraw
|
|
|
|
call feedkeys("exit\<CR>", 'xt')
|
|
call TermWait(buf)
|
|
set statusline&
|
|
endfunc
|
|
|
|
" must be nearly the last, we can't go back from GUI to terminal
|
|
func Test_zz1_terminal_in_gui()
|
|
CheckCanRunGui
|
|
|
|
" Ignore the "failed to create input context" error.
|
|
call test_ignore_error('E285:')
|
|
|
|
gui -f
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
let buf = Run_shell_in_terminal({'term_finish': 'close'})
|
|
call StopShellInTerminal(buf)
|
|
|
|
" closing window wipes out the terminal buffer a with finished job
|
|
call WaitForAssert({-> assert_equal(1, winnr('$'))})
|
|
call assert_equal("", bufname(buf))
|
|
|
|
unlet g:job
|
|
endfunc
|
|
|
|
func Test_zz2_terminal_guioptions_bang()
|
|
CheckGui
|
|
set guioptions+=!
|
|
|
|
let filename = 'Xtestscript'
|
|
if has('win32')
|
|
let filename .= '.bat'
|
|
let prefix = ''
|
|
let contents = ['@echo off', 'exit %1']
|
|
else
|
|
let filename .= '.sh'
|
|
let prefix = './'
|
|
let contents = ['#!/bin/sh', 'exit $1']
|
|
endif
|
|
call writefile(contents, filename, 'D')
|
|
call setfperm(filename, 'rwxrwx---')
|
|
|
|
" Check if v:shell_error is equal to the exit status.
|
|
let exitval = 0
|
|
execute printf(':!%s%s %d', prefix, filename, exitval)
|
|
call assert_equal(exitval, v:shell_error)
|
|
|
|
let exitval = 9
|
|
execute printf(':!%s%s %d', prefix, filename, exitval)
|
|
call assert_equal(exitval, v:shell_error)
|
|
|
|
set guioptions&
|
|
endfunc
|
|
|
|
func Test_terminal_hidden()
|
|
CheckUnix
|
|
|
|
term ++hidden cat
|
|
let bnr = bufnr('$')
|
|
call assert_equal('terminal', getbufvar(bnr, '&buftype'))
|
|
exe 'sbuf ' . bnr
|
|
call assert_equal('terminal', &buftype)
|
|
call term_sendkeys(bnr, "asdf\<CR>")
|
|
call WaitForAssert({-> assert_match('asdf', term_getline(bnr, 2))})
|
|
call term_sendkeys(bnr, "\<C-D>")
|
|
call WaitForAssert({-> assert_equal('finished', bnr->term_getstatus())})
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_switch_mode()
|
|
term
|
|
let bnr = bufnr('$')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
" In the GUI the first switch sometimes doesn't work. Switch twice to avoid
|
|
" flakiness.
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
call feedkeys("A", 'xt')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
call feedkeys("\<C-W>N", 'xt')
|
|
call WaitForAssert({-> assert_equal('running,normal', term_getstatus(bnr))})
|
|
call feedkeys("A", 'xt')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
call feedkeys("\<C-\>\<C-N>", 'xt')
|
|
call WaitForAssert({-> assert_equal('running,normal', term_getstatus(bnr))})
|
|
call feedkeys("I", 'xt')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
call feedkeys("\<C-W>Nv", 'xt')
|
|
call WaitForAssert({-> assert_equal('running,normal', term_getstatus(bnr))})
|
|
call feedkeys("I", 'xt')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
call feedkeys("\<C-W>Nv", 'xt')
|
|
call WaitForAssert({-> assert_equal('running,normal', term_getstatus(bnr))})
|
|
call feedkeys("A", 'xt')
|
|
call WaitForAssert({-> assert_equal('running', term_getstatus(bnr))})
|
|
bwipe!
|
|
endfunc
|
|
|
|
func Test_terminal_normal_mode()
|
|
CheckScreendump
|
|
CheckRunVimInTerminal
|
|
|
|
" Run Vim in a terminal and open a terminal window to run Vim in.
|
|
let lines =<< trim END
|
|
call setline(1, range(11111, 11122))
|
|
3
|
|
END
|
|
call writefile(lines, 'XtermNormal', 'D')
|
|
let buf = RunVimInTerminal('-S XtermNormal', {'rows': 8})
|
|
call TermWait(buf)
|
|
|
|
call term_sendkeys(buf, "\<C-W>N")
|
|
call term_sendkeys(buf, ":set number cursorline culopt=both\r")
|
|
call VerifyScreenDump(buf, 'Test_terminal_normal_1', {})
|
|
|
|
call term_sendkeys(buf, ":set culopt=number\r")
|
|
call VerifyScreenDump(buf, 'Test_terminal_normal_2', {})
|
|
|
|
call term_sendkeys(buf, ":set culopt=line\r")
|
|
call VerifyScreenDump(buf, 'Test_terminal_normal_3', {})
|
|
|
|
call assert_fails('call term_sendkeys(buf, [])', 'E730:')
|
|
call term_sendkeys(buf, "a:q!\<CR>:q\<CR>:q\<CR>")
|
|
call StopVimInTerminal(buf)
|
|
endfunc
|
|
|
|
func Test_terminal_hidden_and_close()
|
|
CheckUnix
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
term ++hidden ++close ls
|
|
let bnr = bufnr('$')
|
|
call assert_equal('terminal', getbufvar(bnr, '&buftype'))
|
|
call WaitForAssert({-> assert_false(bufexists(bnr))})
|
|
call assert_equal(1, winnr('$'))
|
|
endfunc
|
|
|
|
func Test_terminal_does_not_truncate_last_newlines()
|
|
if has('conpty')
|
|
throw 'Skipped: fail on ConPTY'
|
|
endif
|
|
let g:test_is_flaky = 1
|
|
let contents = [
|
|
\ [ 'One', '', 'X' ],
|
|
\ [ 'Two', '', '' ],
|
|
\ [ 'Three' ] + repeat([''], 30)
|
|
\ ]
|
|
|
|
for c in contents
|
|
call writefile(c, 'Xdntfile', 'D')
|
|
if has('win32')
|
|
term cmd /D /c type Xdntfile
|
|
else
|
|
term cat Xdntfile
|
|
endif
|
|
let bnr = bufnr('$')
|
|
call assert_equal('terminal', getbufvar(bnr, '&buftype'))
|
|
call WaitForAssert({-> assert_equal('finished', term_getstatus(bnr))})
|
|
sleep 100m
|
|
call assert_equal(c, getline(1, line('$')))
|
|
quit
|
|
endfor
|
|
endfunc
|
|
|
|
func GetDummyCmd()
|
|
if has('win32')
|
|
return 'cmd /D /c ""'
|
|
else
|
|
CheckExecutable false
|
|
return 'false'
|
|
endif
|
|
endfunc
|
|
|
|
func Test_terminal_no_job()
|
|
let cmd = GetDummyCmd()
|
|
let term = term_start(cmd, {'term_finish': 'close'})
|
|
call WaitForAssert({-> assert_equal(v:null, term_getjob(term)) })
|
|
endfunc
|
|
|
|
func Test_term_getcursor()
|
|
CheckUnix
|
|
|
|
let buf = Run_shell_in_terminal({})
|
|
|
|
" Wait for the shell to display a prompt.
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
|
|
" Hide the cursor.
|
|
call term_sendkeys(buf, "echo -e '\\033[?25l'\r")
|
|
call WaitForAssert({-> assert_equal(0, term_getcursor(buf)[2].visible)})
|
|
|
|
" Show the cursor.
|
|
call term_sendkeys(buf, "echo -e '\\033[?25h'\r")
|
|
call WaitForAssert({-> assert_equal(1, buf->term_getcursor()[2].visible)})
|
|
|
|
" Change color of cursor.
|
|
call WaitForAssert({-> assert_equal('', term_getcursor(buf)[2].color)})
|
|
call term_sendkeys(buf, "echo -e '\\033]12;blue\\007'\r")
|
|
call WaitForAssert({-> assert_equal('blue', term_getcursor(buf)[2].color)})
|
|
call term_sendkeys(buf, "echo -e '\\033]12;green\\007'\r")
|
|
call WaitForAssert({-> assert_equal('green', term_getcursor(buf)[2].color)})
|
|
|
|
" Make cursor a blinking block.
|
|
call term_sendkeys(buf, "echo -e '\\033[1 q'\r")
|
|
call WaitForAssert({-> assert_equal([1, 1],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
" Make cursor a steady block.
|
|
call term_sendkeys(buf, "echo -e '\\033[2 q'\r")
|
|
call WaitForAssert({-> assert_equal([0, 1],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
" Make cursor a blinking underline.
|
|
call term_sendkeys(buf, "echo -e '\\033[3 q'\r")
|
|
call WaitForAssert({-> assert_equal([1, 2],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
" Make cursor a steady underline.
|
|
call term_sendkeys(buf, "echo -e '\\033[4 q'\r")
|
|
call WaitForAssert({-> assert_equal([0, 2],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
" Make cursor a blinking vertical bar.
|
|
call term_sendkeys(buf, "echo -e '\\033[5 q'\r")
|
|
call WaitForAssert({-> assert_equal([1, 3],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
" Make cursor a steady vertical bar.
|
|
call term_sendkeys(buf, "echo -e '\\033[6 q'\r")
|
|
call WaitForAssert({-> assert_equal([0, 3],
|
|
\ [term_getcursor(buf)[2].blink, term_getcursor(buf)[2].shape])})
|
|
|
|
call StopShellInTerminal(buf)
|
|
endfunc
|
|
|
|
" Test for term_gettitle()
|
|
" Known to be flaky on Mac-OS X and the GH runners
|
|
func Test_term_gettitle()
|
|
" term_gettitle() returns an empty string for a non-terminal buffer
|
|
" and for a non-existing buffer.
|
|
call assert_equal('', bufnr('%')->term_gettitle())
|
|
call assert_equal('', term_gettitle(bufnr('$') + 1))
|
|
|
|
if !has('title') || empty(&t_ts)
|
|
throw "Skipped: can't get/set title"
|
|
endif
|
|
if has('osx') && !empty($CI) && system('uname -m') =~# 'arm64'
|
|
" This test often fails with the following error message on Github runners
|
|
" MacOS-14
|
|
" '^\\[No Name\\] - VIM\\d*$' does not match 'e] - VIM'
|
|
" Why? Is the terminal that runs Vim too small?
|
|
throw 'Skipped: FIXME: Running this test on M1 Mac fails on GitHub Actions'
|
|
endif
|
|
|
|
let term = term_start([GetVimProg(), '--clean', '-c', 'set noswapfile', '-c', 'set title'])
|
|
call TermWait(term)
|
|
" When Vim is running as a server then the title ends in VIM{number}, thus
|
|
" optionally match a number after "VIM".
|
|
call WaitForAssert({-> assert_match('^\[No Name\] - VIM\d*$', term_gettitle(term)) })
|
|
call term_sendkeys(term, ":e Xfoo\r")
|
|
call WaitForAssert({-> assert_match('^Xfoo (.*[/\\]testdir) - VIM\d*$', term_gettitle(term)) })
|
|
|
|
call term_sendkeys(term, ":set titlestring=foo\r")
|
|
call WaitForAssert({-> assert_equal('foo', term_gettitle(term)) })
|
|
|
|
exe term . 'bwipe!'
|
|
endfunc
|
|
|
|
func Test_term_gettty()
|
|
let buf = Run_shell_in_terminal({})
|
|
let gettty = term_gettty(buf)
|
|
|
|
if has('unix') && executable('tty')
|
|
" Find tty using the tty shell command.
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 1))})
|
|
call term_sendkeys(buf, "tty\r")
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 3))})
|
|
let tty = term_getline(buf, 2)
|
|
call assert_equal(tty, gettty)
|
|
endif
|
|
|
|
let gettty0 = term_gettty(buf, 0)
|
|
let gettty1 = term_gettty(buf, 1)
|
|
|
|
call assert_equal(gettty, gettty0)
|
|
call assert_equal(job_info(g:job).tty_out, gettty0)
|
|
call assert_equal(job_info(g:job).tty_in, gettty1)
|
|
|
|
if has('unix')
|
|
" For unix, term_gettty(..., 0) and term_gettty(..., 1)
|
|
" are identical according to :help term_gettty()
|
|
call assert_equal(gettty0, gettty1)
|
|
call assert_match('^/dev/', gettty)
|
|
else
|
|
" ConPTY works on anonymous pipe.
|
|
if !has('conpty')
|
|
call assert_match('^\\\\.\\pipe\\', gettty0)
|
|
call assert_match('^\\\\.\\pipe\\', gettty1)
|
|
endif
|
|
endif
|
|
|
|
call assert_fails('call term_gettty(buf, 2)', 'E475:')
|
|
call assert_fails('call term_gettty(buf, -1)', 'E475:')
|
|
|
|
call assert_equal('', term_gettty(buf + 1))
|
|
|
|
call StopShellInTerminal(buf)
|
|
exe buf . 'bwipe'
|
|
endfunc
|
|
|
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|