diff options
Diffstat (limited to '')
| -rw-r--r-- | src/testdir/test_terminal.vim | 2353 |
1 files changed, 2353 insertions, 0 deletions
diff --git a/src/testdir/test_terminal.vim b/src/testdir/test_terminal.vim new file mode 100644 index 0000000..b0c29ec --- /dev/null +++ b/src/testdir/test_terminal.vim @@ -0,0 +1,2353 @@ +" 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 sleep 1 + sleep 1 + 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 +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 /c "cls && color 2 && echo 123"' + else + " When clearing twice, extra sequence is not output. + return 'cmd /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 /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 /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) + + call StopShellInTerminal(buf) + exe buf . 'bwipe' + set termwinscroll& +endfunc + +func Test_terminal_postponed_scrollback() + " 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 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 /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 + call assert_equal(123, bufnr()->term_getjob()->job_info().exitval) + %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))}) + call assert_match('\^Z', getline(line('$') - 1)) + %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 + call assert_equal(123, bufnr()->term_getjob()->job_info().exitval) + %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 +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 /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() + 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() + 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() + 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() + 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 + +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:') + set tgc& + + call StopShellInTerminal(buf) + call assert_equal(0, term_setansicolors(buf, [])) + exe buf . 'bwipe' +endfunc + +func Test_terminal_all_ansi_colors() + 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 |