mirror of
https://github.com/neovim/neovim.git
synced 2026-07-31 20:59:11 +00:00
359459dec6
Problem:
POSIX-compatible Ex-mode requires special-cases all over the codebase to
match various quirks that don't actually matter to users.
- The main utility of *interactive* Ex-mode is its REPL behavior, and
that can be achieved with `cmdwin`, which also gains extra UX
benefits.
- The main utility of *non-interactive* `nvim -es` is for shell
scripting, where Ex-mode quirks are mostly unhelpful (e.g. the
"Entering Ex mode" message).
Solution:
- Reimplement *interactive* Ex-mode as a "persistent, insert-mode
cmdwin" in Lua.
- "nvim -e/-E" is simply an alias to "gQ".
- Reframe *non-interactive* Ex-mode (`nvim -es`) as "script mode".
- Drop POSIX Ex-mode quirks.
Improvements:
- "nvim -V1 -es" output ends with a final newline!
- "nvim -V1 -es" no longer shows the "Entering Ex mode" msg. (This was
pointless noise, unwanted for scripting purposes.)
- stdin is no longer typeahead. Scripts (":lua io.read()") can read
stdin as data.
- Empty line is a no-op: a stray blank line no longer moves the cursor
(deviates from POSIX ex "+1"), no longer exits 1 at EOF (E501).
Preserved behavior:
- cursor starts at "$"
- mode()=="cv" (for non-interactive)
- multiline commands (:append/:function/heredoc pull continuation lines)
- bare-range print
- :print=>stdout
- -V1=>stderr
- CRLF input
- continue-after-error and exit codes
Dropped (regressed) POSIX behavior (non-interactive):
- Event loop only ticks while/between commands, not while blocked
waiting for a stdin line.
- ":g/pat/visual...Q"
- input()/getchar()/":s/x/y/c" no longer consume stdin lines as
answers: Nvim stops at end-of-input, skipping the rest of the script,
exit 0. Use ":lua io.read()" instead.
- If users care about this they should use interactive Ex-mode (`gQ`).
- ":@r" stops at end of the register instead of continuing to read
cmdline input from stdin.
1199 lines
52 KiB
Lua
1199 lines
52 KiB
Lua
local t = require('test.testutil')
|
|
local n = require('test.functional.testnvim')()
|
|
local tt = require('test.functional.testterm')
|
|
|
|
local describe, it, before_each = t.describe, t.it, t.before_each
|
|
local feed, clear = n.feed, n.clear
|
|
local testprg, command = n.testprg, n.command
|
|
local eq, eval = t.eq, n.eval
|
|
local api = n.api
|
|
local exec_lua = n.exec_lua
|
|
local matches = t.matches
|
|
local call = n.call
|
|
local hide_cursor = tt.hide_cursor
|
|
local show_cursor = tt.show_cursor
|
|
local retry = t.retry
|
|
local is_os = t.is_os
|
|
local skip = t.skip
|
|
|
|
describe(':terminal cursor', function()
|
|
local screen
|
|
|
|
local terminal_mode_idx ---@type number
|
|
|
|
before_each(function()
|
|
clear()
|
|
screen = tt.setup_screen()
|
|
|
|
if terminal_mode_idx == nil then
|
|
for i, v in ipairs(screen._mode_info) do
|
|
if v.name == 'terminal' then
|
|
terminal_mode_idx = i
|
|
end
|
|
end
|
|
assert(terminal_mode_idx)
|
|
end
|
|
end)
|
|
|
|
it('moves the screen cursor when focused', function()
|
|
tt.feed_data('testing cursor')
|
|
screen:expect([[
|
|
tty ready |
|
|
testing cursor^ |
|
|
|*4
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
|
|
it('is highlighted when not focused', function()
|
|
feed('<c-\\><c-n>')
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
end)
|
|
|
|
describe('with number column', function()
|
|
before_each(function()
|
|
feed('<c-\\><c-n>:set number<cr>')
|
|
end)
|
|
|
|
it('is positioned correctly when unfocused', function()
|
|
screen:expect([[
|
|
{121: 1 }tty ready |
|
|
{121: 2 }^rows: 6, cols: 46 |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 } |
|
|
:set number |
|
|
]])
|
|
end)
|
|
|
|
it('is positioned correctly when focused', function()
|
|
screen:expect([[
|
|
{121: 1 }tty ready |
|
|
{121: 2 }^rows: 6, cols: 46 |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 } |
|
|
:set number |
|
|
]])
|
|
feed('i')
|
|
n.poke_eventloop()
|
|
screen:expect([[
|
|
{121: 1 }tty ready |
|
|
{121: 2 }rows: 6, cols: 46 |
|
|
{121: 3 }^ |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 } |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
describe('when invisible', function()
|
|
it('is not highlighted', function()
|
|
hide_cursor()
|
|
screen:expect([[
|
|
tty ready |
|
|
|*5
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
show_cursor()
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*4
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
-- same for when the terminal is unfocused
|
|
feed('<c-\\><c-n>')
|
|
hide_cursor()
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
show_cursor()
|
|
screen:expect_unchanged()
|
|
end)
|
|
|
|
it('becomes visible when exiting Terminal mode', function()
|
|
hide_cursor()
|
|
screen:expect([[
|
|
tty ready |
|
|
|*5
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
feed('<c-\\><c-n>')
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
feed('i')
|
|
screen:expect([[
|
|
tty ready |
|
|
|*5
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
|
|
-- Cursor is hidden; now request to show it while in a TermLeave autocmd.
|
|
-- Process events (via :sleep) to handle the escape sequence now.
|
|
n.exec([[
|
|
autocmd TermLeave * ++once call chansend(&channel, "\e[?25h") | sleep 1m
|
|
\ | let g:did_termleave = 1]])
|
|
feed([[<C-\><C-N>]]) -- Exit terminal mode; cursor should not remain hidden
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
-- Wait for the TermLeave autocommand to finish. Sometimes :sleep can be slow.
|
|
retry(nil, 1000, function()
|
|
eq(1, api.nvim_get_var('did_termleave'))
|
|
end)
|
|
|
|
command('bwipeout! | let chan = nvim_open_term(0, {})')
|
|
feed('i')
|
|
-- Hide the cursor, switch to a non-terminal buffer, then show the cursor; it shouldn't remain
|
|
-- hidden after we're kicked out of terminal mode in the new buffer.
|
|
-- Must ensure these actions happen within the same terminal_execute call. The stream is
|
|
-- internal, so polling the event loop isn't necessary (terminal_receive is directly called).
|
|
command([[call chansend(chan, "\e[?25l") | new floob | call chansend(chan, "\e[?25h")]])
|
|
screen:expect([[
|
|
^ |
|
|
{100:~ }|
|
|
{3:floob }|
|
|
|*2
|
|
{119:[Scratch] [-] }|
|
|
|
|
|
]])
|
|
|
|
feed('<C-W>pi')
|
|
screen:expect([[
|
|
|
|
|
{100:~ }|
|
|
{2:floob }|
|
|
^ |
|
|
|
|
|
{120:[Scratch] [-] }|
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
|
|
it('becomes visible on TermLeave if hidden immediately by events #32456', function()
|
|
-- Reproducing the issue is quite fragile; it's easiest done in a lone test case like this
|
|
-- with no prior commands.
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
|
|
-- Hide the cursor such that the escape sequence is processed as a side effect of showmode in
|
|
-- terminal_enter handling events (skip_showmode -> char_avail -> vpeekc -> os_breakcheck).
|
|
-- This requires a particular set of actions; :startinsert repros better than feed('i') here.
|
|
hide_cursor()
|
|
command('mode | startinsert')
|
|
screen:expect([[
|
|
tty ready |
|
|
|*5
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
it('can be modified by application #3681 #31685', function()
|
|
local states = {
|
|
[1] = { blink = true, shape = 'block' },
|
|
[2] = { blink = false, shape = 'block' },
|
|
[3] = { blink = true, shape = 'horizontal' },
|
|
[4] = { blink = false, shape = 'horizontal' },
|
|
[5] = { blink = true, shape = 'vertical' },
|
|
[6] = { blink = false, shape = 'vertical' },
|
|
}
|
|
|
|
for k, v in pairs(states) do
|
|
tt.feed_csi(('%d q'):format(k))
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
^ |
|
|
|*4
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
if v.blink then
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
else
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
end
|
|
|
|
eq(v.shape, screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
|
|
-- Cell percentages are hard coded for each shape in terminal.c
|
|
if v.shape == 'horizontal' then
|
|
eq(20, screen._mode_info[terminal_mode_idx].cell_percentage)
|
|
elseif v.shape == 'vertical' then
|
|
eq(25, screen._mode_info[terminal_mode_idx].cell_percentage)
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
|
|
feed([[<C-\><C-N>]])
|
|
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
|
|
-- Cursor returns to default on TermLeave
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('block', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end)
|
|
|
|
it('can be modified per terminal', function()
|
|
-- Set cursor to vertical bar with blink
|
|
tt.feed_csi('5 q')
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
^ |
|
|
|*4
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('vertical', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end,
|
|
})
|
|
|
|
tt.hide_cursor()
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
|*5
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('vertical', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end,
|
|
})
|
|
|
|
-- Exit terminal mode to reset terminal cursor settings to default and
|
|
-- create a new terminal window
|
|
feed([[<C-\><C-N>]])
|
|
command('set statusline=~~~')
|
|
command('new')
|
|
call('jobstart', { testprg('tty-test') }, { term = true })
|
|
feed('i')
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
^ |
|
|
{120:~~~ }|
|
|
rows: 2, cols: 50 |
|
|
|
|
|
{119:~~~ }|
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
-- New terminal, cursor resets to defaults
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('block', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end,
|
|
})
|
|
|
|
-- Set cursor to underline, no blink
|
|
tt.feed_csi('4 q')
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
^ |
|
|
{120:~~~ }|
|
|
rows: 2, cols: 50 |
|
|
|
|
|
{119:~~~ }|
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('horizontal', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end,
|
|
})
|
|
|
|
-- Switch back to first terminal, cursor should still be hidden
|
|
command('wincmd p')
|
|
screen:expect({
|
|
grid = [[
|
|
tty ready |
|
|
|
|
|
{119:~~~ }|
|
|
rows: 2, cols: 50 |
|
|
|
|
|
{120:~~~ }|
|
|
{5:-- TERMINAL --} |
|
|
]],
|
|
condition = function()
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
eq('vertical', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
end,
|
|
})
|
|
end)
|
|
|
|
it('can be positioned arbitrarily', function()
|
|
clear()
|
|
screen = tt.setup_child_nvim({
|
|
'-u',
|
|
'NONE',
|
|
'-i',
|
|
'NONE',
|
|
'--cmd',
|
|
n.nvim_set .. ' noshowmode',
|
|
})
|
|
screen:expect([[
|
|
^ |
|
|
~ |*4
|
|
|
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
|
|
feed('i<Tab>')
|
|
screen:expect([[
|
|
^ |
|
|
~ |*4
|
|
|
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
end)
|
|
|
|
it('preserves guicursor value on TermLeave #31612', function()
|
|
eq(3, screen._mode_info[terminal_mode_idx].hl_id)
|
|
|
|
-- Change 'guicursor' while terminal mode is active
|
|
command('set guicursor+=t:Error')
|
|
|
|
local error_hl_id = call('hlID', 'Error')
|
|
|
|
screen:expect({
|
|
condition = function()
|
|
eq(error_hl_id, screen._mode_info[terminal_mode_idx].hl_id)
|
|
end,
|
|
})
|
|
|
|
-- Exit terminal mode
|
|
feed([[<C-\><C-N>]])
|
|
|
|
screen:expect([[
|
|
tty ready |
|
|
^ |
|
|
|*5
|
|
]])
|
|
|
|
eq(error_hl_id, screen._mode_info[terminal_mode_idx].hl_id)
|
|
end)
|
|
|
|
it('uses the correct attributes', function()
|
|
feed([[<C-\><C-N>]])
|
|
command([[
|
|
bwipeout!
|
|
let chan1 = nvim_open_term(0, {})
|
|
vnew
|
|
let chan2 = nvim_open_term(0, {})
|
|
]])
|
|
feed('i')
|
|
local s0 = [[
|
|
^ │ |
|
|
│ |*4
|
|
{120:[Scratch] [-] }{119:[Scratch] [-] }|
|
|
{5:-- TERMINAL --} |
|
|
]]
|
|
screen:expect(s0)
|
|
eq('block', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
|
|
-- Modify cursor in the non-current terminal; should not affect this cursor.
|
|
command([[call chansend(chan1, "\e[4 q")]])
|
|
screen:expect({
|
|
grid = s0,
|
|
unchanged = true,
|
|
condition = function()
|
|
eq('block', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(500, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
end,
|
|
})
|
|
|
|
-- Modify cursor in the current terminal.
|
|
command([[call chansend(chan2, "\e[6 q")]])
|
|
screen:expect({
|
|
grid = s0,
|
|
condition = function()
|
|
eq('vertical', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
end,
|
|
})
|
|
|
|
-- Check the cursor in the other terminal reflects our changes from before.
|
|
command('wincmd p')
|
|
screen:expect([[
|
|
│^ |
|
|
│ |*4
|
|
{119:[Scratch] [-] }{120:[Scratch] [-] }|
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq('horizontal', screen._mode_info[terminal_mode_idx].cursor_shape)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkon)
|
|
eq(0, screen._mode_info[terminal_mode_idx].blinkoff)
|
|
end)
|
|
|
|
it('position correct within events', function()
|
|
local term, term_unfocused = exec_lua(function()
|
|
vim.cmd 'bwipeout!'
|
|
local term_unfocused = vim.api.nvim_open_term(0, {})
|
|
vim.cmd.vnew()
|
|
vim.cmd.wincmd '|'
|
|
local term = vim.api.nvim_open_term(0, {})
|
|
-- We'll use this keymap to pause the main loop while we send events, as we want the test to
|
|
-- run within the same terminal_execute call (while using test suite facilities like retry).
|
|
vim.keymap.set('t', '<F1>', '<Cmd>let g:sleepy = 1 | sleep 5000 | let g:sleepy = 0<CR>')
|
|
return term, term_unfocused
|
|
end)
|
|
feed('i<F1>')
|
|
|
|
local function check_pos(expected_pos, expected_virtcol, chan, data)
|
|
api.nvim_chan_send(chan, data) -- Using nvim_chan_send so terminal_receive is immediate.
|
|
|
|
-- Results won't be visible until refresh_terminal is called, which happens on a timer.
|
|
retry(nil, nil, function()
|
|
eq(expected_pos, eval("getpos('.')[1:]"))
|
|
end)
|
|
eq(expected_virtcol, eval("virtcol('.', 1)"))
|
|
eq(1, eval('g:sleepy')) -- :sleep shouldn't have timed out.
|
|
end
|
|
|
|
check_pos({ 1, 4, 0 }, { 4, 4 }, term, 'foo')
|
|
-- double-width char at end (3 bytes)
|
|
check_pos({ 2, 13, 0 }, { 12, 12 }, term, '\r\nbarbaaaar哦')
|
|
-- Move to 1,12 (beyond eol; sets coladd)
|
|
check_pos({ 1, 4, 8 }, { 12, 12 }, term, '\27[1;12H')
|
|
-- Move to 4,1
|
|
check_pos({ 4, 1, 0 }, { 1, 1 }, term, '\27[4;1H')
|
|
-- Move to 4,5 (beyond eol; sets coladd)
|
|
check_pos({ 4, 1, 4 }, { 5, 5 }, term, '\27[4;5H')
|
|
-- Move to 2,10 (head of wide char)
|
|
check_pos({ 2, 10, 0 }, { 10, 11 }, term, '\27[2;10H')
|
|
-- Move to 2,11 (non-head of wide char)
|
|
check_pos({ 2, 10, 0 }, { 10, 11 }, term, '\27[2;11H')
|
|
-- Move to 2,12 (after wide char)
|
|
check_pos({ 2, 13, 0 }, { 12, 12 }, term, '\27[2;12H')
|
|
-- Move to 2,13 (beyond eol; sets coladd)
|
|
check_pos({ 2, 13, 1 }, { 13, 13 }, term, '\27[2;13H')
|
|
-- Cursor movement in unfocused terminal shouldn't affect us
|
|
check_pos({ 2, 13, 1 }, { 13, 13 }, term_unfocused, 'amogus')
|
|
end)
|
|
end)
|
|
|
|
describe('buffer cursor position is correct in terminal without number column', function()
|
|
local screen
|
|
|
|
local function setup_register_and_prompt(str, prompt)
|
|
prompt = ':' .. (prompt or '')
|
|
screen = tt.setup_child_nvim({
|
|
'-u',
|
|
'NONE',
|
|
'-i',
|
|
'NONE',
|
|
'--cmd',
|
|
string.format('let @r = "%s"', str),
|
|
-- <Left> and <Right> don't always work
|
|
'--cmd',
|
|
'cnoremap <C-X> <Left>',
|
|
'--cmd',
|
|
'cnoremap <C-O> <Right>',
|
|
'--cmd',
|
|
'set notermguicolors',
|
|
-- A blocked cmdline prompt at the last row, as a stable text-entry to test cursor tracking.
|
|
('+call input("%s")'):format(prompt),
|
|
}, {
|
|
cols = 70,
|
|
})
|
|
screen:expect(([[
|
|
|*5
|
|
%s^%s|
|
|
{5:-- TERMINAL --} |
|
|
]]):format(prompt, (' '):rep(70 - #prompt)))
|
|
end
|
|
|
|
before_each(function()
|
|
clear()
|
|
command('autocmd! nvim.terminal TermOpen')
|
|
end)
|
|
|
|
describe('in a line with no multibyte chars or trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('aaaaaaaa')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
|*5
|
|
:aaaaaaaa^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 9 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:aaaaaaa^a |
|
|
|
|
|
]])
|
|
eq({ 6, 8 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
|*5
|
|
:aaaaaa^aa |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 7 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:aaaaa^aaa |
|
|
|
|
|
]])
|
|
eq({ 6, 6 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
|*5
|
|
:a^aaaaaaa |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 2 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:^aaaaaaaa |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with single-cell multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('µµµµµµµµ')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
|*5
|
|
:µµµµµµµµ^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 17 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:µµµµµµµ^µ |
|
|
|
|
|
]])
|
|
eq({ 6, 15 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
|*5
|
|
:µµµµµµ^µµ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 13 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:µµµµµ^µµµ |
|
|
|
|
|
]])
|
|
eq({ 6, 11 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
|*5
|
|
:µ^µµµµµµµ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 3 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:^µµµµµµµµ |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with single-cell composed multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
|*5
|
|
:µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 33 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:µ̳µ̳µ̳µ̳µ̳µ̳µ̳^µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 29 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
skip(is_os('win'))
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
|*5
|
|
:µ̳µ̳µ̳µ̳µ̳µ̳^µ̳µ̳ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 25 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:µ̳µ̳µ̳µ̳µ̳^µ̳µ̳µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 21 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
skip(is_os('win'))
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
|*5
|
|
:µ̳^µ̳µ̳µ̳µ̳µ̳µ̳µ̳ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 5 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:^µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with double-cell multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('哦哦哦哦哦哦哦哦')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
|*5
|
|
:哦哦哦哦哦哦哦哦^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 25 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:哦哦哦哦哦哦哦^哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 22 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
|*5
|
|
:哦哦哦哦哦哦^哦哦 |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 19 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:哦哦哦哦哦^哦哦哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 16 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
|*5
|
|
:哦^哦哦哦哦哦哦哦 |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 4 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
|*5
|
|
:^哦哦哦哦哦哦哦哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
it('at the end of a line with trailing spaces #16234', function()
|
|
-- Use the raw tty-test child: it echoes input verbatim, so the trailing spaces are real
|
|
-- terminal cells (a cmdline/TUI child never emits trailing blank cells).
|
|
screen = tt.setup_screen(nil, nil, 70)
|
|
tt.feed_data('aaaaaaaa ')
|
|
screen:expect([[
|
|
tty ready |
|
|
aaaaaaaa ^ |
|
|
|*4
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
matches('^aaaaaaaa [ ]*$', eval('nvim_get_current_line()'))
|
|
eq({ 2, 12 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
eq({ 2, 11 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('buffer cursor position is correct in terminal with number column', function()
|
|
local screen
|
|
|
|
local function setup_register_and_prompt(str, prompt)
|
|
prompt = ':' .. (prompt or '')
|
|
screen = tt.setup_child_nvim({
|
|
'-u',
|
|
'NONE',
|
|
'-i',
|
|
'NONE',
|
|
'--cmd',
|
|
string.format('let @r = "%s"', str),
|
|
-- <Left> and <Right> don't always work
|
|
'--cmd',
|
|
'cnoremap <C-X> <Left>',
|
|
'--cmd',
|
|
'cnoremap <C-O> <Right>',
|
|
'--cmd',
|
|
'set notermguicolors',
|
|
-- A blocked cmdline prompt at the last row, as a stable text-entry to test cursor tracking.
|
|
('+call input("%s")'):format(prompt),
|
|
}, {
|
|
cols = 70,
|
|
})
|
|
screen:expect(([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }%s^%s|
|
|
{5:-- TERMINAL --} |
|
|
]]):format(prompt, (' '):rep(66 - #prompt)))
|
|
end
|
|
|
|
before_each(function()
|
|
clear()
|
|
command('autocmd! nvim.terminal TermOpen')
|
|
-- 'number' should be set before the terminal process starts, otherwise the resize
|
|
-- from setting 'number' may cause a redraw that changes the child screen.
|
|
command('set number')
|
|
end)
|
|
|
|
describe('in a line with no multibyte chars or trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('aaaaaaaa')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:aaaaaaaa^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 9 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:aaaaaaa^a |
|
|
|
|
|
]])
|
|
eq({ 6, 8 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:aaaaaa^aa |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 7 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:aaaaa^aaa |
|
|
|
|
|
]])
|
|
eq({ 6, 6 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:a^aaaaaaa |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 2 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:^aaaaaaaa |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with single-cell multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('µµµµµµµµ')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µµµµµµµµ^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 17 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µµµµµµµ^µ |
|
|
|
|
|
]])
|
|
eq({ 6, 15 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µµµµµµ^µµ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 13 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µµµµµ^µµµ |
|
|
|
|
|
]])
|
|
eq({ 6, 11 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ^µµµµµµµ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 3 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:^µµµµµµµµ |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with single-cell composed multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 33 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ̳µ̳µ̳µ̳µ̳µ̳µ̳^µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 29 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
skip(is_os('win'))
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ̳µ̳µ̳µ̳µ̳µ̳^µ̳µ̳ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 25 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ̳µ̳µ̳µ̳µ̳^µ̳µ̳µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 21 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
skip(is_os('win'))
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:µ̳^µ̳µ̳µ̳µ̳µ̳µ̳µ̳ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 5 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:^µ̳µ̳µ̳µ̳µ̳µ̳µ̳µ̳ |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
describe('in a line with double-cell multibyte chars and no trailing spaces,', function()
|
|
before_each(function()
|
|
setup_register_and_prompt('哦哦哦哦哦哦哦哦')
|
|
end)
|
|
|
|
it('at the end', function()
|
|
feed('<C-R>r')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:哦哦哦哦哦哦哦哦^ |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 25 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:哦哦哦哦哦哦哦^哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 22 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the end', function()
|
|
feed('<C-R>r<C-X><C-X>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:哦哦哦哦哦哦^哦哦 |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 19 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:哦哦哦哦哦^哦哦哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 16 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
|
|
it('near the start', function()
|
|
feed('<C-R>r<C-B><C-O>')
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:哦^哦哦哦哦哦哦哦 |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
eq({ 6, 4 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
screen:expect([[
|
|
{121: 1 } |
|
|
{121: 2 } |
|
|
{121: 3 } |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 }:^哦哦哦哦哦哦哦哦 |
|
|
|
|
|
]])
|
|
eq({ 6, 1 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|
|
|
|
it('at the end of a line with trailing spaces #16234', function()
|
|
-- Raw tty-test child: trailing spaces are real terminal cells. See the no-number variant.
|
|
-- 'number' is set after the terminal opens: setup_screen() asserts the default layout.
|
|
command('set nonumber')
|
|
screen = tt.setup_screen(nil, nil, 70)
|
|
command('set number')
|
|
screen:expect({ any = 'rows: 6, cols: 66' })
|
|
tt.feed_data('aaaaaaaa ')
|
|
screen:expect([[
|
|
{121: 1 }tty ready |
|
|
{121: 2 }rows: 6, cols: 66 |
|
|
{121: 3 }aaaaaaaa ^ |
|
|
{121: 4 } |
|
|
{121: 5 } |
|
|
{121: 6 } |
|
|
{5:-- TERMINAL --} |
|
|
]])
|
|
matches('^aaaaaaaa [ ]*$', eval('nvim_get_current_line()'))
|
|
eq({ 3, 12 }, eval('nvim_win_get_cursor(0)'))
|
|
feed([[<C-\><C-N>]])
|
|
eq({ 3, 11 }, eval('nvim_win_get_cursor(0)'))
|
|
end)
|
|
end)
|