mirror of
https://github.com/neovim/neovim.git
synced 2024-12-27 14:21:31 -07:00
6e414b698c
Remove the command('qall!') from mksession_spec.lua because it prevents
helpers.rmdir() from retrying.
Allow extra trailing spaces when matching terminal lines.
603 lines
20 KiB
Lua
603 lines
20 KiB
Lua
local Screen = require('test.functional.ui.screen')
|
|
local helpers = require('test.functional.helpers')(after_each)
|
|
local thelpers = require('test.functional.terminal.helpers')
|
|
local clear, eq, curbuf = helpers.clear, helpers.eq, helpers.curbuf
|
|
local feed, nvim_dir, feed_command = helpers.feed, helpers.nvim_dir, helpers.feed_command
|
|
local iswin = helpers.iswin
|
|
local eval = helpers.eval
|
|
local command = helpers.command
|
|
local matches = helpers.matches
|
|
local poke_eventloop = helpers.poke_eventloop
|
|
local retry = helpers.retry
|
|
local curbufmeths = helpers.curbufmeths
|
|
local nvim = helpers.nvim
|
|
local feed_data = thelpers.feed_data
|
|
local pcall_err = helpers.pcall_err
|
|
local exec_lua = helpers.exec_lua
|
|
local assert_alive = helpers.assert_alive
|
|
|
|
describe(':terminal scrollback', function()
|
|
local screen
|
|
|
|
before_each(function()
|
|
clear()
|
|
screen = thelpers.screen_setup(nil, nil, 30)
|
|
end)
|
|
|
|
describe('when the limit is exceeded', function()
|
|
before_each(function()
|
|
local lines = {}
|
|
for i = 1, 30 do
|
|
table.insert(lines, 'line'..tostring(i))
|
|
end
|
|
table.insert(lines, '')
|
|
feed_data(lines)
|
|
screen:expect([[
|
|
line26 |
|
|
line27 |
|
|
line28 |
|
|
line29 |
|
|
line30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
|
|
it('will delete extra lines at the top', function()
|
|
feed('<c-\\><c-n>gg')
|
|
screen:expect([[
|
|
^line16 |
|
|
line17 |
|
|
line18 |
|
|
line19 |
|
|
line20 |
|
|
line21 |
|
|
|
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
describe('with cursor at last row', function()
|
|
before_each(function()
|
|
feed_data({'line1', 'line2', 'line3', 'line4', ''})
|
|
screen:expect([[
|
|
tty ready |
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
|
|
describe('and 1 line is printed', function()
|
|
before_each(function() feed_data({'line5', ''}) end)
|
|
|
|
it('will hide the top line', function()
|
|
screen:expect([[
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
line5 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
eq(7, curbuf('line_count'))
|
|
end)
|
|
|
|
describe('and then 3 more lines are printed', function()
|
|
before_each(function() feed_data({'line6', 'line7', 'line8'}) end)
|
|
|
|
it('will hide the top 4 lines', function()
|
|
screen:expect([[
|
|
line3 |
|
|
line4 |
|
|
line5 |
|
|
line6 |
|
|
line7 |
|
|
line8{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
|
|
feed('<c-\\><c-n>6k')
|
|
screen:expect([[
|
|
^line2 |
|
|
line3 |
|
|
line4 |
|
|
line5 |
|
|
line6 |
|
|
line7 |
|
|
|
|
|
]])
|
|
|
|
feed('gg')
|
|
screen:expect([[
|
|
^tty ready |
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
line5 |
|
|
|
|
|
]])
|
|
|
|
feed('G')
|
|
screen:expect([[
|
|
line3 |
|
|
line4 |
|
|
line5 |
|
|
line6 |
|
|
line7 |
|
|
^line8{2: } |
|
|
|
|
|
]])
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
|
|
describe('and height decreased by 1', function()
|
|
if helpers.pending_win32(pending) then return end
|
|
local function will_hide_top_line()
|
|
feed([[<C-\><C-N>]])
|
|
screen:try_resize(screen._width - 2, screen._height - 1)
|
|
screen:expect([[
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
rows: 5, cols: 28 |
|
|
{2:^ } |
|
|
|
|
|
]])
|
|
end
|
|
|
|
it('will hide top line', will_hide_top_line)
|
|
|
|
describe('and then decreased by 2', function()
|
|
before_each(function()
|
|
will_hide_top_line()
|
|
screen:try_resize(screen._width - 2, screen._height - 2)
|
|
end)
|
|
|
|
it('will hide the top 3 lines', function()
|
|
screen:expect([[
|
|
rows: 5, cols: 28 |
|
|
rows: 3, cols: 26 |
|
|
{2:^ } |
|
|
|
|
|
]])
|
|
eq(8, curbuf('line_count'))
|
|
feed([[3k]])
|
|
screen:expect([[
|
|
^line4 |
|
|
rows: 5, cols: 28 |
|
|
rows: 3, cols: 26 |
|
|
|
|
|
]])
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('with empty lines after the cursor', function()
|
|
-- XXX: Can't test this reliably on Windows unless the cursor is _moved_
|
|
-- by the resize. http://docs.libuv.org/en/v1.x/signal.html
|
|
-- See also: https://github.com/rprichard/winpty/issues/110
|
|
if helpers.pending_win32(pending) then return end
|
|
|
|
describe('and the height is decreased by 2', function()
|
|
before_each(function()
|
|
screen:try_resize(screen._width, screen._height - 2)
|
|
end)
|
|
|
|
local function will_delete_last_two_lines()
|
|
screen:expect([[
|
|
tty ready |
|
|
rows: 4, cols: 30 |
|
|
{1: } |
|
|
|
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
eq(4, curbuf('line_count'))
|
|
end
|
|
|
|
it('will delete the last two empty lines', will_delete_last_two_lines)
|
|
|
|
describe('and then decreased by 1', function()
|
|
before_each(function()
|
|
will_delete_last_two_lines()
|
|
screen:try_resize(screen._width, screen._height - 1)
|
|
end)
|
|
|
|
it('will delete the last line and hide the first', function()
|
|
screen:expect([[
|
|
rows: 4, cols: 30 |
|
|
rows: 3, cols: 30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
eq(4, curbuf('line_count'))
|
|
feed('<c-\\><c-n>gg')
|
|
screen:expect([[
|
|
^tty ready |
|
|
rows: 4, cols: 30 |
|
|
rows: 3, cols: 30 |
|
|
|
|
|
]])
|
|
feed('a')
|
|
screen:expect([[
|
|
rows: 4, cols: 30 |
|
|
rows: 3, cols: 30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('with 4 lines hidden in the scrollback', function()
|
|
before_each(function()
|
|
feed_data({'line1', 'line2', 'line3', 'line4', ''})
|
|
screen:expect([[
|
|
tty ready |
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
screen:try_resize(screen._width, screen._height - 3)
|
|
screen:expect([[
|
|
line4 |
|
|
rows: 3, cols: 30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
eq(7, curbuf('line_count'))
|
|
end)
|
|
|
|
describe('and the height is increased by 1', function()
|
|
-- XXX: Can't test this reliably on Windows unless the cursor is _moved_
|
|
-- by the resize. http://docs.libuv.org/en/v1.x/signal.html
|
|
-- See also: https://github.com/rprichard/winpty/issues/110
|
|
if helpers.pending_win32(pending) then return end
|
|
local function pop_then_push()
|
|
screen:try_resize(screen._width, screen._height + 1)
|
|
screen:expect([[
|
|
line4 |
|
|
rows: 3, cols: 30 |
|
|
rows: 4, cols: 30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
end
|
|
|
|
it('will pop 1 line and then push it back', pop_then_push)
|
|
|
|
describe('and then by 3', function()
|
|
before_each(function()
|
|
pop_then_push()
|
|
eq(8, curbuf('line_count'))
|
|
screen:try_resize(screen._width, screen._height + 3)
|
|
end)
|
|
|
|
local function pop3_then_push1()
|
|
screen:expect([[
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
rows: 3, cols: 30 |
|
|
rows: 4, cols: 30 |
|
|
rows: 7, cols: 30 |
|
|
{1: } |
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
eq(9, curbuf('line_count'))
|
|
feed('<c-\\><c-n>gg')
|
|
screen:expect([[
|
|
^tty ready |
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
rows: 3, cols: 30 |
|
|
rows: 4, cols: 30 |
|
|
|
|
|
]])
|
|
end
|
|
|
|
it('will pop 3 lines and then push one back', pop3_then_push1)
|
|
|
|
describe('and then by 4', function()
|
|
before_each(function()
|
|
pop3_then_push1()
|
|
feed('Gi')
|
|
screen:try_resize(screen._width, screen._height + 4)
|
|
end)
|
|
|
|
it('will show all lines and leave a blank one at the end', function()
|
|
screen:expect([[
|
|
tty ready |
|
|
line1 |
|
|
line2 |
|
|
line3 |
|
|
line4 |
|
|
rows: 3, cols: 30 |
|
|
rows: 4, cols: 30 |
|
|
rows: 7, cols: 30 |
|
|
rows: 11, cols: 30 |
|
|
{1: } |
|
|
|
|
|
{3:-- TERMINAL --} |
|
|
]])
|
|
-- since there's an empty line after the cursor, the buffer line
|
|
-- count equals the terminal screen height
|
|
eq(11, curbuf('line_count'))
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe(':terminal prints more lines than the screen height and exits', function()
|
|
it('will push extra lines to scrollback', function()
|
|
if helpers.pending_win32(pending) then return end
|
|
clear()
|
|
local screen = Screen.new(30, 7)
|
|
screen:attach({rgb=false})
|
|
feed_command('call termopen(["'..nvim_dir..'/tty-test", "10"]) | startinsert')
|
|
poke_eventloop()
|
|
screen:expect([[
|
|
line6 |
|
|
line7 |
|
|
line8 |
|
|
line9 |
|
|
|
|
|
[Process exited 0] |
|
|
-- TERMINAL -- |
|
|
]])
|
|
feed('<cr>')
|
|
-- closes the buffer correctly after pressing a key
|
|
screen:expect([[
|
|
^ |
|
|
~ |
|
|
~ |
|
|
~ |
|
|
~ |
|
|
~ |
|
|
|
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
describe("'scrollback' option", function()
|
|
before_each(function()
|
|
clear()
|
|
end)
|
|
|
|
local function set_fake_shell()
|
|
-- shell-test.c is a fake shell that prints its arguments and exits.
|
|
nvim('set_option', 'shell', nvim_dir..'/shell-test')
|
|
nvim('set_option', 'shellcmdflag', 'EXE')
|
|
end
|
|
|
|
local function expect_lines(expected, epsilon)
|
|
local ep = epsilon and epsilon or 0
|
|
local actual = eval("line('$')")
|
|
if expected > actual + ep and expected < actual - ep then
|
|
error('expected (+/- '..ep..'): '..expected..', actual: '..tostring(actual))
|
|
end
|
|
end
|
|
|
|
it('set to 0 behaves as 1', function()
|
|
local screen
|
|
if iswin() then
|
|
screen = thelpers.screen_setup(nil, "['cmd.exe']", 30)
|
|
else
|
|
screen = thelpers.screen_setup(nil, "['sh']", 30)
|
|
end
|
|
|
|
curbufmeths.set_option('scrollback', 0)
|
|
feed_data(nvim_dir..'/shell-test REP 31 line'..(iswin() and '\r' or '\n'))
|
|
screen:expect{any='30: line '}
|
|
retry(nil, nil, function() expect_lines(7) end)
|
|
end)
|
|
|
|
it('deletes lines (only) if necessary', function()
|
|
local screen
|
|
if iswin() then
|
|
command([[let $PROMPT='$$']])
|
|
screen = thelpers.screen_setup(nil, "['cmd.exe']", 30)
|
|
else
|
|
command('let $PS1 = "$"')
|
|
screen = thelpers.screen_setup(nil, "['sh']", 30)
|
|
end
|
|
|
|
curbufmeths.set_option('scrollback', 200)
|
|
|
|
-- Wait for prompt.
|
|
screen:expect{any='%$'}
|
|
|
|
feed_data(nvim_dir.."/shell-test REP 31 line"..(iswin() and '\r' or '\n'))
|
|
screen:expect{any='30: line '}
|
|
|
|
retry(nil, nil, function() expect_lines(33, 2) end)
|
|
curbufmeths.set_option('scrollback', 10)
|
|
poke_eventloop()
|
|
retry(nil, nil, function() expect_lines(16) end)
|
|
curbufmeths.set_option('scrollback', 10000)
|
|
retry(nil, nil, function() expect_lines(16) end)
|
|
-- Terminal job data is received asynchronously, may happen before the
|
|
-- 'scrollback' option is synchronized with the internal sb_buffer.
|
|
command('sleep 100m')
|
|
|
|
feed_data(nvim_dir.."/shell-test REP 41 line"..(iswin() and '\r' or '\n'))
|
|
if iswin() then
|
|
screen:expect{grid=[[
|
|
37: line |
|
|
38: line |
|
|
39: line |
|
|
40: line |
|
|
|
|
|
${1: } |
|
|
{3:-- TERMINAL --} |
|
|
]]}
|
|
else
|
|
screen:expect{grid=[[
|
|
36: line |
|
|
37: line |
|
|
38: line |
|
|
39: line |
|
|
40: line |
|
|
{MATCH:.*}|
|
|
{3:-- TERMINAL --} |
|
|
]]}
|
|
end
|
|
expect_lines(58)
|
|
|
|
-- Verify off-screen state
|
|
matches((iswin() and '^36: line[ ]*$' or '^35: line[ ]*$'), eval("getline(line('w0') - 1)"))
|
|
matches((iswin() and '^27: line[ ]*$' or '^26: line[ ]*$'), eval("getline(line('w0') - 10)"))
|
|
end)
|
|
|
|
it('defaults to 10000 in :terminal buffers', function()
|
|
set_fake_shell()
|
|
command('terminal')
|
|
eq(10000, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
it('error if set to invalid value', function()
|
|
eq('Vim(set):E474: Invalid argument: scrollback=-2',
|
|
pcall_err(command, 'set scrollback=-2'))
|
|
eq('Vim(set):E474: Invalid argument: scrollback=100001',
|
|
pcall_err(command, 'set scrollback=100001'))
|
|
end)
|
|
|
|
it('defaults to -1 on normal buffers', function()
|
|
command('new')
|
|
eq(-1, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
it(':setlocal in a :terminal buffer', function()
|
|
set_fake_shell()
|
|
|
|
-- _Global_ scrollback=-1 defaults :terminal to 10_000.
|
|
command('setglobal scrollback=-1')
|
|
command('terminal')
|
|
eq(10000, curbufmeths.get_option('scrollback'))
|
|
|
|
-- _Local_ scrollback=-1 in :terminal forces the _maximum_.
|
|
command('setlocal scrollback=-1')
|
|
retry(nil, nil, function() -- Fixup happens on refresh, not immediately.
|
|
eq(100000, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
-- _Local_ scrollback=-1 during TermOpen forces the maximum. #9605
|
|
command('setglobal scrollback=-1')
|
|
command('autocmd TermOpen * setlocal scrollback=-1')
|
|
command('terminal')
|
|
eq(100000, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
it(':setlocal in a normal buffer', function()
|
|
command('new')
|
|
-- :setlocal to -1.
|
|
command('setlocal scrollback=-1')
|
|
eq(-1, curbufmeths.get_option('scrollback'))
|
|
-- :setlocal to anything except -1. Currently, this just has no effect.
|
|
command('setlocal scrollback=42')
|
|
eq(42, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
it(':set updates local value and global default', function()
|
|
set_fake_shell()
|
|
command('set scrollback=42') -- set global value
|
|
eq(42, curbufmeths.get_option('scrollback'))
|
|
command('terminal')
|
|
eq(42, curbufmeths.get_option('scrollback')) -- inherits global default
|
|
command('setlocal scrollback=99')
|
|
eq(99, curbufmeths.get_option('scrollback'))
|
|
command('set scrollback<') -- reset to global default
|
|
eq(42, curbufmeths.get_option('scrollback'))
|
|
command('setglobal scrollback=734') -- new global default
|
|
eq(42, curbufmeths.get_option('scrollback')) -- local value did not change
|
|
command('terminal')
|
|
eq(734, curbufmeths.get_option('scrollback'))
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("pending scrollback line handling", function()
|
|
local screen
|
|
|
|
before_each(function()
|
|
clear()
|
|
screen = Screen.new(30, 7)
|
|
screen:attach()
|
|
screen:set_default_attr_ids {
|
|
[1] = {foreground = Screen.colors.Brown},
|
|
[2] = {reverse = true},
|
|
[3] = {bold = true},
|
|
}
|
|
end)
|
|
|
|
it("does not crash after setting 'number' #14891", function()
|
|
exec_lua [[
|
|
local a = vim.api
|
|
local buf = a.nvim_create_buf(true, true)
|
|
local chan = a.nvim_open_term(buf, {})
|
|
a.nvim_win_set_option(0, "number", true)
|
|
a.nvim_chan_send(chan, ("a\n"):rep(11) .. "a")
|
|
a.nvim_win_set_buf(0, buf)
|
|
]]
|
|
screen:expect [[
|
|
{1: 1 }^a |
|
|
{1: 2 } a |
|
|
{1: 3 } a |
|
|
{1: 4 } a |
|
|
{1: 5 } a |
|
|
{1: 6 } a |
|
|
|
|
|
]]
|
|
feed('G')
|
|
screen:expect [[
|
|
{1: 7 } a |
|
|
{1: 8 } a |
|
|
{1: 9 } a |
|
|
{1: 10 } a |
|
|
{1: 11 } a |
|
|
{1: 12 } ^a |
|
|
|
|
|
]]
|
|
assert_alive()
|
|
end)
|
|
|
|
it("does not crash after nvim_buf_call #14891", function()
|
|
if helpers.pending_win32(pending) then return end
|
|
exec_lua [[
|
|
local a = vim.api
|
|
local bufnr = a.nvim_create_buf(false, true)
|
|
a.nvim_buf_call(bufnr, function()
|
|
vim.fn.termopen({"echo", ("hi\n"):rep(11)})
|
|
end)
|
|
a.nvim_win_set_buf(0, bufnr)
|
|
vim.cmd("startinsert")
|
|
]]
|
|
screen:expect [[
|
|
hi |
|
|
hi |
|
|
hi |
|
|
|
|
|
|
|
|
[Process exited 0]{2: } |
|
|
{3:-- TERMINAL --} |
|
|
]]
|
|
assert_alive()
|
|
end)
|
|
end)
|