neovim/test/functional/ui/cmdline_spec.lua
Luuk van Baal 037ea6e786 feat(api): add nvim__redraw for more granular redrawing
Experimental and subject to future changes.
Add a way to redraw certain elements that are not redrawn while Nvim is waiting
for input, or currently have no API to do so. This API covers all that can be
done with the :redraw* commands, in addition to the following new features:
- Immediately move the cursor to a (non-current) window.
- Target a specific window or buffer to mark for redraw.
- Mark a buffer range for redraw (replaces nvim__buf_redraw_range()).
- Redraw the 'statuscolumn'.
2024-05-02 15:57:06 +02:00

1732 lines
41 KiB
Lua

local t = require('test.testutil')
local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')
local clear, feed = n.clear, n.feed
local source = n.source
local command = n.command
local assert_alive = n.assert_alive
local poke_eventloop = n.poke_eventloop
local exec = n.exec
local eval = n.eval
local eq = t.eq
local is_os = t.is_os
local api = n.api
local function new_screen(opt)
local screen = Screen.new(25, 5)
screen:attach(opt)
screen:set_default_attr_ids({
[1] = { bold = true, foreground = Screen.colors.Blue1 },
[2] = { reverse = true },
[3] = { bold = true, reverse = true },
[4] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
[5] = { bold = true, foreground = Screen.colors.SeaGreen4 },
[6] = { foreground = Screen.colors.Magenta },
[7] = { bold = true, foreground = Screen.colors.Brown },
[8] = { foreground = Screen.colors.Black, background = Screen.colors.LightGrey },
[9] = { bold = true },
[10] = { background = Screen.colors.Yellow1 },
})
return screen
end
local function test_cmdline(linegrid)
local screen
before_each(function()
clear()
screen = new_screen({ rgb = true, ext_cmdline = true, ext_linegrid = linegrid })
end)
it('works', function()
feed(':')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = { {
firstc = ':',
content = { { '' } },
pos = 0,
} },
}
feed('sign')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign' } },
pos = 4,
},
},
}
feed('<Left>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign' } },
pos = 3,
},
},
}
feed('<bs>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sin' } },
pos = 2,
},
},
}
feed('<Esc>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
end)
it('works with input()', function()
feed(':call input("input", "default")<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
prompt = 'input',
content = { { 'default' } },
pos = 7,
},
},
}
feed('<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
end)
it('works with special chars and nested cmdline', function()
feed(':xx<c-r>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'xx' } },
pos = 2,
special = { '"', true },
},
},
}
feed('=')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'xx' } },
pos = 2,
special = { '"', true },
},
{
firstc = '=',
content = { { '' } },
pos = 0,
},
},
}
feed('1+2')
local expectation = {
{
firstc = ':',
content = { { 'xx' } },
pos = 2,
special = { '"', true },
},
{
firstc = '=',
content = { { '1', 6 }, { '+', 7 }, { '2', 6 } },
pos = 3,
},
}
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = expectation,
}
-- erase information, so we check if it is retransmitted
command('mode')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = expectation,
reset = true,
}
feed('<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'xx3' } },
pos = 3,
},
},
}
feed('<esc>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
end)
it('works with function definitions', function()
feed(':function Foo()<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
indent = 2,
firstc = ':',
content = { { '' } },
pos = 0,
},
},
cmdline_block = {
{ { 'function Foo()' } },
},
}
feed('line1<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
indent = 2,
firstc = ':',
content = { { '' } },
pos = 0,
},
},
cmdline_block = {
{ { 'function Foo()' } },
{ { ' line1' } },
},
}
command('mode')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
indent = 2,
firstc = ':',
content = { { '' } },
pos = 0,
},
},
cmdline_block = {
{ { 'function Foo()' } },
{ { ' line1' } },
},
reset = true,
}
feed('endfunction<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
-- Try once more, to check buffer is reinitialized. #8007
feed(':function Bar()<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
indent = 2,
firstc = ':',
content = { { '' } },
pos = 0,
},
},
cmdline_block = {
{ { 'function Bar()' } },
},
}
feed('endfunction<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
end)
it('works with cmdline window', function()
feed(':make')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'make' } },
pos = 4,
},
},
}
feed('<c-f>')
screen:expect {
grid = [[
|
{2:[No Name] }|
{1::}make^ |
{3:[Command Line] }|
|
]],
}
-- nested cmdline
feed(':yank')
screen:expect {
grid = [[
|
{2:[No Name] }|
{1::}make^ |
{3:[Command Line] }|
|
]],
cmdline = {
nil,
{
firstc = ':',
content = { { 'yank' } },
pos = 4,
},
},
}
command('mode')
screen:expect {
grid = [[
|
{2:[No Name] }|
{1::}make^ |
{3:[Command Line] }|
|
]],
cmdline = {
nil,
{
firstc = ':',
content = { { 'yank' } },
pos = 4,
},
},
reset = true,
}
feed('<c-c>')
screen:expect {
grid = [[
|
{2:[No Name] }|
{1::}make^ |
{3:[Command Line] }|
|
]],
}
feed('<c-c>')
screen:expect {
grid = [[
^ |
{2:[No Name] }|
{1::}make |
{3:[Command Line] }|
|
]],
cmdline = {
{
firstc = ':',
content = { { 'make' } },
pos = 4,
},
},
}
command('redraw!')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'make' } },
pos = 4,
},
},
}
end)
it('works with inputsecret()', function()
feed(":call inputsecret('secret:')<cr>abc123")
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
prompt = 'secret:',
content = { { '******' } },
pos = 6,
},
},
}
end)
it('works with highlighted cmdline', function()
source([[
highlight RBP1 guibg=Red
highlight RBP2 guibg=Yellow
highlight RBP3 guibg=Green
highlight RBP4 guibg=Blue
let g:NUM_LVLS = 4
function RainBowParens(cmdline)
let ret = []
let i = 0
let lvl = 0
while i < len(a:cmdline)
if a:cmdline[i] is# '('
call add(ret, [i, i + 1, 'RBP' . ((lvl % g:NUM_LVLS) + 1)])
let lvl += 1
elseif a:cmdline[i] is# ')'
let lvl -= 1
call add(ret, [i, i + 1, 'RBP' . ((lvl % g:NUM_LVLS) + 1)])
endif
let i += 1
endwhile
return ret
endfunction
map <f5> :let x = input({'prompt':'>','highlight':'RainBowParens'})<cr>
"map <f5> :let x = input({'prompt':'>'})<cr>
]])
screen:set_default_attr_ids({
RBP1 = { background = Screen.colors.Red },
RBP2 = { background = Screen.colors.Yellow },
EOB = { bold = true, foreground = Screen.colors.Blue1 },
})
feed('<f5>(a(b)a)')
screen:expect {
grid = [[
^ |
{EOB:~ }|*3
|
]],
cmdline = {
{
prompt = '>',
content = {
{ '(', 'RBP1' },
{ 'a' },
{ '(', 'RBP2' },
{ 'b' },
{ ')', 'RBP2' },
{ 'a' },
{ ')', 'RBP1' },
},
pos = 7,
},
},
}
end)
it('works together with ext_wildmenu', function()
local expected = {
'define',
'jump',
'list',
'place',
'undefine',
'unplace',
}
command('set wildmode=full')
command('set wildmenu')
screen:set_option('ext_wildmenu', true)
feed(':sign <tab>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign define' } },
pos = 11,
},
},
wildmenu_items = expected,
wildmenu_pos = 0,
}
feed('<tab>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign jump' } },
pos = 9,
},
},
wildmenu_items = expected,
wildmenu_pos = 1,
}
feed('<left><left>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign ' } },
pos = 5,
},
},
wildmenu_items = expected,
wildmenu_pos = -1,
}
feed('<right>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign define' } },
pos = 11,
},
},
wildmenu_items = expected,
wildmenu_pos = 0,
}
feed('a')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign definea' } },
pos = 12,
},
},
}
end)
it('works together with ext_popupmenu', function()
local expected = {
{ 'define', '', '', '' },
{ 'jump', '', '', '' },
{ 'list', '', '', '' },
{ 'place', '', '', '' },
{ 'undefine', '', '', '' },
{ 'unplace', '', '', '' },
}
command('set wildmode=full')
command('set wildmenu')
screen:set_option('ext_popupmenu', true)
feed(':sign <tab>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign define' } },
pos = 11,
},
},
popupmenu = { items = expected, pos = 0, anchor = { -1, 0, 5 } },
}
feed('<tab>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign jump' } },
pos = 9,
},
},
popupmenu = { items = expected, pos = 1, anchor = { -1, 0, 5 } },
}
feed('<left><left>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign ' } },
pos = 5,
},
},
popupmenu = { items = expected, pos = -1, anchor = { -1, 0, 5 } },
}
feed('<right>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign define' } },
pos = 11,
},
},
popupmenu = { items = expected, pos = 0, anchor = { -1, 0, 5 } },
}
feed('a')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign definea' } },
pos = 12,
},
},
}
feed('<esc>')
-- check positioning with multibyte char in pattern
command('e långfile1')
command('sp långfile2')
feed(':b lå<tab>')
screen:expect {
grid = [[
^ |
{3:långfile2 }|
|
{2:långfile1 }|
|
]],
popupmenu = {
anchor = { -1, 0, 2 },
items = { { 'långfile1', '', '', '' }, { 'långfile2', '', '', '' } },
pos = 0,
},
cmdline = {
{
content = { { 'b långfile1' } },
firstc = ':',
pos = 12,
},
},
}
end)
it('ext_wildmenu takes precedence over ext_popupmenu', function()
local expected = {
'define',
'jump',
'list',
'place',
'undefine',
'unplace',
}
command('set wildmode=full')
command('set wildmenu')
screen:set_option('ext_wildmenu', true)
screen:set_option('ext_popupmenu', true)
feed(':sign <tab>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
firstc = ':',
content = { { 'sign define' } },
pos = 11,
},
},
wildmenu_items = expected,
wildmenu_pos = 0,
}
end)
it("doesn't send invalid events when aborting mapping #10000", function()
command('set notimeout')
command('cnoremap ab c')
feed(':xa')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
cmdline = {
{
content = { { 'x' } },
firstc = ':',
pos = 1,
special = { 'a', false },
},
},
}
-- This used to send an invalid event where pos where larger than the total
-- length of content. Checked in _handle_cmdline_show.
feed('<esc>')
screen:expect([[
^ |
{1:~ }|*3
|
]])
end)
it('does not move cursor to curwin #20309', function()
local win = api.nvim_get_current_win()
command('norm icmdlinewin')
command('new')
command('norm icurwin')
feed(':')
api.nvim_win_set_cursor(win, { 1, 7 })
api.nvim__redraw({ win = win, cursor = true })
screen:expect {
grid = [[
curwin |
{3:[No Name] [+] }|
cmdline^win |
{2:[No Name] [+] }|
|
]],
cmdline = { {
content = { { '' } },
firstc = ':',
pos = 0,
} },
}
end)
end
-- the representation of cmdline and cmdline_block contents changed with ext_linegrid
-- (which uses indexed highlights) so make sure to test both
describe('ui/ext_cmdline', function()
test_cmdline(true)
end)
describe('ui/ext_cmdline (legacy highlights)', function()
test_cmdline(false)
end)
describe('cmdline redraw', function()
local screen
before_each(function()
clear()
screen = new_screen({ rgb = true })
end)
it('with timer', function()
feed(':012345678901234567890123456789')
screen:expect {
grid = [[
|
{1:~ }|
{3: }|
:012345678901234567890123|
456789^ |
]],
}
command('call timer_start(0, {-> 1})')
screen:expect {
grid = [[
|
{1:~ }|
{3: }|
:012345678901234567890123|
456789^ |
]],
unchanged = true,
timeout = 100,
}
end)
it('with <Cmd>', function()
if is_os('bsd') then
pending('FIXME #10804')
end
command('cmap a <Cmd>call sin(0)<CR>') -- no-op
feed(':012345678901234567890123456789')
screen:expect {
grid = [[
|
{1:~ }|
{3: }|
:012345678901234567890123|
456789^ |
]],
}
feed('a')
screen:expect {
grid = [[
|
{1:~ }|
{3: }|
:012345678901234567890123|
456789^ |
]],
unchanged = true,
}
end)
it('after pressing Ctrl-C in cmdwin in Visual mode #18967', function()
screen:try_resize(40, 10)
command('set cmdwinheight=3')
feed('q:iabc<Esc>vhh')
screen:expect([[
|
{1:~ }|*3
{2:[No Name] }|
{1::}^a{8:bc} |
{1:~ }|*2
{3:[Command Line] }|
{9:-- VISUAL --} |
]])
feed('<C-C>')
screen:expect([[
|
{1:~ }|*3
{2:[No Name] }|
{1::}a{8:bc} |
{1:~ }|*2
{3:[Command Line] }|
:^abc |
]])
end)
it('with rightleftcmd', function()
command('set rightleft rightleftcmd=search shortmess+=s')
api.nvim_buf_set_lines(0, 0, -1, true, { "let's rock!" })
screen:expect {
grid = [[
!kcor s'te^l|
{1: ~}|*3
|
]],
}
feed '/'
screen:expect {
grid = [[
!kcor s'tel|
{1: ~}|*3
^ /|
]],
}
feed "let's"
-- note: cursor looks off but looks alright in real use
-- when rendered as a block so it touches the end of the text
screen:expect {
grid = [[
!kcor {2:s'tel}|
{1: ~}|*3
^ s'tel/|
]],
}
-- cursor movement
feed '<space>'
screen:expect {
grid = [[
!kcor{2: s'tel}|
{1: ~}|*3
^ s'tel/|
]],
}
feed 'rock'
screen:expect {
grid = [[
!{2:kcor s'tel}|
{1: ~}|*3
^ kcor s'tel/|
]],
}
feed '<right>'
screen:expect {
grid = [[
!{2:kcor s'tel}|
{1: ~}|*3
^kcor s'tel/|
]],
}
feed '<left>'
screen:expect {
grid = [[
!{2:kcor s'tel}|
{1: ~}|*3
^ kcor s'tel/|
]],
}
feed '<cr>'
screen:expect {
grid = [[
!{10:kcor s'te^l}|
{1: ~}|*3
kcor s'tel/ |
]],
}
end)
end)
describe('statusline is redrawn on entering cmdline', function()
local screen
before_each(function()
clear()
screen = new_screen()
command('set laststatus=2')
end)
it('from normal mode', function()
command('set statusline=%{mode()}')
screen:expect {
grid = [[
^ |
{1:~ }|*2
{3:n }|
|
]],
}
feed(':')
screen:expect {
grid = [[
|
{1:~ }|*2
{3:c }|
:^ |
]],
}
end)
it('from normal mode when : is mapped', function()
command('set statusline=%{mode()}')
command('nnoremap ; :')
screen:expect {
grid = [[
^ |
{1:~ }|*2
{3:n }|
|
]],
}
feed(';')
screen:expect {
grid = [[
|
{1:~ }|*2
{3:c }|
:^ |
]],
}
end)
it('with scrolled messages', function()
screen:try_resize(35, 14)
exec([[
let g:count = 0
autocmd CmdlineEnter * let g:count += 1
split
resize 1
setlocal statusline=%{mode()}%{g:count}
setlocal winbar=%{mode()}%{g:count}
]])
feed(':echoerr doesnotexist<cr>')
screen:expect {
grid = [[
{9:c1 }|
|
{3:c1 }|
|
{1:~ }|*5
{3: }|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{5:inue}^ |
]],
}
feed(':echoerr doesnotexist<cr>')
screen:expect {
grid = [[
{9:c2 }|
|
{3:c2 }|
|
{1:~ }|*2
{3: }|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{5:inue}^ |
]],
}
feed(':echoerr doesnotexist<cr>')
screen:expect {
grid = [[
{9:c3 }|
|
{3:c3 }|
{3: }|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{4:E121: Undefined variable: doesnotex}|
{4:ist} |
{5:Press ENTER or type command to cont}|
{5:inue}^ |
]],
}
feed('<cr>')
screen:expect {
grid = [[
{9:n3 }|
^ |
{3:n3 }|
|
{1:~ }|*8
{2:[No Name] }|
|
]],
}
end)
describe('if custom statusline is set by', function()
before_each(function()
command('set statusline=')
screen:expect {
grid = [[
^ |
{1:~ }|*2
{3:[No Name] }|
|
]],
}
end)
it('CmdlineEnter autocommand', function()
command('autocmd CmdlineEnter * set statusline=command')
feed(':')
screen:expect {
grid = [[
|
{1:~ }|*2
{3:command }|
:^ |
]],
}
end)
it('ModeChanged autocommand', function()
command('autocmd ModeChanged *:c set statusline=command')
feed(':')
screen:expect {
grid = [[
|
{1:~ }|*2
{3:command }|
:^ |
]],
}
end)
end)
end)
it('tabline is not redrawn in Ex mode #24122', function()
clear()
local screen = Screen.new(60, 5)
screen:set_default_attr_ids({
[0] = { bold = true, foreground = Screen.colors.Blue }, -- NonText
[1] = { bold = true, reverse = true }, -- MsgSeparator
[2] = { reverse = true }, -- TabLineFill
})
screen:attach()
exec([[
set showtabline=2
set tabline=%!MyTabLine()
function! MyTabLine()
return "foo"
endfunction
]])
feed('gQ')
screen:expect {
grid = [[
{2:foo }|
|
{1: }|
Entering Ex mode. Type "visual" to go to Normal mode. |
:^ |
]],
}
feed('echo 1<CR>')
screen:expect {
grid = [[
{1: }|
Entering Ex mode. Type "visual" to go to Normal mode. |
:echo 1 |
1 |
:^ |
]],
}
end)
describe('cmdline height', function()
before_each(clear)
it('does not crash resized screen #14263', function()
local screen = Screen.new(25, 10)
screen:attach()
command('set cmdheight=9999')
screen:try_resize(25, 5)
assert_alive()
end)
it('unchanged when restoring window sizes with global statusline', function()
command('set cmdheight=2 laststatus=2')
feed('q:')
command('set cmdheight=1 laststatus=3 | quit')
-- Available lines changed, so closing cmdwin should skip restoring window sizes, leaving the
-- cmdheight unchanged.
eq(1, eval('&cmdheight'))
end)
end)
describe('cmdheight=0', function()
local screen
before_each(function()
clear()
screen = Screen.new(25, 5)
screen:attach()
end)
it('with redrawdebug=invalid resize -1', function()
command('set redrawdebug=invalid cmdheight=0 noruler laststatus=0')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
}
feed(':resize -1<CR>')
screen:expect {
grid = [[
^ |
{1:~ }|*3
|
]],
}
assert_alive()
end)
it('with cmdheight=1 noruler laststatus=2', function()
command('set cmdheight=1 noruler laststatus=2')
screen:expect {
grid = [[
^ |
{1:~ }|*2
{3:[No Name] }|
|
]],
}
end)
it('with cmdheight=0 noruler laststatus=2', function()
command('set cmdheight=0 noruler laststatus=2')
screen:expect {
grid = [[
^ |
{1:~ }|*3
{3:[No Name] }|
]],
}
end)
it('with cmdheight=0 ruler laststatus=0', function()
command('set cmdheight=0 ruler laststatus=0')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
}
end)
it('with cmdheight=0 ruler laststatus=0', function()
command('set cmdheight=0 noruler laststatus=0 showmode')
feed('i')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
showmode = {},
}
feed('<Esc>')
eq(0, eval('&cmdheight'))
end)
it('with cmdheight=0 ruler rulerformat laststatus=0', function()
command('set cmdheight=0 noruler laststatus=0 rulerformat=%l,%c%= showmode')
feed('i')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
showmode = {},
}
feed('<Esc>')
eq(0, eval('&cmdheight'))
end)
it('with showmode', function()
command('set cmdheight=1 noruler laststatus=0 showmode')
feed('i')
screen:expect {
grid = [[
^ |
{1:~ }|*3
{5:-- INSERT --} |
]],
}
feed('<Esc>')
eq(1, eval('&cmdheight'))
end)
it('when using command line', function()
command('set cmdheight=0 noruler laststatus=0')
feed(':')
screen:expect {
grid = [[
|
{1:~ }|*3
:^ |
]],
}
eq(0, eval('&cmdheight'))
feed('<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
showmode = {},
}
eq(0, eval('&cmdheight'))
end)
it('when using input()', function()
command('set cmdheight=0 noruler laststatus=0')
feed(':call input("foo >")<cr>')
screen:expect {
grid = [[
|
{1:~ }|
{3: }|
:call input("foo >") |
foo >^ |
]],
}
eq(0, eval('&cmdheight'))
feed('<cr>')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
showmode = {},
}
eq(0, eval('&cmdheight'))
end)
it('with winbar and splits', function()
command('set cmdheight=0 noruler laststatus=3 winbar=foo')
feed(':split<CR>')
screen:expect {
grid = [[
{3: }|
:split |
{9:E36: Not enough room} |
{6:Press ENTER or type comma}|
{6:nd to continue}^ |
]],
}
feed('<CR>')
screen:expect {
grid = [[
{5:foo }|
^ |
{1:~ }|*2
{3:[No Name] }|
]],
}
feed(':')
screen:expect {
grid = [[
{5:foo }|
|
{1:~ }|*2
:^ |
]],
}
feed('<Esc>')
screen:expect {
grid = [[
{5:foo }|
^ |
{1:~ }|*2
{3:[No Name] }|
]],
showmode = {},
}
eq(0, eval('&cmdheight'))
assert_alive()
end)
it('when macro with lastline', function()
command('set cmdheight=0 display=lastline')
feed('qq')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
}
feed('q')
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
unchanged = true,
}
end)
it('when substitute text', function()
command('set cmdheight=0 noruler laststatus=3')
feed('ifoo<ESC>')
screen:expect {
grid = [[
fo^o |
{1:~ }|*3
{3:[No Name] [+] }|
]],
}
feed(':%s/foo/bar/gc<CR>')
screen:expect {
grid = [[
{2:foo} |
{1:~ }|*3
{6:replace wi...q/l/^E/^Y)?}^ |
]],
}
feed('y')
screen:expect {
grid = [[
^bar |
{1:~ }|*3
{3:[No Name] [+] }|
]],
}
assert_alive()
end)
it('when window resize', function()
command('set cmdheight=0')
feed('<C-w>+')
eq(0, eval('&cmdheight'))
end)
it('with non-silent mappings with cmdline', function()
command('set cmdheight=0')
command('map <f3> :nohlsearch<cr>')
feed('iaabbaa<esc>/aa<cr>')
screen:expect {
grid = [[
{10:^aa}bb{10:aa} |
{1:~ }|*4
]],
}
feed('<f3>')
screen:expect {
grid = [[
^aabbaa |
{1:~ }|*4
]],
}
end)
it('with silent! at startup', function()
clear { args = { '-c', 'set cmdheight=0', '-c', 'autocmd VimEnter * silent! call Foo()' } }
screen:attach()
-- doesn't crash while not displaying silent! error message
screen:expect {
grid = [[
^ |
{1:~ }|*4
]],
}
end)
it('with multigrid', function()
clear { args = { '--cmd', 'set cmdheight=0' } }
screen:attach { ext_multigrid = true }
api.nvim_buf_set_lines(0, 0, -1, true, { 'p' })
screen:expect {
grid = [[
## grid 1
[2:-------------------------]|*5
## grid 2
^p |
{1:~ }|*4
## grid 3
]],
win_viewport = {
[2] = {
win = 1000,
topline = 0,
botline = 2,
curline = 0,
curcol = 0,
linecount = 1,
sum_scroll_delta = 0,
},
},
}
feed '/p'
screen:expect {
grid = [[
## grid 1
[2:-------------------------]|*4
[3:-------------------------]|
## grid 2
{2:p} |
{1:~ }|*4
## grid 3
/p^ |
]],
win_viewport = {
[2] = {
win = 1000,
topline = 0,
botline = 2,
curline = 0,
curcol = 1,
linecount = 1,
sum_scroll_delta = 0,
},
},
}
end)
it('winbar is redrawn on entering cmdline and :redrawstatus #20336', function()
exec([[
set cmdheight=0
set winbar=%{mode()}%=:%{getcmdline()}
]])
feed(':')
screen:expect([[
{5:c :}|
|
{1:~ }|*2
:^ |
]])
feed('echo')
-- not redrawn yet
screen:expect([[
{5:c :}|
|
{1:~ }|*2
:echo^ |
]])
command('redrawstatus')
screen:expect([[
{5:c :echo}|
|
{1:~ }|*2
:echo^ |
]])
end)
it('window equalization with laststatus=0 #20367', function()
screen:try_resize(60, 9)
command('set cmdheight=0 laststatus=0')
command('vsplit')
screen:expect([[
^ │ |
{1:~ }│{1:~ }|*8
]])
feed(':')
command('split')
feed('<Esc>')
screen:expect([[
^ │ |
{1:~ }│{1:~ }|*3
{3:[No Name] }│{1:~ }|
│{1:~ }|
{1:~ }│{1:~ }|*3
]])
command('resize 2')
screen:expect([[
^ │ |
{1:~ }│{1:~ }|
{3:[No Name] }│{1:~ }|
│{1:~ }|
{1:~ }│{1:~ }|*5
]])
feed(':')
command('wincmd =')
feed('<Esc>')
screen:expect([[
^ │ |
{1:~ }│{1:~ }|*3
{3:[No Name] }│{1:~ }|
│{1:~ }|
{1:~ }│{1:~ }|*3
]])
end)
it('no assert failure with showcmd', function()
command('set showcmd cmdheight=0')
feed('d')
screen:expect([[
^ |
{1:~ }|*4
]])
assert_alive()
end)
it('can only be resized to 0 if set explicitly', function()
command('set laststatus=2')
command('resize +1')
screen:expect([[
^ |
{1:~ }|*2
{3:[No Name] }|
|
]])
command('set cmdheight=0')
screen:expect {
grid = [[
^ |
{1:~ }|*3
{3:[No Name] }|
]],
}
command('resize -1')
screen:expect {
grid = [[
^ |
{1:~ }|*2
{3:[No Name] }|
|
]],
}
command('resize +1')
screen:expect([[
^ |
{1:~ }|*3
{3:[No Name] }|
]])
end)
it('can be resized with external messages', function()
clear()
screen = new_screen({ rgb = true, ext_messages = true })
command('set laststatus=2 mouse=a')
command('resize -1')
screen:expect([[
^ |
{1:~ }|*2
{3:[No Name] }|
|
]])
api.nvim_input_mouse('left', 'press', '', 0, 3, 10)
poke_eventloop()
api.nvim_input_mouse('left', 'drag', '', 0, 4, 10)
screen:expect([[
^ |
{1:~ }|*3
{3:[No Name] }|
]])
end)
end)