mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2026-03-28 11:22:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
7be4ae796faa2066044b6cafe266ebe6354c55fe
neovim/test/functional/api/window_spec.lua
Sean Dewar 7be4ae796f fix(api): relax config validation for "win" 
Problem: only possible to move floats between tabpages if relative=win, which
has the restrictive effect of also anchoring it to the target window.

Solution: allow "win" without "relative" or "split"/"vertical". Only assume
missing "win" is 0 if relative=win is given to maintain that behaviour. (or when
configuring a new window)

Also add an error when attempting to change a split into a float that's in
another tabpage, as this isn't actually supported yet. (until the next commit)

Maybe this could do with some bikeshedding. Unclear if "win" should require
"relative" to be given, like with "row"/"col"; this can be annoying though as
specifying "relative" requires other fields to be given too.
2026-03-14 20:48:31 +00:00

3776 lines
129 KiB
Lua
Raw Blame History

local t = require('test.testutil')
local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')
local clear, curbuf, curbuf_contents, curwin, eq, neq, matches, ok, feed, insert, eval =
n.clear,
n.api.nvim_get_current_buf,
n.curbuf_contents,
n.api.nvim_get_current_win,
t.eq,
t.neq,
t.matches,
t.ok,
n.feed,
n.insert,
n.eval
local poke_eventloop = n.poke_eventloop
local exec = n.exec
local exec_lua = n.exec_lua
local fn = n.fn
local request = n.request
local NIL = vim.NIL
local api = n.api
local command = n.command
local pcall_err = t.pcall_err
local assert_alive = n.assert_alive
describe('API/win', function()
before_each(clear)
describe('get_buf', function()
it('works', function()
eq(curbuf(), api.nvim_win_get_buf(api.nvim_list_wins()[1]))
command('new')
api.nvim_set_current_win(api.nvim_list_wins()[2])
eq(curbuf(), api.nvim_win_get_buf(api.nvim_list_wins()[2]))
neq(
api.nvim_win_get_buf(api.nvim_list_wins()[1]),
api.nvim_win_get_buf(api.nvim_list_wins()[2])
)
end)
end)
describe('set_buf', function()
it('works', function()
command('new')
local windows = api.nvim_list_wins()
neq(api.nvim_win_get_buf(windows[2]), api.nvim_win_get_buf(windows[1]))
api.nvim_win_set_buf(windows[2], api.nvim_win_get_buf(windows[1]))
eq(api.nvim_win_get_buf(windows[2]), api.nvim_win_get_buf(windows[1]))
end)
it('validates args', function()
eq('Invalid buffer id: 23', pcall_err(api.nvim_win_set_buf, api.nvim_get_current_win(), 23))
eq('Invalid window id: 23', pcall_err(api.nvim_win_set_buf, 23, api.nvim_get_current_buf()))
end)
it('disallowed in cmdwin if win=cmdwin_{old_cur}win or buf=cmdwin_buf', function()
local new_buf = api.nvim_create_buf(true, true)
local old_win = api.nvim_get_current_win()
local new_win = api.nvim_open_win(new_buf, false, {
relative = 'editor',
row = 10,
col = 10,
width = 50,
height = 10,
})
feed('q:')
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_buf, 0, new_buf)
)
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_buf, old_win, new_buf)
)
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_buf, new_win, 0)
)
matches(
'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
pcall_err(
exec_lua,
[[
local cmdwin_buf = vim.api.nvim_get_current_buf()
local new_win, new_buf = ...
vim._with({buf = new_buf}, function()
vim.api.nvim_win_set_buf(new_win, cmdwin_buf)
end)
]],
new_win,
new_buf
)
)
matches(
'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
pcall_err(
exec_lua,
[[
local cmdwin_win = vim.api.nvim_get_current_win()
local new_win, new_buf = ...
vim._with({win = new_win}, function()
vim.api.nvim_win_set_buf(cmdwin_win, new_buf)
end)
]],
new_win,
new_buf
)
)
local next_buf = api.nvim_create_buf(true, true)
api.nvim_win_set_buf(new_win, next_buf)
eq(next_buf, api.nvim_win_get_buf(new_win))
end)
describe("with 'autochdir'", function()
local topdir
local otherbuf
local oldwin
local newwin
before_each(function()
command('set shellslash')
topdir = fn.getcwd()
t.mkdir(topdir .. '/Xacd')
t.mkdir(topdir .. '/Xacd/foo')
otherbuf = api.nvim_create_buf(false, true)
api.nvim_buf_set_name(otherbuf, topdir .. '/Xacd/baz.txt')
command('set autochdir')
command('edit Xacd/foo/bar.txt')
eq(topdir .. '/Xacd/foo', fn.getcwd())
oldwin = api.nvim_get_current_win()
command('vsplit')
newwin = api.nvim_get_current_win()
end)
after_each(function()
n.rmdir(topdir .. '/Xacd')
end)
it('does not change cwd with non-current window', function()
api.nvim_win_set_buf(oldwin, otherbuf)
eq(topdir .. '/Xacd/foo', fn.getcwd())
end)
it('changes cwd with current window', function()
api.nvim_win_set_buf(newwin, otherbuf)
eq(topdir .. '/Xacd', fn.getcwd())
end)
end)
end)
describe('{get,set}_cursor', function()
it('works', function()
eq({ 1, 0 }, api.nvim_win_get_cursor(0))
command('normal ityping\027o some text')
eq('typing\n some text', curbuf_contents())
eq({ 2, 10 }, api.nvim_win_get_cursor(0))
api.nvim_win_set_cursor(0, { 2, 6 })
command('normal i dumb')
eq('typing\n some dumb text', curbuf_contents())
end)
it('no memory leak when using invalid window ID with invalid pos', function()
eq('Invalid window id: 1', pcall_err(api.nvim_win_set_cursor, 1, { 'b\na' }))
end)
it('updates the screen, and also when the window is unfocused', function()
local screen = Screen.new(30, 9)
insert('prologue')
feed('100o<esc>')
insert('epilogue')
local win = curwin()
feed('gg')
local s1 = [[
^prologue |
|*8
]]
screen:expect(s1)
-- cursor position is at beginning
eq({ 1, 0 }, api.nvim_win_get_cursor(win))
-- move cursor to end
api.nvim_win_set_cursor(win, { 101, 0 })
screen:expect([[
|*7
^epilogue |
|
]])
-- move cursor to the beginning again
api.nvim_win_set_cursor(win, { 1, 0 })
screen:expect(s1)
-- move focus to new window
command('new')
neq(win, curwin())
-- sanity check, cursor position is kept
eq({ 1, 0 }, api.nvim_win_get_cursor(win))
local s2 = [[
^ |
{1:~ }|*2
{3:[No Name] }|
prologue |
|*2
{2:[No Name] [+] }|
|
]]
screen:expect(s2)
-- move cursor to end
api.nvim_win_set_cursor(win, { 101, 0 })
screen:expect([[
^ |
{1:~ }|*2
{3:[No Name] }|
|*2
epilogue |
{2:[No Name] [+] }|
|
]])
-- move cursor to the beginning again
api.nvim_win_set_cursor(win, { 1, 0 })
screen:expect(s2)
-- curwin didn't change back
neq(win, curwin())
end)
it('remembers what column it wants to be in', function()
insert('first line')
feed('o<esc>')
insert('second line')
feed('gg')
poke_eventloop() -- let nvim process the 'gg' command
-- cursor position is at beginning
local win = curwin()
eq({ 1, 0 }, api.nvim_win_get_cursor(win))
-- move cursor to column 5
api.nvim_win_set_cursor(win, { 1, 5 })
-- move down a line
feed('j')
poke_eventloop() -- let nvim process the 'j' command
-- cursor is still in column 5
eq({ 2, 5 }, api.nvim_win_get_cursor(win))
end)
it('updates cursorline and statusline ruler in non-current window', function()
local screen = Screen.new(60, 8)
command('set ruler')
command('set cursorline')
insert([[
aaa
bbb
ccc
ddd]])
local oldwin = curwin()
command('vsplit')
screen:expect([[
aaa │aaa |
bbb │bbb |
ccc │ccc |
{21:dd^d }│{21:ddd }|
{1:~ }│{1:~ }|*2
{3:< Name] [+] 4,3 All }{2:<Name] [+] 4,3 All}|
|
]])
api.nvim_win_set_cursor(oldwin, { 1, 0 })
screen:expect([[
aaa │{21:aaa }|
bbb │bbb |
ccc │ccc |
{21:dd^d }│ddd |
{1:~ }│{1:~ }|*2
{3:< Name] [+] 4,3 All }{2:<Name] [+] 1,1 All}|
|
]])
end)
it('updates cursorcolumn in non-current window', function()
local screen = Screen.new(60, 8)
command('set cursorcolumn')
insert([[
aaa
bbb
ccc
ddd]])
local oldwin = curwin()
command('vsplit')
screen:expect([[
aa{21:a} │aa{21:a} |
bb{21:b} │bb{21:b} |
cc{21:c} │cc{21:c} |
dd^d │ddd |
{1:~ }│{1:~ }|*2
{3:[No Name] [+] }{2:[No Name] [+] }|
|
]])
api.nvim_win_set_cursor(oldwin, { 2, 0 })
screen:expect([[
aa{21:a} │{21:a}aa |
bb{21:b} │bbb |
cc{21:c} │{21:c}cc |
dd^d │{21:d}dd |
{1:~ }│{1:~ }|*2
{3:[No Name] [+] }{2:[No Name] [+] }|
|
]])
end)
end)
describe('{get,set}_height', function()
it('works', function()
command('vsplit')
eq(
api.nvim_win_get_height(api.nvim_list_wins()[2]),
api.nvim_win_get_height(api.nvim_list_wins()[1])
)
api.nvim_set_current_win(api.nvim_list_wins()[2])
command('split')
eq(
api.nvim_win_get_height(api.nvim_list_wins()[2]),
math.floor(api.nvim_win_get_height(api.nvim_list_wins()[1]) / 2)
)
api.nvim_win_set_height(api.nvim_list_wins()[2], 2)
eq(2, api.nvim_win_get_height(api.nvim_list_wins()[2]))
end)
it('failure modes', function()
command('split')
eq('Invalid window id: 999999', pcall_err(api.nvim_win_set_height, 999999, 10))
eq(
'Wrong type for argument 2 when calling nvim_win_set_height, expecting Integer',
pcall_err(api.nvim_win_set_height, 0, 0.9)
)
end)
it('correctly handles height=1', function()
command('split')
api.nvim_set_current_win(api.nvim_list_wins()[1])
api.nvim_win_set_height(api.nvim_list_wins()[2], 1)
eq(1, api.nvim_win_get_height(api.nvim_list_wins()[2]))
end)
it('correctly handles height=1 with a winbar', function()
command('set winbar=foobar')
command('set winminheight=0')
command('split')
api.nvim_set_current_win(api.nvim_list_wins()[1])
api.nvim_win_set_height(api.nvim_list_wins()[2], 1)
eq(1, api.nvim_win_get_height(api.nvim_list_wins()[2]))
end)
it('do not cause ml_get errors with foldmethod=expr #19989', function()
insert([[
aaaaa
bbbbb
ccccc]])
command('set foldmethod=expr')
exec([[
new
let w = nvim_get_current_win()
wincmd w
call nvim_win_set_height(w, 5)
]])
feed('l')
eq('', api.nvim_get_vvar('errmsg'))
end)
end)
describe('{get,set}_width', function()
it('works', function()
command('split')
eq(
api.nvim_win_get_width(api.nvim_list_wins()[2]),
api.nvim_win_get_width(api.nvim_list_wins()[1])
)
api.nvim_set_current_win(api.nvim_list_wins()[2])
command('vsplit')
eq(
api.nvim_win_get_width(api.nvim_list_wins()[2]),
math.floor(api.nvim_win_get_width(api.nvim_list_wins()[1]) / 2)
)
api.nvim_win_set_width(api.nvim_list_wins()[2], 2)
eq(2, api.nvim_win_get_width(api.nvim_list_wins()[2]))
end)
it('failure modes', function()
command('vsplit')
eq('Invalid window id: 999999', pcall_err(api.nvim_win_set_width, 999999, 10))
eq(
'Wrong type for argument 2 when calling nvim_win_set_width, expecting Integer',
pcall_err(api.nvim_win_set_width, 0, 0.9)
)
end)
it('do not cause ml_get errors with foldmethod=expr #19989', function()
insert([[
aaaaa
bbbbb
ccccc]])
command('set foldmethod=expr')
exec([[
vnew
let w = nvim_get_current_win()
wincmd w
call nvim_win_set_width(w, 5)
]])
feed('l')
eq('', api.nvim_get_vvar('errmsg'))
end)
end)
describe('{get,set,del}_var', function()
it('works', function()
api.nvim_win_set_var(0, 'lua', { 1, 2, { ['3'] = 1 } })
eq({ 1, 2, { ['3'] = 1 } }, api.nvim_win_get_var(0, 'lua'))
eq({ 1, 2, { ['3'] = 1 } }, api.nvim_eval('w:lua'))
eq(1, fn.exists('w:lua'))
api.nvim_win_del_var(0, 'lua')
eq(0, fn.exists('w:lua'))
eq('Key not found: lua', pcall_err(api.nvim_win_del_var, 0, 'lua'))
api.nvim_win_set_var(0, 'lua', 1)
command('lockvar w:lua')
eq('Key is locked: lua', pcall_err(api.nvim_win_del_var, 0, 'lua'))
eq('Key is locked: lua', pcall_err(api.nvim_win_set_var, 0, 'lua', 1))
end)
it('window_set_var returns the old value', function()
local val1 = { 1, 2, { ['3'] = 1 } }
local val2 = { 4, 7 }
eq(NIL, request('window_set_var', 0, 'lua', val1))
eq(val1, request('window_set_var', 0, 'lua', val2))
end)
it('window_del_var returns the old value', function()
local val1 = { 1, 2, { ['3'] = 1 } }
local val2 = { 4, 7 }
eq(NIL, request('window_set_var', 0, 'lua', val1))
eq(val1, request('window_set_var', 0, 'lua', val2))
eq(val2, request('window_del_var', 0, 'lua'))
end)
end)
describe('nvim_get_option_value, nvim_set_option_value', function()
it('works', function()
api.nvim_set_option_value('colorcolumn', '4,3', {})
eq('4,3', api.nvim_get_option_value('colorcolumn', {}))
command('set modified hidden')
command('enew') -- edit new buffer, window option is preserved
eq('4,3', api.nvim_get_option_value('colorcolumn', {}))
-- global-local option
api.nvim_set_option_value('statusline', 'window-status', { win = 0 })
eq('window-status', api.nvim_get_option_value('statusline', { win = 0 }))
eq(
"%<%f %{%nvim_eval_statusline('%h%w%m%r', {'maxwidth': 30}).width > 0 ? '%h%w%m%r ' : ''%}%=%{% &showcmdloc == 'statusline' ? '%-10.S ' : '' %}%{% exists('b:keymap_name') ? '<'..b:keymap_name..'> ' : '' %}%{% &ruler ? ( &rulerformat == '' ? '%-14.(%l,%c%V%) %P' : &rulerformat ) : '' %}",
api.nvim_get_option_value('statusline', { scope = 'global' })
)
command('set modified')
command('enew') -- global-local: not preserved in new buffer
-- confirm local value was not copied
eq(
"%<%f %{%nvim_eval_statusline('%h%w%m%r', {'maxwidth': 30}).width > 0 ? '%h%w%m%r ' : ''%}%=%{% &showcmdloc == 'statusline' ? '%-10.S ' : '' %}%{% exists('b:keymap_name') ? '<'..b:keymap_name..'> ' : '' %}%{% &ruler ? ( &rulerformat == '' ? '%-14.(%l,%c%V%) %P' : &rulerformat ) : '' %}",
api.nvim_get_option_value('statusline', { win = 0 })
)
eq('', eval('&l:statusline'))
end)
it('after switching windows #15390', function()
command('tabnew')
local tab1 = unpack(api.nvim_list_tabpages())
local win1 = unpack(api.nvim_tabpage_list_wins(tab1))
api.nvim_set_option_value('statusline', 'window-status', { win = win1 })
command('split')
command('wincmd J')
command('wincmd j')
eq('window-status', api.nvim_get_option_value('statusline', { win = win1 }))
assert_alive()
end)
describe('after closing', function()
local buf, win0, win1, win2
before_each(function()
win0 = api.nvim_get_current_win()
command('new')
buf = api.nvim_get_current_buf()
win1 = api.nvim_get_current_win()
command('set numberwidth=10')
command('split')
win2 = api.nvim_get_current_win()
command('set numberwidth=15')
command('enew')
api.nvim_set_current_win(win1)
command('normal ix')
command('enew')
api.nvim_set_current_win(win0)
eq(4, api.nvim_get_option_value('numberwidth', {}))
end)
-- at this point buffer `buf` is current in no windows. Closing shouldn't affect its defaults
it('0 windows', function()
api.nvim_set_current_buf(buf)
eq(10, api.nvim_get_option_value('numberwidth', {}))
end)
it('1 window', function()
api.nvim_win_close(win1, false)
api.nvim_set_current_buf(buf)
eq(10, api.nvim_get_option_value('numberwidth', {}))
end)
it('2 windows', function()
api.nvim_win_close(win1, false)
api.nvim_win_close(win2, false)
api.nvim_set_current_buf(buf)
eq(10, api.nvim_get_option_value('numberwidth', {}))
end)
end)
it('returns values for unset local options', function()
eq(-1, api.nvim_get_option_value('scrolloff', { win = 0, scope = 'local' }))
end)
end)
describe('get_position', function()
it('works', function()
local height = api.nvim_win_get_height(api.nvim_list_wins()[1])
local width = api.nvim_win_get_width(api.nvim_list_wins()[1])
command('split')
command('vsplit')
eq({ 0, 0 }, api.nvim_win_get_position(api.nvim_list_wins()[1]))
local vsplit_pos = math.floor(width / 2)
local split_pos = math.floor(height / 2)
local win2row, win2col = unpack(api.nvim_win_get_position(api.nvim_list_wins()[2]))
local win3row, win3col = unpack(api.nvim_win_get_position(api.nvim_list_wins()[3]))
eq(0, win2row)
eq(0, win3col)
ok(vsplit_pos - 1 <= win2col and win2col <= vsplit_pos + 1)
ok(split_pos - 1 <= win3row and win3row <= split_pos + 1)
end)
end)
describe('get_position', function()
it('works', function()
command('tabnew')
command('vsplit')
eq(api.nvim_win_get_tabpage(api.nvim_list_wins()[1]), api.nvim_list_tabpages()[1])
eq(api.nvim_win_get_tabpage(api.nvim_list_wins()[2]), api.nvim_list_tabpages()[2])
eq(api.nvim_win_get_tabpage(api.nvim_list_wins()[3]), api.nvim_list_tabpages()[2])
end)
end)
describe('get_number', function()
it('works', function()
local wins = api.nvim_list_wins()
eq(1, api.nvim_win_get_number(wins[1]))
command('split')
local win1, win2 = unpack(api.nvim_list_wins())
eq(1, api.nvim_win_get_number(win1))
eq(2, api.nvim_win_get_number(win2))
command('wincmd J')
eq(2, api.nvim_win_get_number(win1))
eq(1, api.nvim_win_get_number(win2))
command('tabnew')
local win3 = api.nvim_list_wins()[3]
-- First tab page
eq(2, api.nvim_win_get_number(win1))
eq(1, api.nvim_win_get_number(win2))
-- Second tab page
eq(1, api.nvim_win_get_number(win3))
end)
end)
describe('is_valid', function()
it('works', function()
command('split')
local win = api.nvim_list_wins()[2]
api.nvim_set_current_win(win)
ok(api.nvim_win_is_valid(win))
command('close')
ok(not api.nvim_win_is_valid(win))
end)
end)
describe('close', function()
it('can close current window', function()
local oldwin = api.nvim_get_current_win()
command('split')
local newwin = api.nvim_get_current_win()
api.nvim_win_close(newwin, false)
eq({ oldwin }, api.nvim_list_wins())
end)
it('can close noncurrent window', function()
local oldwin = api.nvim_get_current_win()
command('split')
local newwin = api.nvim_get_current_win()
api.nvim_win_close(oldwin, false)
eq({ newwin }, api.nvim_list_wins())
end)
it("handles changed buffer when 'hidden' is unset", function()
command('set nohidden')
local oldwin = api.nvim_get_current_win()
insert('text')
command('new')
local newwin = api.nvim_get_current_win()
eq(
'Vim:E37: No write since last change (add ! to override)',
pcall_err(api.nvim_win_close, oldwin, false)
)
eq({ newwin, oldwin }, api.nvim_list_wins())
end)
it('handles changed buffer with force', function()
local oldwin = api.nvim_get_current_win()
insert('text')
command('new')
local newwin = api.nvim_get_current_win()
api.nvim_win_close(oldwin, true)
eq({ newwin }, api.nvim_list_wins())
end)
it('in cmdline-window #9767', function()
command('split')
eq(2, #api.nvim_list_wins())
local oldbuf = api.nvim_get_current_buf()
local oldwin = api.nvim_get_current_win()
local otherwin = api.nvim_open_win(0, false, {
relative = 'editor',
row = 10,
col = 10,
width = 10,
height = 10,
})
-- Open cmdline-window.
feed('q:')
eq(4, #api.nvim_list_wins())
eq(':', fn.getcmdwintype())
-- Not allowed to close previous window from cmdline-window.
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_close, oldwin, true)
)
-- Closing other windows is fine.
api.nvim_win_close(otherwin, true)
eq(false, api.nvim_win_is_valid(otherwin))
-- Close cmdline-window.
api.nvim_win_close(0, true)
eq(2, #api.nvim_list_wins())
eq('', fn.getcmdwintype())
-- Closing curwin in context of a different window shouldn't close cmdwin.
otherwin = api.nvim_open_win(0, false, {
relative = 'editor',
row = 10,
col = 10,
width = 10,
height = 10,
})
feed('q:')
exec_lua(
[[
vim._with({win = ...}, function()
vim.api.nvim_win_close(0, true)
end)
]],
otherwin
)
eq(false, api.nvim_win_is_valid(otherwin))
eq(':', fn.getcmdwintype())
-- Closing cmdwin in context of a non-previous window is still OK.
otherwin = api.nvim_open_win(oldbuf, false, {
relative = 'editor',
row = 10,
col = 10,
width = 10,
height = 10,
})
exec_lua(
[[
local otherwin, cmdwin = ...
vim._with({win = otherwin}, function()
vim.api.nvim_win_close(cmdwin, true)
end)
]],
otherwin,
api.nvim_get_current_win()
)
eq('', fn.getcmdwintype())
eq(true, api.nvim_win_is_valid(otherwin))
end)
it('closing current (float) window of another tabpage #15313', function()
command('tabedit')
command('botright split')
local prevwin = curwin()
eq(2, eval('tabpagenr()'))
local win = api.nvim_open_win(0, true, {
relative = 'editor',
row = 10,
col = 10,
width = 50,
height = 10,
})
local tab = eval('tabpagenr()')
command('tabprevious')
eq(1, eval('tabpagenr()'))
api.nvim_win_close(win, false)
eq(prevwin, api.nvim_tabpage_get_win(tab))
assert_alive()
end)
it('closing a float does not enter unfocusable or hidden prevwin', function()
local firstwin = api.nvim_get_current_win()
local wins = {} ---@type integer[]
for _ = 1, 4 do
wins[#wins + 1] = api.nvim_open_win(0, true, {
relative = 'editor',
row = 10,
col = 10,
width = 50,
height = 10,
})
end
api.nvim_win_set_config(wins[3], { hide = true })
api.nvim_win_close(0, false)
eq(firstwin, api.nvim_get_current_win())
api.nvim_set_current_win(wins[2])
api.nvim_set_current_win(wins[3])
api.nvim_win_set_config(wins[2], { focusable = false })
api.nvim_win_close(0, false)
eq(firstwin, api.nvim_get_current_win())
api.nvim_set_current_win(wins[1])
api.nvim_set_current_win(wins[2])
api.nvim_win_close(0, false)
eq(wins[1], api.nvim_get_current_win())
end)
end)
describe('hide', function()
it('can hide current window', function()
local oldwin = api.nvim_get_current_win()
command('split')
local newwin = api.nvim_get_current_win()
api.nvim_win_hide(newwin)
eq({ oldwin }, api.nvim_list_wins())
end)
it('can hide noncurrent window', function()
local oldwin = api.nvim_get_current_win()
command('split')
local newwin = api.nvim_get_current_win()
api.nvim_win_hide(oldwin)
eq({ newwin }, api.nvim_list_wins())
end)
it('does not close the buffer', function()
local oldwin = api.nvim_get_current_win()
local oldbuf = api.nvim_get_current_buf()
local buf = api.nvim_create_buf(true, false)
local newwin = api.nvim_open_win(buf, true, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
})
api.nvim_win_hide(newwin)
eq({ oldwin }, api.nvim_list_wins())
eq({ oldbuf, buf }, api.nvim_list_bufs())
end)
it('deletes the buffer when bufhidden=wipe', function()
local oldwin = api.nvim_get_current_win()
local oldbuf = api.nvim_get_current_buf()
local buf = api.nvim_create_buf(true, false)
local newwin = api.nvim_open_win(buf, true, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
})
api.nvim_set_option_value('bufhidden', 'wipe', { buf = buf })
api.nvim_win_hide(newwin)
eq({ oldwin }, api.nvim_list_wins())
eq({ oldbuf }, api.nvim_list_bufs())
end)
it('in the cmdwin', function()
feed('q:')
-- Can close the cmdwin.
api.nvim_win_hide(0)
eq('', fn.getcmdwintype())
local old_buf = api.nvim_get_current_buf()
local old_win = api.nvim_get_current_win()
local other_win = api.nvim_open_win(0, false, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
})
feed('q:')
-- Cannot close the previous window.
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_hide, old_win)
)
-- Can close other windows.
api.nvim_win_hide(other_win)
eq(false, api.nvim_win_is_valid(other_win))
-- Closing curwin in context of a different window shouldn't close cmdwin.
other_win = api.nvim_open_win(old_buf, false, {
relative = 'editor',
row = 10,
col = 10,
width = 10,
height = 10,
})
exec_lua(
[[
vim._with({win = ...}, function()
vim.api.nvim_win_hide(0)
end)
]],
other_win
)
eq(false, api.nvim_win_is_valid(other_win))
eq(':', fn.getcmdwintype())
-- Closing cmdwin in context of a non-previous window is still OK.
other_win = api.nvim_open_win(old_buf, false, {
relative = 'editor',
row = 10,
col = 10,
width = 10,
height = 10,
})
exec_lua(
[[
local otherwin, cmdwin = ...
vim._with({win = otherwin}, function()
vim.api.nvim_win_hide(cmdwin)
end)
]],
other_win,
api.nvim_get_current_win()
)
eq('', fn.getcmdwintype())
eq(true, api.nvim_win_is_valid(other_win))
end)
end)
describe('text_height', function()
local screen, ns, X
before_each(function()
screen = Screen.new(45, 22)
ns = api.nvim_create_namespace('')
X = api.nvim_get_vvar('maxcol')
end)
it('validation', function()
insert([[
aaa
bbb
ccc
ddd
eee]])
eq('Invalid window id: 23', pcall_err(api.nvim_win_text_height, 23, {}))
eq('Line index out of bounds', pcall_err(api.nvim_win_text_height, 0, { start_row = 5 }))
eq('Line index out of bounds', pcall_err(api.nvim_win_text_height, 0, { start_row = -6 }))
eq('Line index out of bounds', pcall_err(api.nvim_win_text_height, 0, { end_row = 5 }))
eq('Line index out of bounds', pcall_err(api.nvim_win_text_height, 0, { end_row = -6 }))
eq(
"'start_row' is higher than 'end_row'",
pcall_err(api.nvim_win_text_height, 0, { start_row = 3, end_row = 1 })
)
eq(
"'start_vcol' specified without 'start_row'",
pcall_err(api.nvim_win_text_height, 0, { end_row = 2, start_vcol = 0 })
)
eq(
"'end_vcol' specified without 'end_row'",
pcall_err(api.nvim_win_text_height, 0, { start_row = 2, end_vcol = 0 })
)
eq(
"Invalid 'start_vcol': out of range",
pcall_err(api.nvim_win_text_height, 0, { start_row = 2, start_vcol = -1 })
)
eq(
"Invalid 'start_vcol': out of range",
pcall_err(api.nvim_win_text_height, 0, { start_row = 2, start_vcol = X + 1 })
)
eq(
"Invalid 'end_vcol': out of range",
pcall_err(api.nvim_win_text_height, 0, { end_row = 2, end_vcol = -1 })
)
eq(
"Invalid 'end_vcol': out of range",
pcall_err(api.nvim_win_text_height, 0, { end_row = 2, end_vcol = X + 1 })
)
eq(
"Invalid 'max_height': out of range",
pcall_err(api.nvim_win_text_height, 0, { max_height = 0 })
)
eq(
"'start_vcol' is higher than 'end_vcol'",
pcall_err(
api.nvim_win_text_height,
0,
{ start_row = 2, end_row = 2, start_vcol = 10, end_vcol = 5 }
)
)
end)
it('with two diff windows', function()
exec([[
set diffopt+=context:2 number
let expr = 'printf("%08d", v:val) .. repeat("!", v:val)'
call setline(1, map(range(1, 20) + range(25, 45), expr))
vnew
call setline(1, map(range(3, 20) + range(28, 50), expr))
windo diffthis
]])
feed('24gg')
screen:expect([[
{7: }{8: }{23:----------------}│{7: }{8: 1 }{22:00000001! }|
{7: }{8: }{23:----------------}│{7: }{8: 2 }{22:00000002!! }|
{7: }{8: 1 }00000003!!! │{7: }{8: 3 }00000003!!! |
{7: }{8: 2 }00000004!!!! │{7: }{8: 4 }00000004!!!! |
{7:+ }{8: 3 }{13:+-- 14 lines: 00}│{7:+ }{8: 5 }{13:+-- 14 lines: 00}|
{7: }{8: 17 }00000019!!!!!!!!│{7: }{8: 19 }00000019!!!!!!!!|
{7: }{8: 18 }00000020!!!!!!!!│{7: }{8: 20 }00000020!!!!!!!!|
{7: }{8: }{23:----------------}│{7: }{8: 21 }{22:00000025!!!!!!!!}|
{7: }{8: }{23:----------------}│{7: }{8: 22 }{22:00000026!!!!!!!!}|
{7: }{8: }{23:----------------}│{7: }{8: 23 }{22:00000027!!!!!!!!}|
{7: }{8: 19 }00000028!!!!!!!!│{7: }{8: 24 }^00000028!!!!!!!!|
{7: }{8: 20 }00000029!!!!!!!!│{7: }{8: 25 }00000029!!!!!!!!|
{7:+ }{8: 21 }{13:+-- 14 lines: 00}│{7:+ }{8: 26 }{13:+-- 14 lines: 00}|
{7: }{8: 35 }00000044!!!!!!!!│{7: }{8: 40 }00000044!!!!!!!!|
{7: }{8: 36 }00000045!!!!!!!!│{7: }{8: 41 }00000045!!!!!!!!|
{7: }{8: 37 }{22:00000046!!!!!!!!}│{7: }{8: }{23:----------------}|
{7: }{8: 38 }{22:00000047!!!!!!!!}│{7: }{8: }{23:----------------}|
{7: }{8: 39 }{22:00000048!!!!!!!!}│{7: }{8: }{23:----------------}|
{7: }{8: 40 }{22:00000049!!!!!!!!}│{7: }{8: }{23:----------------}|
{7: }{8: 41 }{22:00000050!!!!!!!!}│{7: }{8: }{23:----------------}|
{2:[No Name] [+] }{3:[No Name] [+] }|
|
]])
screen:try_resize(45, 3)
screen:expect([[
{7: }{8: 19 }00000028!!!!!!!!│{7: }{8: 24 }^00000028!!!!!!!!|
{2:[No Name] [+] }{3:[No Name] [+] }|
|
]])
eq({ all = 20, fill = 5, end_row = 40, end_vcol = 53 }, api.nvim_win_text_height(1000, {}))
eq({ all = 20, fill = 5, end_row = 40, end_vcol = 58 }, api.nvim_win_text_height(1001, {}))
eq(
{ all = 20, fill = 5, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { start_row = 0 })
)
eq(
{ all = 20, fill = 5, end_row = 40, end_vcol = 58 },
api.nvim_win_text_height(1001, { start_row = 0 })
)
eq(
{ all = 15, fill = 0, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { end_row = -1 })
)
eq(
{ all = 15, fill = 0, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { end_row = 40 })
)
eq(
{ all = 20, fill = 5, end_row = 40, end_vcol = 58 },
api.nvim_win_text_height(1001, { end_row = -1 })
)
eq(
{ all = 20, fill = 5, end_row = 40, end_vcol = 58 },
api.nvim_win_text_height(1001, { end_row = 40 })
)
eq(
{ all = 10, fill = 5, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { start_row = 23 })
)
eq(
{ all = 13, fill = 3, end_row = 40, end_vcol = 58 },
api.nvim_win_text_height(1001, { start_row = 18 })
)
eq(
{ all = 11, fill = 0, end_row = 23, end_vcol = 36 },
api.nvim_win_text_height(1000, { end_row = 23 })
)
eq(
{ all = 11, fill = 5, end_row = 18, end_vcol = 36 },
api.nvim_win_text_height(1001, { end_row = 18 })
)
eq(
{ all = 11, fill = 0, end_row = 39, end_vcol = 52 },
api.nvim_win_text_height(1000, { start_row = 3, end_row = 39 })
)
eq(
{ all = 11, fill = 3, end_row = 34, end_vcol = 52 },
api.nvim_win_text_height(1001, { start_row = 1, end_row = 34 })
)
eq(
{ all = 9, fill = 0, end_row = 25, end_vcol = 0 },
api.nvim_win_text_height(1000, { start_row = 4, end_row = 38 })
)
eq(
{ all = 9, fill = 3, end_row = 20, end_vcol = 0 },
api.nvim_win_text_height(1001, { start_row = 2, end_row = 33 })
)
eq(
{ all = 9, fill = 0, end_row = 25, end_vcol = 0 },
api.nvim_win_text_height(1000, { start_row = 5, end_row = 37 })
)
eq(
{ all = 9, fill = 3, end_row = 20, end_vcol = 0 },
api.nvim_win_text_height(1001, { start_row = 3, end_row = 32 })
)
eq(
{ all = 9, fill = 0, end_row = 25, end_vcol = 0 },
api.nvim_win_text_height(1000, { start_row = 17, end_row = 25 })
)
eq(
{ all = 9, fill = 3, end_row = 20, end_vcol = 0 },
api.nvim_win_text_height(1001, { start_row = 15, end_row = 20 })
)
eq(
{ all = 7, fill = 0, end_row = 24, end_vcol = 37 },
api.nvim_win_text_height(1000, { start_row = 18, end_row = 24 })
)
eq(
{ all = 7, fill = 3, end_row = 19, end_vcol = 37 },
api.nvim_win_text_height(1001, { start_row = 16, end_row = 19 })
)
eq(
{ all = 6, fill = 5, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { start_row = -1 })
)
eq(
{ all = 5, fill = 5, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { start_row = -1, start_vcol = X })
)
eq(
{ all = 0, fill = 0, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(1000, { start_row = -1, start_vcol = X, end_row = -1 })
)
eq(
{ all = 0, fill = 0, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(
1000,
{ start_row = -1, start_vcol = X, end_row = -1, end_vcol = X }
)
)
eq(
{ all = 1, fill = 0, end_row = 40, end_vcol = 53 },
api.nvim_win_text_height(
1000,
{ start_row = -1, start_vcol = 0, end_row = -1, end_vcol = X }
)
)
eq(
{ all = 3, fill = 2, end_row = 0, end_vcol = 11 },
api.nvim_win_text_height(1001, { end_row = 0 })
)
eq(
{ all = 2, fill = 2, end_row = 0, end_vcol = 0 },
api.nvim_win_text_height(1001, { end_row = 0, end_vcol = 0 })
)
eq(
{ all = 2, fill = 2, end_row = 0, end_vcol = 0 },
api.nvim_win_text_height(1001, { start_row = 0, end_row = 0, end_vcol = 0 })
)
eq(
{ all = 0, fill = 0, end_row = 0, end_vcol = 0 },
api.nvim_win_text_height(1001, { start_row = 0, start_vcol = 0, end_row = 0, end_vcol = 0 })
)
eq(
{ all = 1, fill = 0, end_row = 0, end_vcol = 11 },
api.nvim_win_text_height(1001, { start_row = 0, start_vcol = 0, end_row = 0, end_vcol = X })
)
eq(
{ all = 11, fill = 5, end_row = 18, end_vcol = 36 },
api.nvim_win_text_height(1001, { end_row = 18 })
)
eq(
{ all = 9, fill = 3, end_row = 18, end_vcol = 36 },
api.nvim_win_text_height(1001, { start_row = 0, start_vcol = 0, end_row = 18 })
)
eq(
{ all = 10, fill = 5, end_row = 18, end_vcol = 0 },
api.nvim_win_text_height(1001, { end_row = 18, end_vcol = 0 })
)
eq(
{ all = 8, fill = 3, end_row = 18, end_vcol = 0 },
api.nvim_win_text_height(
1001,
{ start_row = 0, start_vcol = 0, end_row = 18, end_vcol = 0 }
)
)
end)
it('with wrapped lines', function()
exec([[
set number cpoptions+=n
call setline(1, repeat([repeat('foobar-', 36)], 3))
]])
api.nvim_buf_set_extmark(
0,
ns,
1,
100,
{ virt_text = { { ('?'):rep(15), 'Search' } }, virt_text_pos = 'inline' }
)
api.nvim_buf_set_extmark(
0,
ns,
2,
200,
{ virt_text = { { ('!'):rep(75), 'Search' } }, virt_text_pos = 'inline' }
)
screen:expect([[
{8: 1 }^foobar-foobar-foobar-foobar-foobar-foobar|
-foobar-foobar-foobar-foobar-foobar-foobar-fo|
obar-foobar-foobar-foobar-foobar-foobar-fooba|
r-foobar-foobar-foobar-foobar-foobar-foobar-f|
oobar-foobar-foobar-foobar-foobar-foobar-foob|
ar-foobar-foobar-foobar-foobar- |
{8: 2 }foobar-foobar-foobar-foobar-foobar-foobar|
-foobar-foobar-foobar-foobar-foobar-foobar-fo|
obar-foobar-fo{10:???????????????}obar-foobar-foob|
ar-foobar-foobar-foobar-foobar-foobar-foobar-|
foobar-foobar-foobar-foobar-foobar-foobar-foo|
bar-foobar-foobar-foobar-foobar-foobar-foobar|
- |
{8: 3 }foobar-foobar-foobar-foobar-foobar-foobar|
-foobar-foobar-foobar-foobar-foobar-foobar-fo|
obar-foobar-foobar-foobar-foobar-foobar-fooba|
r-foobar-foobar-foobar-foobar-foobar-foobar-f|
oobar-foobar-foobar-foob{10:!!!!!!!!!!!!!!!!!!!!!}|
{10:!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}|
{10:!!!!!!!!!}ar-foobar-foobar-foobar-foobar-fooba|
r-foobar-foobar- |
|
]])
screen:try_resize(45, 2)
screen:expect([[
{8: 1 }^foobar-foobar-foobar-foobar-foobar-foobar|
|
]])
eq({ all = 21, fill = 0, end_row = 2, end_vcol = 327 }, api.nvim_win_text_height(0, {}))
eq(
{ all = 6, fill = 0, end_row = 0, end_vcol = 252 },
api.nvim_win_text_height(0, { start_row = 0, end_row = 0 })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, end_row = 1 })
)
eq(
{ all = 8, fill = 0, end_row = 2, end_vcol = 327 },
api.nvim_win_text_height(0, { start_row = 2, end_row = 2 })
)
eq(
{ all = 0, fill = 0, end_row = 1, end_vcol = 0 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 0 })
)
eq(
{ all = 1, fill = 0, end_row = 1, end_vcol = 41 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 41 })
)
eq(
{ all = 2, fill = 0, end_row = 1, end_vcol = 42 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 42 })
)
eq(
{ all = 2, fill = 0, end_row = 1, end_vcol = 86 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 86 })
)
eq(
{ all = 3, fill = 0, end_row = 1, end_vcol = 87 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 87 })
)
eq(
{ all = 6, fill = 0, end_row = 1, end_vcol = 266 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 266 })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 267 })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 311 })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = 312 })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 0, end_row = 1, end_vcol = X })
)
eq(
{ all = 7, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 40, end_row = 1, end_vcol = X })
)
eq(
{ all = 6, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 41, end_row = 1, end_vcol = X })
)
eq(
{ all = 6, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 85, end_row = 1, end_vcol = X })
)
eq(
{ all = 5, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 86, end_row = 1, end_vcol = X })
)
eq(
{ all = 2, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 265, end_row = 1, end_vcol = X })
)
eq(
{ all = 1, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 266, end_row = 1, end_vcol = X })
)
eq(
{ all = 1, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 310, end_row = 1, end_vcol = X })
)
eq(
{ all = 0, fill = 0, end_row = 1, end_vcol = 267 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 311, end_row = 1, end_vcol = X })
)
eq(
{ all = 1, fill = 0, end_row = 1, end_vcol = 131 },
api.nvim_win_text_height(0, { start_row = 1, start_vcol = 86, end_row = 1, end_vcol = 131 })
)
eq(
{ all = 1, fill = 0, end_row = 1, end_vcol = 266 },
api.nvim_win_text_height(
0,
{ start_row = 1, start_vcol = 221, end_row = 1, end_vcol = 266 }
)
)
eq(
{ all = 18, fill = 0, end_row = 2, end_vcol = 327 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 131 })
)
eq(
{ all = 19, fill = 0, end_row = 2, end_vcol = 327 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 130 })
)
eq(
{ all = 20, fill = 0, end_row = 2, end_vcol = 311 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 311 })
)
eq(
{ all = 21, fill = 0, end_row = 2, end_vcol = 312 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 312 })
)
eq(
{ all = 17, fill = 0, end_row = 2, end_vcol = 311 },
api.nvim_win_text_height(
0,
{ start_row = 0, start_vcol = 131, end_row = 2, end_vcol = 311 }
)
)
eq(
{ all = 19, fill = 0, end_row = 2, end_vcol = 312 },
api.nvim_win_text_height(
0,
{ start_row = 0, start_vcol = 130, end_row = 2, end_vcol = 312 }
)
)
eq(
{ all = 16, fill = 0, end_row = 2, end_vcol = 327 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 221 })
)
eq(
{ all = 17, fill = 0, end_row = 2, end_vcol = 327 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 220 })
)
eq(
{ all = 14, fill = 0, end_row = 2, end_vcol = 41 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 41 })
)
eq(
{ all = 15, fill = 0, end_row = 2, end_vcol = 42 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 42 })
)
eq(
{ all = 9, fill = 0, end_row = 2, end_vcol = 41 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 221, end_row = 2, end_vcol = 41 })
)
eq(
{ all = 11, fill = 0, end_row = 2, end_vcol = 42 },
api.nvim_win_text_height(0, { start_row = 0, start_vcol = 220, end_row = 2, end_vcol = 42 })
)
exec('call setline(1, "foo")')
eq(
{ all = 1, fill = 0, end_row = 0, end_vcol = 3 },
api.nvim_win_text_height(0, { max_height = 1 })
)
eq(
{ all = 8, fill = 0, end_row = 1, end_vcol = 41 },
api.nvim_win_text_height(0, { max_height = 2 })
)
eq(
{ all = 2, fill = 0, end_row = 1, end_vcol = 1 },
api.nvim_win_text_height(0, { max_height = 2, end_row = 1, end_vcol = 1 })
)
eq(
{ all = 8, fill = 0, end_row = 1, end_vcol = 41 },
api.nvim_win_text_height(0, { max_height = 2, end_row = 2, end_vcol = 1 })
)
end)
it('with virtual lines around a fold', function()
screen:try_resize(45, 10)
exec([[
call setline(1, range(1, 8))
3,6fold
]])
api.nvim_buf_set_extmark(
0,
ns,
1,
0,
{ virt_lines = { { { 'VIRT LINE 1' } }, { { 'VIRT LINE 2' } } } }
)
api.nvim_buf_set_extmark(
0,
ns,
6,
0,
{ virt_lines = { { { 'VIRT LINE 3' } } }, virt_lines_above = true }
)
screen:expect([[
^1 |
2 |
VIRT LINE 1 |
VIRT LINE 2 |
{13:+-- 4 lines: 3······························}|
VIRT LINE 3 |
7 |
8 |
{1:~ }|
|
]])
eq({ all = 8, fill = 3, end_row = 7, end_vcol = 1 }, api.nvim_win_text_height(0, {}))
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2 })
)
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = X })
)
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 90 })
)
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 46 })
)
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 45 })
)
eq(
{ all = 5, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 1 })
)
eq(
{ all = 4, fill = 2, end_row = 2, end_vcol = 0 },
api.nvim_win_text_height(0, { end_row = 2, end_vcol = 0 })
)
eq(
{ all = 6, fill = 3, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2 })
)
eq(
{ all = 4, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = 0 })
)
eq(
{ all = 4, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = 44 })
)
eq(
{ all = 3, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = 45 })
)
eq(
{ all = 3, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = 89 })
)
eq(
{ all = 3, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = 90 })
)
eq(
{ all = 3, fill = 1, end_row = 7, end_vcol = 1 },
api.nvim_win_text_height(0, { start_row = 2, start_vcol = X })
)
end)
it('with virt_lines above max_height row', function()
screen:try_resize(45, 10)
exec('call setline(1, range(1, 7) + ["foo"->repeat(20)])')
api.nvim_buf_set_extmark(0, ns, 6, 0, { virt_lines = { { { 'VIRT LINE 1' } } } })
screen:expect([[
^1 |
2 |
3 |
4 |
5 |
6 |
7 |
VIRT LINE 1 |
foofoofoofoofoofoofoofoofoofoofoofoofoofoo{1:@@@}|
|
]])
eq(
{ all = 10, fill = 1, end_row = 7, end_vcol = 45 },
api.nvim_win_text_height(0, { max_height = api.nvim_win_get_height(0) })
)
end)
end)
describe('open_win', function()
it('disallowed in cmdwin if enter=true or buf=cmdwin_buf', function()
local new_buf = api.nvim_create_buf(true, true)
feed('q:')
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_open_win, new_buf, true, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
)
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_open_win, 0, false, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
)
matches(
'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
pcall_err(
exec_lua,
[[
local cmdwin_buf = vim.api.nvim_get_current_buf()
vim._with({buf = vim.api.nvim_create_buf(false, true)}, function()
vim.api.nvim_open_win(cmdwin_buf, false, {
relative='editor', row=5, col=5, width=5, height=5,
})
end)
]]
)
)
eq(
new_buf,
api.nvim_win_get_buf(api.nvim_open_win(new_buf, false, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
}))
)
end)
it('aborts if buffer is invalid', function()
local wins_before = api.nvim_list_wins()
eq(
'Invalid buffer id: 1337',
pcall_err(api.nvim_open_win, 1337, false, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
)
eq(wins_before, api.nvim_list_wins())
end)
describe('creates a split window above', function()
local function test_open_win_split_above(key, val)
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, true, {
[key] = val,
height = 10,
})
eq('', api.nvim_win_get_config(win).relative)
eq(10, api.nvim_win_get_height(win))
local layout = fn.winlayout()
eq({
'col',
{
{ 'leaf', win },
{ 'leaf', initial_win },
},
}, layout)
end
it("with split = 'above'", function()
test_open_win_split_above('split', 'above')
end)
it("with vertical = false and 'nosplitbelow'", function()
api.nvim_set_option_value('splitbelow', false, {})
test_open_win_split_above('vertical', false)
end)
end)
describe('creates a split window below', function()
local function test_open_win_split_below(key, val)
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, true, {
[key] = val,
height = 15,
})
eq('', api.nvim_win_get_config(win).relative)
eq(15, api.nvim_win_get_height(win))
local layout = fn.winlayout()
eq({
'col',
{
{ 'leaf', initial_win },
{ 'leaf', win },
},
}, layout)
end
it("with split = 'below'", function()
test_open_win_split_below('split', 'below')
end)
it("with vertical = false and 'splitbelow'", function()
api.nvim_set_option_value('splitbelow', true, {})
test_open_win_split_below('vertical', false)
end)
end)
describe('creates a split window to the left', function()
local function test_open_win_split_left(key, val)
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, true, {
[key] = val,
width = 25,
})
eq('', api.nvim_win_get_config(win).relative)
eq(25, api.nvim_win_get_width(win))
local layout = fn.winlayout()
eq({
'row',
{
{ 'leaf', win },
{ 'leaf', initial_win },
},
}, layout)
end
it("with split = 'left'", function()
test_open_win_split_left('split', 'left')
end)
it("with vertical = true and 'nosplitright'", function()
api.nvim_set_option_value('splitright', false, {})
test_open_win_split_left('vertical', true)
end)
end)
describe('creates a split window to the right', function()
local function test_open_win_split_right(key, val)
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, true, {
[key] = val,
width = 30,
})
eq('', api.nvim_win_get_config(win).relative)
eq(30, api.nvim_win_get_width(win))
local layout = fn.winlayout()
eq({
'row',
{
{ 'leaf', initial_win },
{ 'leaf', win },
},
}, layout)
end
it("with split = 'right'", function()
test_open_win_split_right('split', 'right')
end)
it("with vertical = true and 'splitright'", function()
api.nvim_set_option_value('splitright', true, {})
test_open_win_split_right('vertical', true)
end)
end)
it("doesn't change tp_curwin when splitting window in another tab with enter=false", function()
local tab1 = api.nvim_get_current_tabpage()
local tab1_win = api.nvim_get_current_win()
n.command('tabnew')
local tab2 = api.nvim_get_current_tabpage()
local tab2_win = api.nvim_get_current_win()
eq({ tab1_win, tab2_win }, api.nvim_list_wins())
eq({ tab1, tab2 }, api.nvim_list_tabpages())
api.nvim_set_current_tabpage(tab1)
eq(tab1_win, api.nvim_get_current_win())
local tab2_prevwin = fn.tabpagewinnr(tab2, '#')
-- split in tab2 whine in tab2, with enter = false
local tab2_win2 = api.nvim_open_win(api.nvim_create_buf(false, true), false, {
win = tab2_win,
split = 'right',
})
eq(tab1_win, api.nvim_get_current_win()) -- we should still be in the first tp
eq(tab1_win, api.nvim_tabpage_get_win(tab1))
eq(tab2_win, api.nvim_tabpage_get_win(tab2)) -- tab2's tp_curwin should not have changed
eq(tab2_prevwin, fn.tabpagewinnr(tab2, '#')) -- tab2's tp_prevwin should not have changed
eq({ tab1_win, tab2_win, tab2_win2 }, api.nvim_list_wins())
eq({ tab2_win, tab2_win2 }, api.nvim_tabpage_list_wins(tab2))
end)
it('creates splits in the correct location', function()
local first_win = api.nvim_get_current_win()
-- specifying window 0 should create a split next to the current window
local win = api.nvim_open_win(0, true, {
vertical = false,
})
local layout = fn.winlayout()
eq({
'col',
{
{ 'leaf', win },
{ 'leaf', first_win },
},
}, layout)
-- not specifying a window should create a top-level split
local win2 = api.nvim_open_win(0, true, {
split = 'left',
win = -1,
})
layout = fn.winlayout()
eq({
'row',
{
{ 'leaf', win2 },
{
'col',
{
{ 'leaf', win },
{ 'leaf', first_win },
},
},
},
}, layout)
-- specifying a window should create a split next to that window
local win3 = api.nvim_open_win(0, true, {
win = win,
vertical = false,
})
layout = fn.winlayout()
eq({
'row',
{
{ 'leaf', win2 },
{
'col',
{
{ 'leaf', win3 },
{ 'leaf', win },
{ 'leaf', first_win },
},
},
},
}, layout)
end)
it('opens floating windows in other tabpages', function()
local first_win = api.nvim_get_current_win()
local first_tab = api.nvim_get_current_tabpage()
command('tabnew')
local new_tab = api.nvim_get_current_tabpage()
local win = api.nvim_open_win(0, false, {
relative = 'win',
win = first_win,
width = 5,
height = 5,
row = 1,
col = 1,
})
eq(api.nvim_win_get_tabpage(win), first_tab)
eq(api.nvim_get_current_tabpage(), new_tab)
end)
it('switches to new windows in non-current tabpages when enter=true', function()
local first_win = api.nvim_get_current_win()
local first_tab = api.nvim_get_current_tabpage()
command('tabnew')
local win = api.nvim_open_win(0, true, {
relative = 'win',
win = first_win,
width = 5,
height = 5,
row = 1,
col = 1,
})
eq(api.nvim_win_get_tabpage(win), first_tab)
eq(api.nvim_get_current_tabpage(), first_tab)
end)
local function setup_tabbed_autocmd_test()
local info = {}
info.orig_buf = api.nvim_get_current_buf()
info.other_buf = api.nvim_create_buf(true, true)
info.tab1_curwin = api.nvim_get_current_win()
info.tab1 = api.nvim_get_current_tabpage()
command('tab split | split')
info.tab2_curwin = api.nvim_get_current_win()
info.tab2 = api.nvim_get_current_tabpage()
exec([=[
tabfirst
let result = []
autocmd TabEnter * let result += [["TabEnter", nvim_get_current_tabpage()]]
autocmd TabLeave * let result += [["TabLeave", nvim_get_current_tabpage()]]
autocmd WinEnter * let result += [["WinEnter", win_getid()]]
autocmd WinLeave * let result += [["WinLeave", win_getid()]]
autocmd WinNew * let result += [["WinNew", win_getid()]]
autocmd WinClosed * let result += [["WinClosed", str2nr(expand("<afile>"))]]
autocmd BufEnter * let result += [["BufEnter", win_getid(), bufnr()]]
autocmd BufLeave * let result += [["BufLeave", win_getid(), bufnr()]]
autocmd BufWinEnter * let result += [["BufWinEnter", win_getid(), bufnr()]]
autocmd BufWinLeave * let result += [["BufWinLeave", win_getid(), bufnr()]]
]=])
return info
end
it('noautocmd option works', function()
local info = setup_tabbed_autocmd_test()
api.nvim_open_win(
info.other_buf,
true,
{ split = 'left', win = info.tab2_curwin, noautocmd = true }
)
eq({}, eval('result'))
api.nvim_open_win(
info.orig_buf,
true,
{ relative = 'editor', row = 0, col = 0, width = 10, height = 10, noautocmd = true }
)
eq({}, eval('result'))
end)
it('fires expected autocmds when creating splits without entering', function()
local info = setup_tabbed_autocmd_test()
-- For these, don't want BufWinEnter if visiting the same buffer, like :{s}buffer.
-- Same tabpage, same buffer.
local new_win = api.nvim_open_win(0, false, { split = 'left', win = info.tab1_curwin })
eq({
{ 'WinNew', new_win },
}, eval('result'))
eq(info.tab1_curwin, api.nvim_get_current_win())
-- Other tabpage, same buffer.
command('let result = []')
new_win = api.nvim_open_win(0, false, { split = 'left', win = info.tab2_curwin })
eq({
{ 'WinNew', new_win },
}, eval('result'))
eq(info.tab1_curwin, api.nvim_get_current_win())
-- Same tabpage, other buffer.
command('let result = []')
new_win = api.nvim_open_win(info.other_buf, false, { split = 'left', win = info.tab1_curwin })
eq({
{ 'WinNew', new_win },
{ 'BufWinEnter', new_win, info.other_buf },
}, eval('result'))
eq(info.tab1_curwin, api.nvim_get_current_win())
-- Other tabpage, other buffer.
command('let result = []')
new_win = api.nvim_open_win(info.other_buf, false, { split = 'left', win = info.tab2_curwin })
eq({
{ 'WinNew', new_win },
{ 'BufWinEnter', new_win, info.other_buf },
}, eval('result'))
eq(info.tab1_curwin, api.nvim_get_current_win())
end)
it('fires expected autocmds when creating and entering splits', function()
local info = setup_tabbed_autocmd_test()
-- Same tabpage, same buffer.
local new_win = api.nvim_open_win(0, true, { split = 'left', win = info.tab1_curwin })
eq({
{ 'WinNew', new_win },
{ 'WinLeave', info.tab1_curwin },
{ 'WinEnter', new_win },
}, eval('result'))
-- Same tabpage, other buffer.
api.nvim_set_current_win(info.tab1_curwin)
command('let result = []')
new_win = api.nvim_open_win(info.other_buf, true, { split = 'left', win = info.tab1_curwin })
eq({
{ 'WinNew', new_win },
{ 'WinLeave', info.tab1_curwin },
{ 'WinEnter', new_win },
{ 'BufLeave', new_win, info.orig_buf },
{ 'BufEnter', new_win, info.other_buf },
{ 'BufWinEnter', new_win, info.other_buf },
}, eval('result'))
-- For these, the other tabpage's prevwin and curwin will change like we switched from its old
-- curwin to the new window, so the extra events near TabEnter reflect that.
-- Other tabpage, same buffer.
api.nvim_set_current_win(info.tab1_curwin)
command('let result = []')
new_win = api.nvim_open_win(0, true, { split = 'left', win = info.tab2_curwin })
eq({
{ 'WinNew', new_win },
{ 'WinLeave', info.tab1_curwin },
{ 'TabLeave', info.tab1 },
{ 'WinEnter', info.tab2_curwin },
{ 'TabEnter', info.tab2 },
{ 'WinLeave', info.tab2_curwin },
{ 'WinEnter', new_win },
}, eval('result'))
-- Other tabpage, other buffer.
api.nvim_set_current_win(info.tab2_curwin)
api.nvim_set_current_win(info.tab1_curwin)
command('let result = []')
new_win = api.nvim_open_win(info.other_buf, true, { split = 'left', win = info.tab2_curwin })
eq({
{ 'WinNew', new_win },
{ 'WinLeave', info.tab1_curwin },
{ 'TabLeave', info.tab1 },
{ 'WinEnter', info.tab2_curwin },
{ 'TabEnter', info.tab2 },
{ 'WinLeave', info.tab2_curwin },
{ 'WinEnter', new_win },
{ 'BufLeave', new_win, info.orig_buf },
{ 'BufEnter', new_win, info.other_buf },
{ 'BufWinEnter', new_win, info.other_buf },
}, eval('result'))
-- Other tabpage, other buffer; but other tabpage's curwin has a new buffer active.
api.nvim_set_current_win(info.tab2_curwin)
local new_buf = api.nvim_create_buf(true, true)
api.nvim_set_current_buf(new_buf)
api.nvim_set_current_win(info.tab1_curwin)
command('let result = []')
new_win = api.nvim_open_win(info.other_buf, true, { split = 'left', win = info.tab2_curwin })
eq({
{ 'WinNew', new_win },
{ 'BufLeave', info.tab1_curwin, info.orig_buf },
{ 'WinLeave', info.tab1_curwin },
{ 'TabLeave', info.tab1 },
{ 'WinEnter', info.tab2_curwin },
{ 'TabEnter', info.tab2 },
{ 'BufEnter', info.tab2_curwin, new_buf },
{ 'WinLeave', info.tab2_curwin },
{ 'WinEnter', new_win },
{ 'BufLeave', new_win, new_buf },
{ 'BufEnter', new_win, info.other_buf },
{ 'BufWinEnter', new_win, info.other_buf },
}, eval('result'))
end)
it('OK when new window is moved to other tabpage by autocommands', function()
-- Use nvim_win_set_config in the autocommands, as other methods of moving a window to a
-- different tabpage (e.g: wincmd T) actually creates a new window.
local tab0 = api.nvim_get_current_tabpage()
local tab0_win = api.nvim_get_current_win()
command('tabnew')
local new_buf = api.nvim_create_buf(true, true)
local tab1 = api.nvim_get_current_tabpage()
local tab1_parent = api.nvim_get_current_win()
command(
'tabfirst | autocmd WinNew * ++once call nvim_win_set_config(0, #{split: "left", win: '
.. tab1_parent
.. '})'
)
local new_win = api.nvim_open_win(new_buf, true, { split = 'left' })
eq(tab1, api.nvim_get_current_tabpage())
eq(new_win, api.nvim_get_current_win())
eq(new_buf, api.nvim_get_current_buf())
-- nvim_win_set_config called after entering. It doesn't follow a curwin that is moved to a
-- different tabpage, but instead moves to the win filling the space, which is tab0_win.
command(
'tabfirst | autocmd WinEnter * ++once call nvim_win_set_config(0, #{split: "left", win: '
.. tab1_parent
.. '})'
)
new_win = api.nvim_open_win(new_buf, true, { split = 'left' })
eq(tab0, api.nvim_get_current_tabpage())
eq(tab0_win, api.nvim_get_current_win())
eq(tab1, api.nvim_win_get_tabpage(new_win))
eq(new_buf, api.nvim_win_get_buf(new_win))
command(
'tabfirst | autocmd BufEnter * ++once call nvim_win_set_config(0, #{split: "left", win: '
.. tab1_parent
.. '})'
)
new_win = api.nvim_open_win(new_buf, true, { split = 'left' })
eq(tab0, api.nvim_get_current_tabpage())
eq(tab0_win, api.nvim_get_current_win())
eq(tab1, api.nvim_win_get_tabpage(new_win))
eq(new_buf, api.nvim_win_get_buf(new_win))
end)
it('does not fire BufWinEnter if win_set_buf fails', function()
exec([[
set nohidden modified
autocmd WinNew * ++once only!
let fired = v:false
autocmd BufWinEnter * ++once let fired = v:true
]])
eq(
'Vim:E37: No write since last change (add ! to override)',
pcall_err(api.nvim_open_win, api.nvim_create_buf(true, true), false, { split = 'left' })
)
eq(false, eval('fired'))
end)
it('fires Buf* autocommands when `!enter` if window is entered via autocommands', function()
exec([[
autocmd WinNew * ++once only!
let fired = v:false
autocmd BufEnter * ++once let fired = v:true
]])
api.nvim_open_win(api.nvim_create_buf(true, true), false, { split = 'left' })
eq(true, eval('fired'))
end)
it('no heap-use-after-free if target buffer deleted by autocommands', function()
local cur_buf = api.nvim_get_current_buf()
local new_buf = api.nvim_create_buf(true, true)
command('autocmd WinNew * ++once call nvim_buf_delete(' .. new_buf .. ', #{force: 1})')
api.nvim_open_win(new_buf, true, { split = 'left' })
eq(cur_buf, api.nvim_get_current_buf())
end)
it('checks if splitting disallowed', function()
command('split | autocmd WinEnter * ++once call nvim_open_win(0, 0, #{split: "right"})')
matches("E242: Can't split a window while closing another$", pcall_err(command, 'quit'))
-- E242 is not needed for floats.
exec([[
split
autocmd WinEnter * ++once let g:win = nvim_open_win(0, 0, #{relative: "editor", row: 0, col: 0, width: 5, height: 5})
quit
]])
eq('editor', eval('nvim_win_get_config(g:win).relative'))
command('only | autocmd BufHidden * ++once call nvim_open_win(0, 0, #{split: "left"})')
matches(
'E1159: Cannot split a window when closing the buffer$',
pcall_err(command, 'new | quit')
)
local w = api.nvim_get_current_win()
command(
'only | new | autocmd BufHidden * ++once call nvim_open_win(0, 0, #{split: "left", win: '
.. w
.. '})'
)
matches(
'E1159: Cannot split a window when closing the buffer$',
pcall_err(api.nvim_win_close, w, true)
)
-- OK when using a buffer that isn't closing.
w = api.nvim_get_current_win()
command(
'only | autocmd BufHidden * ++once call nvim_open_win(bufnr("#"), 0, #{split: "left", win: '
.. w
.. '})'
)
command('new | quit')
-- Apply to opening floats too, as that can similarly create new views into a closing buffer.
-- For example, the following would open a float into an unloaded buffer:
exec([[
only
new
let g:buf = bufnr()
autocmd BufUnload * ++once call nvim_open_win(g:buf, 0, #{relative: "editor", width: 5, height: 5, row: 1, col: 1})
setlocal bufhidden=unload
]])
matches('E1159: Cannot open a float when closing the buffer$', pcall_err(command, 'quit'))
eq(false, eval('nvim_buf_is_loaded(g:buf)'))
eq(0, eval('win_findbuf(g:buf)->len()'))
-- Only checking b_locked_split for the target buffer is insufficient, as naughty autocommands
-- can cause win_set_buf to remain in a closing curbuf:
exec([[
only
new
let g:buf = bufnr()
autocmd BufWipeout * ++once ++nested let g:buf2 = nvim_create_buf(1, 0)
\| execute 'autocmd BufLeave * ++once call nvim_buf_delete(g:buf2, #{force: 1})'
\| setlocal bufhidden=
\| call nvim_open_win(g:buf2, 1, #{relative: 'editor', width: 5, height: 5, col: 5, row: 5})
setlocal bufhidden=wipe
]])
matches('E1159: Cannot open a float when closing the buffer$', pcall_err(command, 'quit'))
eq(false, eval('nvim_buf_is_loaded(g:buf)'))
eq(0, eval('win_findbuf(g:buf)->len()'))
-- BufLeave shouldn't run here (buf2 isn't deleted and remains hidden)
eq(true, eval('nvim_buf_is_loaded(g:buf2)'))
eq(0, eval('win_findbuf(g:buf2)->len()'))
end)
it('restores last known cursor position if BufWinEnter did not move it', function()
-- This test mostly exists to ensure BufWinEnter is executed before enter_buffer's epilogue.
local buf = api.nvim_get_current_buf()
insert([[
foo
bar baz .etc
i love autocommand bugs!
supercalifragilisticexpialidocious
marvim is actually a human
llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
]])
api.nvim_win_set_cursor(0, { 5, 2 })
command('set nostartofline | enew')
local new_win = api.nvim_open_win(buf, false, { split = 'left' })
eq({ 5, 2 }, api.nvim_win_get_cursor(new_win))
exec([[
only!
autocmd BufWinEnter * ++once normal! j6l
]])
new_win = api.nvim_open_win(buf, false, { split = 'left' })
eq({ 2, 6 }, api.nvim_win_get_cursor(new_win))
end)
it('does not block all win_set_buf autocommands if !enter and !noautocmd', function()
local new_buf = fn.bufadd('foobarbaz')
exec([[
let triggered = ""
autocmd BufReadCmd * ++once let triggered = bufname()
]])
api.nvim_open_win(new_buf, false, { split = 'left' })
eq('foobarbaz', eval('triggered'))
end)
it('sets error when no room', function()
matches('E36: Not enough room$', pcall_err(command, 'execute "split|"->repeat(&lines)'))
matches(
'E36: Not enough room$',
pcall_err(api.nvim_open_win, 0, true, { split = 'above', win = 0 })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_open_win, 0, true, { split = 'below', win = 0 })
)
end)
it("can create split window when 'winborder' is set", function()
local old_win = api.nvim_get_current_win()
api.nvim_set_option_value('winborder', 'single', {})
local new_win = api.nvim_open_win(0, false, { split = 'right', win = 0 })
eq({ 'row', { { 'leaf', old_win }, { 'leaf', new_win } } }, fn.winlayout())
eq('', api.nvim_win_get_config(new_win).relative)
end)
describe("with 'autochdir'", function()
local topdir
local otherbuf
before_each(function()
command('set shellslash')
topdir = fn.getcwd()
t.mkdir(topdir .. '/Xacd')
t.mkdir(topdir .. '/Xacd/foo')
otherbuf = api.nvim_create_buf(false, true)
api.nvim_buf_set_name(otherbuf, topdir .. '/Xacd/baz.txt')
command('set autochdir')
command('edit Xacd/foo/bar.txt')
eq(topdir .. '/Xacd/foo', fn.getcwd())
end)
after_each(function()
n.rmdir(topdir .. '/Xacd')
end)
it('does not change cwd with enter=false #15280', function()
api.nvim_open_win(
otherbuf,
false,
{ relative = 'editor', height = 5, width = 5, row = 5, col = 5 }
)
eq(topdir .. '/Xacd/foo', fn.getcwd())
end)
it('changes cwd with enter=true', function()
api.nvim_open_win(
otherbuf,
true,
{ relative = 'editor', height = 5, width = 5, row = 5, col = 5 }
)
eq(topdir .. '/Xacd', fn.getcwd())
end)
end)
it('no memory leak with valid title and invalid footer', function()
eq(
'title/footer must be string or array',
pcall_err(api.nvim_open_win, 0, false, {
relative = 'editor',
row = 10,
col = 10,
height = 10,
width = 10,
border = 'single',
title = { { 'TITLE' } },
footer = 0,
})
)
end)
it('no memory leak with invalid title and valid footer', function()
eq(
'title/footer must be string or array',
pcall_err(api.nvim_open_win, 0, false, {
relative = 'editor',
row = 10,
col = 10,
height = 10,
width = 10,
border = 'single',
title = 0,
footer = { { 'FOOTER' } },
})
)
end)
it('no crash when closing the only non-float in other tabpage #31236', function()
local tp = api.nvim_get_current_tabpage()
local split_win = api.nvim_get_current_win()
local float_win = api.nvim_open_win(
0,
false,
{ relative = 'editor', width = 5, height = 5, row = 1, col = 1 }
)
command('tabnew')
api.nvim_win_close(split_win, false)
eq(false, api.nvim_win_is_valid(split_win))
eq(false, api.nvim_win_is_valid(float_win))
eq(false, api.nvim_tabpage_is_valid(tp))
tp = api.nvim_get_current_tabpage()
split_win = api.nvim_get_current_win()
local float_buf = api.nvim_create_buf(true, false)
float_win = api.nvim_open_win(
float_buf,
false,
{ relative = 'editor', width = 5, height = 5, row = 1, col = 1 }
)
-- Set these options to prevent the float from being automatically closed.
api.nvim_set_option_value('modified', true, { buf = float_buf })
api.nvim_set_option_value('bufhidden', 'wipe', { buf = float_buf })
command('tabnew')
matches(
'E5601: Cannot close window, only floating window would remain$',
pcall_err(api.nvim_win_close, split_win, false)
)
eq(true, api.nvim_win_is_valid(split_win))
eq(true, api.nvim_win_is_valid(float_win))
eq(true, api.nvim_tabpage_is_valid(tp))
api.nvim_set_current_win(float_win)
api.nvim_win_close(split_win, true) -- Force it this time.
eq(false, api.nvim_win_is_valid(split_win))
eq(false, api.nvim_win_is_valid(float_win))
eq(false, api.nvim_tabpage_is_valid(tp))
-- Ensure opening a float after the initial check (like in WinClosed) doesn't crash...
exec([[
tabnew
let g:tp = nvim_get_current_tabpage()
let g:win = win_getid()
tabprevious
autocmd! WinClosed * ++once call nvim_open_win(0, 0, #{win: g:win, relative: 'win', width: 5, height: 5, row: 5, col: 5})
]])
matches(
'E5601: Cannot close window, only floating window would remain$',
pcall_err(command, 'call nvim_win_close(g:win, 0)')
)
eq(true, eval 'nvim_tabpage_is_valid(g:tp)')
exec([[
tabnew
let g:tp = nvim_get_current_tabpage()
let g:win = win_getid()
let g:buf = bufnr()
tabprevious
let s:buf2 = nvim_create_buf(0, 0)
call setbufvar(s:buf2, '&modified', 1)
call setbufvar(s:buf2, '&bufhidden', 'wipe')
autocmd! WinClosed * ++once call nvim_open_win(s:buf2, 0, #{win: g:win, relative: 'win', width: 5, height: 5, row: 5, col: 5})
]])
matches(
'E5601: Cannot close window, only floating window would remain$',
pcall_err(command, 'call nvim_buf_delete(g:buf, #{force: 1})')
)
eq(true, eval 'nvim_tabpage_is_valid(g:tp)')
end)
it('respects requested size for large splits', function()
command('vsplit')
local win = api.nvim_open_win(0, false, { win = -1, split = 'right', width = 38 })
eq(38, api.nvim_win_get_width(win))
-- No zero-sized windows (e.g: from skipping forced equalization in win_split_ins) if
-- requesting a chonky window; that could lead to crashes!
api.nvim_open_win(0, false, { win = -1, split = 'right', width = 9999 })
eq({ 1, 1, 1, 74 }, eval("range(1, winnr('$'))->map({_, nr -> winwidth(nr)})"))
command('split')
win = api.nvim_open_win(0, false, { win = 0, split = 'below', height = 10 })
eq(10, api.nvim_win_get_height(win))
-- Still defaults to half-sized when no size was specified.
command('only')
eq(80, api.nvim_win_get_width(0))
api.nvim_open_win(0, true, { split = 'right' })
eq(40, api.nvim_win_get_width(0))
eq(22, api.nvim_win_get_height(0))
api.nvim_open_win(0, true, { split = 'below' })
eq(11, api.nvim_win_get_height(0))
end)
it('no leak when win_set_buf fails and window is closed immediately', function()
-- Following used to leak.
command('autocmd BufEnter * ++once quit! | throw 1337')
eq(
'Window was closed immediately',
pcall_err(
api.nvim_open_win,
api.nvim_create_buf(true, true),
true,
{ relative = 'editor', width = 5, height = 5, row = 1, col = 1 }
)
)
-- If the window wasn't closed, still set errors from win_set_buf.
command('autocmd BufEnter * ++once throw 1337')
eq(
'BufEnter Autocommands for "*": 1337',
pcall_err(
api.nvim_open_win,
api.nvim_create_buf(true, true),
true,
{ relative = 'editor', width = 5, height = 5, row = 1, col = 1 }
)
)
end)
it('redraws after setting minimal style', function()
local screen = Screen.new(10, 10)
-- Autocommand processes pending redraws earlier than when minimal style is set, so it doesn't
-- implicitly rely on those.
exec([[
set cursorline cursorcolumn number
autocmd WinNew * ++once redraw | let g:triggered = 1
]])
screen:expect([[
{15: 1 }{21:^ }|
{1:~ }|*8
|
]])
api.nvim_open_win(0, false, { style = 'minimal', split = 'below' })
eq(1, eval('g:triggered'))
screen:expect([[
{15: 1 }{21:^ }|
{1:~ }|*2
{2:[No Name] }|
|*4
{2:[No Name] }|
|
]])
-- Also check nvim_win_set_config: only set style to avoid redraws from other config fields.
api.nvim_win_set_config(0, { style = 'minimal' })
screen:expect([[
^ |
|*2
{3:[No Name] }|
|*4
{2:[No Name] }|
|
]])
end)
end)
describe('set_config', function()
it("uses 'winborder' when converting a split to a floating window", function()
api.nvim_set_option_value('winborder', 'single', {})
command('split')
local winid = api.nvim_get_current_win()
-- Convert split to float without specifying border
api.nvim_win_set_config(winid, {
relative = 'editor',
row = 2,
col = 2,
width = 10,
height = 5,
})
local config = api.nvim_win_get_config(winid)
eq('┌', config.border[1])
end)
it('erases border of a floating window when converting to split window', function()
api.nvim_set_option_value('winborder', 'single', {})
local winid = api.nvim_open_win(api.nvim_create_buf(false, false), false, {
relative = 'editor',
row = 2,
col = 2,
width = 10,
height = 5,
})
local config = api.nvim_win_get_config(winid)
eq('┌', config.border[1])
api.nvim_win_set_config(winid, { split = 'right', win = 0 })
config = api.nvim_win_get_config(winid)
eq(nil, config.border)
end)
it('moves a split into a float', function()
local win = api.nvim_open_win(0, true, {
vertical = false,
})
eq('', api.nvim_win_get_config(win).relative)
api.nvim_win_set_config(win, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
eq('editor', api.nvim_win_get_config(win).relative)
end)
it('throws error when attempting to move the last non-floating window', function()
local err = pcall_err(api.nvim_win_set_config, 0, {
vertical = false,
})
eq('Cannot move last non-floating window', err)
local win1 = api.nvim_get_current_win()
command('tabnew')
eq(
'Cannot move last non-floating window',
pcall_err(api.nvim_win_set_config, 0, { win = win1, split = 'left' })
)
api.nvim_open_win(0, false, { relative = 'editor', width = 5, height = 5, row = 1, col = 1 })
eq(
'Cannot move last non-floating window',
pcall_err(api.nvim_win_set_config, 0, { win = win1, split = 'left' })
)
-- If it's no longer the last non-float, still an error if autocommands make it the last
-- non-float again before it's moved.
command('vsplit')
exec_lua(function()
vim.api.nvim_create_autocmd('WinEnter', {
once = true,
callback = function()
vim.api.nvim_win_set_config(
0,
{ relative = 'editor', width = 5, height = 5, row = 1, col = 1 }
)
end,
})
end)
eq(
'Cannot move last non-floating window',
pcall_err(api.nvim_win_set_config, 0, { win = win1, split = 'left' })
)
end)
it('passing retval of get_config results in no-op', function()
-- simple split layout
local win = api.nvim_open_win(0, true, {
split = 'left',
})
local layout = fn.winlayout()
local config = api.nvim_win_get_config(win)
api.nvim_win_set_config(win, config)
eq(layout, fn.winlayout())
-- nested split layout
local win2 = api.nvim_open_win(0, true, {
vertical = true,
})
local win3 = api.nvim_open_win(0, true, {
win = win2,
vertical = false,
})
layout = fn.winlayout()
config = api.nvim_win_get_config(win2)
api.nvim_win_set_config(win2, config)
eq(layout, fn.winlayout())
config = api.nvim_win_get_config(win3)
api.nvim_win_set_config(win3, config)
eq(layout, fn.winlayout())
end)
it('moves a float into a split', function()
local layout = fn.winlayout()
eq('leaf', layout[1])
local win = api.nvim_open_win(0, true, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
api.nvim_win_set_config(win, {
split = 'below',
win = -1,
})
eq('', api.nvim_win_get_config(win).relative)
layout = fn.winlayout()
eq('col', layout[1])
eq(2, #layout[2])
eq(win, layout[2][2][2])
end)
it('respects the "split" option', function()
local layout = fn.winlayout()
eq('leaf', layout[1])
local first_win = layout[2]
local win = api.nvim_open_win(0, true, {
relative = 'editor',
row = 5,
col = 5,
width = 5,
height = 5,
})
api.nvim_win_set_config(win, {
split = 'right',
win = first_win,
})
layout = fn.winlayout()
eq('row', layout[1])
eq(2, #layout[2])
eq(win, layout[2][2][2])
local config = api.nvim_win_get_config(win)
eq('', config.relative)
eq('right', config.split)
api.nvim_win_set_config(win, {
split = 'below',
win = first_win,
})
layout = fn.winlayout()
eq('col', layout[1])
eq(2, #layout[2])
eq(win, layout[2][2][2])
config = api.nvim_win_get_config(win)
eq('', config.relative)
eq('below', config.split)
eq(
"non-float with 'win' requires at least 'split' or 'vertical'",
pcall_err(api.nvim_win_set_config, 0, { win = 0 })
)
eq(
"non-float with 'win' requires at least 'split' or 'vertical'",
pcall_err(api.nvim_win_set_config, 0, { win = 0, relative = '' })
)
-- "minimal" style takes effect immediately for a split.
api.nvim_set_option_value('cursorline', true, { win = win, scope = 'local' })
eq(true, api.nvim_get_option_value('cursorline', { win = win }))
api.nvim_win_set_config(win, { style = 'minimal' })
eq(false, api.nvim_get_option_value('cursorline', { win = win }))
end)
it('creates top-level splits', function()
local win = api.nvim_open_win(0, true, {
vertical = false,
})
local win2 = api.nvim_open_win(0, true, {
vertical = true,
win = -1,
})
local layout = fn.winlayout()
eq('row', layout[1])
eq(2, #layout[2])
eq(win2, layout[2][1][2])
api.nvim_win_set_config(win, {
split = 'below',
win = -1,
})
layout = fn.winlayout()
eq('col', layout[1])
eq(2, #layout[2])
eq('row', layout[2][1][1])
eq(win, layout[2][2][2])
end)
it('moves windows to other tabpages', function()
local first_tab = api.nvim_get_current_tabpage()
local first_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, false, { split = 'left' })
command('tabnew')
local new_tab = api.nvim_get_current_tabpage()
local tab2_win = api.nvim_get_current_win()
api.nvim_set_current_tabpage(first_tab)
-- move new win to new tabpage
api.nvim_win_set_config(win, { split = 'right', win = api.nvim_tabpage_get_win(new_tab) })
eq(new_tab, api.nvim_win_get_tabpage(win))
-- we are changing the config, the current tabpage should not change
eq(first_tab, api.nvim_get_current_tabpage())
api.nvim_set_current_tabpage(new_tab)
local layout = fn.winlayout()
eq({
'row',
{
{ 'leaf', api.nvim_tabpage_get_win(new_tab) },
{ 'leaf', win },
},
}, layout)
-- converting split into a float for a different tabpage is not yet supported
eq(
'Cannot configure split into float in another tabpage',
pcall_err(
api.nvim_win_set_config,
win,
{ relative = 'editor', row = 0, col = 0, width = 1, height = 1, win = first_win }
)
)
-- convert new win to float in new tabpage
api.nvim_win_set_config(win, { relative = 'editor', row = 2, col = 2, height = 2, width = 2 })
api.nvim_set_current_tabpage(first_tab)
-- move to other tabpage
api.nvim_win_set_config(win, { win = first_win })
eq(first_tab, api.nvim_win_get_tabpage(win))
eq({ first_win, win }, api.nvim_tabpage_list_wins(first_tab))
eq({ tab2_win }, api.nvim_tabpage_list_wins(new_tab))
-- unlike splits, negative win is invalid
eq('Invalid window id: -1', pcall_err(api.nvim_win_set_config, win, { win = -1 }))
end)
it('correctly moves curwin when moving curwin to a different tabpage', function()
local tab1 = api.nvim_get_current_tabpage()
local tab1_win = api.nvim_get_current_win()
command('tabnew')
local tab2 = api.nvim_get_current_tabpage()
local tab2_win = api.nvim_get_current_win()
api.nvim_set_current_tabpage(tab1) -- return to the initial tab
-- create and enter a new split
local win = api.nvim_open_win(0, true, {
vertical = false,
})
eq(tab1, api.nvim_win_get_tabpage(win))
eq({ win, tab1_win }, api.nvim_tabpage_list_wins(tab1))
-- move the current win to a different tabpage
api.nvim_win_set_config(win, {
split = 'right',
win = api.nvim_tabpage_get_win(tab2),
})
eq(tab1, api.nvim_get_current_tabpage())
-- win should have moved to tab2
eq(tab2, api.nvim_win_get_tabpage(win))
-- tp_curwin of tab2 should not have changed
eq(tab2_win, api.nvim_tabpage_get_win(tab2))
-- win lists should be correct
eq({ tab2_win, win }, api.nvim_tabpage_list_wins(tab2))
eq({ tab1_win }, api.nvim_tabpage_list_wins(tab1))
-- current win should have moved to neighboring win
eq(tab1_win, api.nvim_tabpage_get_win(tab1))
api.nvim_set_current_tabpage(tab2)
-- convert new win to float
api.nvim_win_set_config(win, { relative = 'editor', row = 2, col = 2, height = 2, width = 2 })
api.nvim_set_current_win(win)
api.nvim_win_set_config(win, { relative = 'win', win = tab1_win, row = 3, col = 3 })
eq(tab1, api.nvim_win_get_tabpage(win))
eq(tab2, api.nvim_get_current_tabpage())
eq({ tab1_win, win }, api.nvim_tabpage_list_wins(tab1))
end)
it('splits windows in non-current tabpage', function()
local curtab = api.nvim_get_current_tabpage()
command('tabnew')
local tabnr = api.nvim_get_current_tabpage()
command('tabprev') -- return to the initial tab
local win = api.nvim_open_win(0, false, {
vertical = false,
win = api.nvim_tabpage_get_win(tabnr),
})
eq(tabnr, api.nvim_win_get_tabpage(win))
-- since enter = false, the current tabpage should not change
eq(curtab, api.nvim_get_current_tabpage())
end)
it('moves the current split window', function()
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, true, {
vertical = true,
})
local win2 = api.nvim_open_win(0, true, {
vertical = true,
})
api.nvim_set_current_win(win)
eq({
'row',
{
{ 'leaf', win2 },
{ 'leaf', win },
{ 'leaf', initial_win },
},
}, fn.winlayout())
api.nvim_win_set_config(0, {
vertical = false,
win = 0,
})
eq(win, api.nvim_get_current_win())
eq({
'col',
{
{ 'leaf', win },
{
'row',
{
{ 'leaf', win2 },
{ 'leaf', initial_win },
},
},
},
}, fn.winlayout())
api.nvim_set_current_win(win2)
local win3 = api.nvim_open_win(0, true, {
vertical = true,
})
eq(win3, api.nvim_get_current_win())
eq({
'col',
{
{ 'leaf', win },
{
'row',
{
{ 'leaf', win3 },
{ 'leaf', win2 },
{ 'leaf', initial_win },
},
},
},
}, fn.winlayout())
api.nvim_win_set_config(0, {
vertical = false,
win = 0,
})
eq(win3, api.nvim_get_current_win())
eq({
'col',
{
{ 'leaf', win },
{
'row',
{
{
'col',
{
{ 'leaf', win3 },
{ 'leaf', win2 },
},
},
{ 'leaf', initial_win },
},
},
},
}, fn.winlayout())
end)
it('closing new curwin when moving window to other tabpage works', function()
command('split | tabnew')
local t2_win = api.nvim_get_current_win()
command('tabfirst | autocmd WinEnter * ++once quit')
local t1_move_win = api.nvim_get_current_win()
-- win_set_config fails to switch away from "t1_move_win" because the WinEnter autocmd that
-- closed the window we're switched to returns us to "t1_move_win", as it filled the space.
eq(
'Failed to switch away from window ' .. t1_move_win,
pcall_err(api.nvim_win_set_config, t1_move_win, { win = t2_win, split = 'left' })
)
eq(t1_move_win, api.nvim_get_current_win())
command('split | split | autocmd WinEnter * ++once quit')
t1_move_win = api.nvim_get_current_win()
-- In this case, we closed the window that we got switched to, but doing so didn't switch us
-- back to "t1_move_win", which is fine.
api.nvim_win_set_config(t1_move_win, { win = t2_win, split = 'left' })
neq(t1_move_win, api.nvim_get_current_win())
end)
it('messing with "win" or "parent" when moving "win" to other tabpage', function()
command('split | tabnew')
local t2 = api.nvim_get_current_tabpage()
local t2_win1 = api.nvim_get_current_win()
command('split')
local t2_win2 = api.nvim_get_current_win()
command('split')
local t2_win3 = api.nvim_get_current_win()
command('tabfirst | autocmd WinEnter * ++once call nvim_win_close(' .. t2_win1 .. ', 1)')
local cur_win = api.nvim_get_current_win()
eq(
'Windows to split were closed',
pcall_err(api.nvim_win_set_config, 0, { win = t2_win1, split = 'left' })
)
eq(cur_win, api.nvim_get_current_win())
command('split | autocmd WinLeave * ++once quit!')
cur_win = api.nvim_get_current_win()
eq(
'Windows to split were closed',
pcall_err(api.nvim_win_set_config, 0, { win = t2_win2, split = 'left' })
)
neq(cur_win, api.nvim_get_current_win())
exec([[
split
autocmd WinLeave * ++once
\ call nvim_win_set_config(0, #{relative:'editor', row:0, col:0, width:5, height:5})
]])
cur_win = api.nvim_get_current_win()
eq(
'Floating state of windows to split changed',
pcall_err(api.nvim_win_set_config, 0, { win = t2_win3, split = 'left' })
)
eq('editor', api.nvim_win_get_config(0).relative)
eq(cur_win, api.nvim_get_current_win())
command('autocmd WinLeave * ++once wincmd J')
cur_win = api.nvim_get_current_win()
eq(
'Floating state of windows to split changed',
pcall_err(api.nvim_win_set_config, 0, { win = t2_win3, split = 'left' })
)
eq('', api.nvim_win_get_config(0).relative)
eq(cur_win, api.nvim_get_current_win())
-- Try to make "parent" floating. This should give the same error as before, but because
-- changing a split from another tabpage into a float isn't supported yet, check for that
-- error instead for now.
-- Use ":silent!" to avoid the one second delay from printing the error message.
exec(([[
autocmd WinLeave * ++once silent!
\ call nvim_win_set_config(%d, #{relative:'editor', row:0, col:0, width:5, height:5})
]]):format(t2_win3))
cur_win = api.nvim_get_current_win()
api.nvim_win_set_config(0, { win = t2_win3, split = 'left' })
matches(
'Cannot change window from different tabpage into float$',
api.nvim_get_vvar('errmsg')
)
-- The error doesn't abort moving the window (or maybe it should, if that's wanted?)
neq(cur_win, api.nvim_get_current_win())
eq(t2, api.nvim_win_get_tabpage(cur_win))
end)
it('expected autocmds when moving window to other tabpage', function()
local new_curwin = api.nvim_get_current_win()
command('split')
local win = api.nvim_get_current_win()
command('tabnew')
local parent = api.nvim_get_current_win()
exec([[
tabfirst
let result = []
autocmd WinEnter * let result += ["Enter", win_getid()]
autocmd WinLeave * let result += ["Leave", win_getid()]
autocmd WinNew * let result += ["New", win_getid()]
]])
api.nvim_win_set_config(0, { win = parent, split = 'left' })
-- Shouldn't see WinNew, as we're not creating any new windows, just moving existing ones.
eq({ 'Leave', win, 'Enter', new_curwin }, eval('result'))
end)
it('no autocmds when moving window in same or other tabpage', function()
local parent = api.nvim_get_current_win()
exec([[
split
let g:result = []
autocmd WinEnter * let g:result += ["Enter", win_getid()]
autocmd WinLeave * let g:result += ["Leave", win_getid()]
autocmd WinNew * let g:result += ["New", win_getid()]
]])
api.nvim_win_set_config(0, { win = parent, split = 'left' })
-- Shouldn't see any of those events, as we remain in the same window.
eq({}, eval('g:result'))
-- move float window from tab2 to tab1
command('tabdo only')
local tab1 = api.nvim_get_current_tabpage()
local tab1_win1 = api.nvim_get_current_win()
command('tabnew')
local fwin = api.nvim_open_win(0, false, {
relative = 'editor',
row = 2,
col = 2,
height = 2,
width = 2,
})
api.nvim_set_current_tabpage(tab1)
api.nvim_set_var('result', {})
api.nvim_win_set_config(fwin, { win = tab1_win1 })
eq({}, eval('g:result'))
end)
it('checks if splitting disallowed', function()
command('split | autocmd WinEnter * ++once call nvim_win_set_config(0, #{split: "right"})')
matches("E242: Can't split a window while closing another$", pcall_err(command, 'quit'))
command('autocmd BufHidden * ++once call nvim_win_set_config(0, #{split: "left"})')
matches(
'E1159: Cannot split a window when closing the buffer$',
pcall_err(command, 'new | quit')
)
-- OK when using window to different buffer.
local w = api.nvim_get_current_win()
command('autocmd BufHidden * ++once call nvim_win_set_config(' .. w .. ', #{split: "left"})')
command('new | quit')
end)
--- Returns a function to get information about the window layout, sizes and positions of a
--- tabpage.
local function define_tp_info_function()
exec_lua([[
function tp_info(tp)
return {
layout = vim.fn.winlayout(vim.api.nvim_tabpage_get_number(tp)),
pos_sizes = vim.tbl_map(
function(w)
local pos = vim.fn.win_screenpos(w)
return {
row = pos[1],
col = pos[2],
width = vim.fn.winwidth(w),
height = vim.fn.winheight(w)
}
end,
vim.api.nvim_tabpage_list_wins(tp)
)
}
end
]])
return function(tp)
return exec_lua('return tp_info(...)', tp)
end
end
it('attempt to move window with no room', function()
-- Fill the 2nd tabpage full of windows until we run out of room.
-- Use &laststatus=0 to ensure restoring missing statuslines doesn't affect things.
command('set laststatus=0 | tabnew')
matches('E36: Not enough room$', pcall_err(command, 'execute "split|"->repeat(&lines)'))
command('vsplit | wincmd | | wincmd p')
local t2 = api.nvim_get_current_tabpage()
local t2_cur_win = api.nvim_get_current_win()
local t2_top_split = fn.win_getid(1)
local t2_bot_split = fn.win_getid(fn.winnr('$'))
local t2_float = api.nvim_open_win(
0,
false,
{ relative = 'editor', row = 0, col = 0, width = 10, height = 10 }
)
local t2_float_config = api.nvim_win_get_config(t2_float)
local tp_info = define_tp_info_function()
local t2_info = tp_info(t2)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_top_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_top_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_bot_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_bot_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t2_float, { win = t2_top_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t2_float, { win = t2_top_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t2_float, { win = t2_bot_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t2_float, { win = t2_bot_split, split = 'below' })
)
eq(t2_cur_win, api.nvim_get_current_win())
eq(t2_info, tp_info(t2))
eq(t2_float_config, api.nvim_win_get_config(t2_float))
-- Try to move windows from the 1st tabpage to the 2nd.
command('tabfirst | split | wincmd _')
local t1 = api.nvim_get_current_tabpage()
local t1_cur_win = api.nvim_get_current_win()
local t1_float = api.nvim_open_win(
0,
false,
{ relative = 'editor', row = 5, col = 3, width = 7, height = 6 }
)
local t1_float_config = api.nvim_win_get_config(t1_float)
local t1_info = tp_info(t1)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_top_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_top_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_bot_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, 0, { win = t2_bot_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t1_float, { win = t2_top_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t1_float, { win = t2_top_split, split = 'below' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t1_float, { win = t2_bot_split, split = 'above' })
)
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t1_float, { win = t2_bot_split, split = 'below' })
)
eq(t1_cur_win, api.nvim_get_current_win())
eq(t1_info, tp_info(t1))
eq(t1_float_config, api.nvim_win_get_config(t1_float))
end)
it('attempt to move window from other tabpage with no room', function()
-- Fill up the 1st tabpage with horizontal splits, then create a 2nd with only a few. Go back
-- to the 1st and try to move windows from the 2nd (while it's non-current) to it. Check that
-- window positions and sizes in the 2nd are unchanged.
command('set laststatus=0')
matches('E36: Not enough room$', pcall_err(command, 'execute "split|"->repeat(&lines)'))
command('tab split')
local t2 = api.nvim_get_current_tabpage()
local t2_top = api.nvim_get_current_win()
command('belowright split')
local t2_mid_left = api.nvim_get_current_win()
command('belowright vsplit')
local t2_mid_right = api.nvim_get_current_win()
command('split | wincmd J')
local t2_bot = api.nvim_get_current_win()
local tp_info = define_tp_info_function()
local t2_info = tp_info(t2)
eq({
'col',
{
{ 'leaf', t2_top },
{
'row',
{
{ 'leaf', t2_mid_left },
{ 'leaf', t2_mid_right },
},
},
{ 'leaf', t2_bot },
},
}, t2_info.layout)
local function try_move_t2_wins_to_t1()
for _, w in ipairs({ t2_bot, t2_mid_left, t2_mid_right, t2_top }) do
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, w, { win = 0, split = 'below' })
)
eq(t2_info, tp_info(t2))
end
end
command('tabfirst')
try_move_t2_wins_to_t1()
-- Go to the 2nd tabpage to ensure nothing changes after win_comp_pos, last_status, .etc.
-- from enter_tabpage.
command('tabnext')
eq(t2_info, tp_info(t2))
-- Check things are fine with the global statusline too, for good measure.
-- Set it while the 2nd tabpage is current, so last_status runs for it.
command('set laststatus=3')
t2_info = tp_info(t2)
command('tabfirst')
try_move_t2_wins_to_t1()
end)
it('handles cmdwin and textlock restrictions', function()
command('tabnew')
local t2 = api.nvim_get_current_tabpage()
local t2_win = api.nvim_get_current_win()
command('tabfirst')
local t1_move_win = api.nvim_get_current_win()
command('split')
-- Can't move the cmdwin, or its old curwin to a different tabpage.
local old_curwin = api.nvim_get_current_win()
feed('q:')
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_config, 0, { split = 'left', win = t2_win })
)
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_config, old_curwin, { split = 'left', win = t2_win })
)
-- But we can move other windows.
api.nvim_win_set_config(t1_move_win, { split = 'left', win = t2_win })
eq(t2, api.nvim_win_get_tabpage(t1_move_win))
command('quit!')
-- Can't configure windows such that the cmdwin would become the only non-float.
command('only!')
feed('q:')
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(
api.nvim_win_set_config,
old_curwin,
{ relative = 'editor', row = 0, col = 0, width = 5, height = 5 }
)
)
-- old_curwin is now no longer the only other non-float, so we can make it floating now.
local t1_new_win = api.nvim_open_win(
api.nvim_create_buf(true, true),
false,
{ split = 'left', win = old_curwin }
)
api.nvim_win_set_config(
old_curwin,
{ relative = 'editor', row = 0, col = 0, width = 5, height = 5 }
)
eq('editor', api.nvim_win_get_config(old_curwin).relative)
-- ...which means we shouldn't be able to also make the new window floating too!
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(
api.nvim_win_set_config,
t1_new_win,
{ relative = 'editor', row = 0, col = 0, width = 5, height = 5 }
)
)
-- Nothing ought to stop us from making the cmdwin itself floating, though...
api.nvim_win_set_config(0, { relative = 'editor', row = 0, col = 0, width = 5, height = 5 })
eq('editor', api.nvim_win_get_config(0).relative)
-- We can't make our new window from before floating too, as it's now the only non-float.
eq(
'Cannot change last window into float',
pcall_err(
api.nvim_win_set_config,
t1_new_win,
{ relative = 'editor', row = 0, col = 0, width = 5, height = 5 }
)
)
command('quit!')
-- Can't switch away from window before moving it to a different tabpage during textlock.
exec(([[
new
call setline(1, 'foo')
setlocal debug=throw indentexpr=nvim_win_set_config(0,#{split:'left',win:%d})
]]):format(t2_win))
local cur_win = api.nvim_get_current_win()
matches(
'E565: Not allowed to change text or change window$',
pcall_err(command, 'normal! ==')
)
eq(cur_win, api.nvim_get_current_win())
end)
it('updates statusline when moving bottom split', function()
local screen = Screen.new(10, 10)
exec([[
set laststatus=0
belowright split
call nvim_win_set_config(0, #{split: 'above', win: win_getid(winnr('#'))})
]])
screen:expect([[
^ |
{1:~ }|*3
{3:[No Name] }|
|
{1:~ }|*3
|
]])
end)
it("updates tp_curwin of moved window's original tabpage", function()
local t1 = api.nvim_get_current_tabpage()
command('tab split | split')
local t2 = api.nvim_get_current_tabpage()
local t2_alt_win = api.nvim_get_current_win()
command('vsplit')
local t2_cur_win = api.nvim_get_current_win()
command('tabprevious')
eq(t2_cur_win, api.nvim_tabpage_get_win(t2))
-- tp_curwin is unchanged when moved within the same tabpage.
api.nvim_win_set_config(t2_cur_win, { split = 'left', win = t2_alt_win })
eq(t2_cur_win, api.nvim_tabpage_get_win(t2))
-- Also unchanged if the move failed.
command('let &winwidth = &columns | let &winminwidth = &columns')
matches(
'E36: Not enough room$',
pcall_err(api.nvim_win_set_config, t2_cur_win, { split = 'left', win = 0 })
)
eq(t2_cur_win, api.nvim_tabpage_get_win(t2))
command('set winminwidth& winwidth&')
-- But is changed if successfully moved to a different tabpage.
api.nvim_win_set_config(t2_cur_win, { split = 'left', win = 0 })
eq(t2_alt_win, api.nvim_tabpage_get_win(t2))
eq(t1, api.nvim_win_get_tabpage(t2_cur_win))
-- Now do it for a float, which has different altwin logic.
command('tabnext')
t2_cur_win =
api.nvim_open_win(0, true, { relative = 'editor', row = 5, col = 5, width = 5, height = 5 })
eq(t2_alt_win, fn.win_getid(fn.winnr('#')))
command('tabprevious')
eq(t2_cur_win, api.nvim_tabpage_get_win(t2))
api.nvim_win_set_config(t2_cur_win, { split = 'left', win = 0 })
eq(t2_alt_win, api.nvim_tabpage_get_win(t2))
eq(t1, api.nvim_win_get_tabpage(t2_cur_win))
end)
it('set_config cannot change "noautocmd" #36409', function()
local cfg = { relative = 'editor', row = 1, col = 1, height = 2, width = 2, noautocmd = true }
local win = api.nvim_open_win(0, false, cfg)
cfg.height = 10
eq(true, pcall(api.nvim_win_set_config, win, cfg))
cfg.noautocmd = false
eq(
"'noautocmd' cannot be changed with existing windows",
pcall_err(api.nvim_win_set_config, win, cfg)
)
end)
end)
describe('get_config', function()
it('includes border', function()
local b = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' }
local win = api.nvim_open_win(0, true, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
border = b,
})
local cfg = api.nvim_win_get_config(win)
eq(b, cfg.border)
end)
it('includes border with highlight group', function()
local b = {
{ 'a', 'Normal' },
{ 'b', 'Special' },
{ 'c', 'String' },
{ 'd', 'Comment' },
{ 'e', 'Visual' },
{ 'f', 'Error' },
{ 'g', 'Constant' },
{ 'h', 'PreProc' },
}
local win = api.nvim_open_win(0, true, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
border = b,
})
local cfg = api.nvim_win_get_config(win)
eq(b, cfg.border)
end)
it('includes title and footer', function()
local title = { { 'A', { 'StatusLine', 'TabLine' } }, { 'B' }, { 'C', 'WinBar' } }
local footer = { { 'A', 'WinBar' }, { 'B' }, { 'C', { 'StatusLine', 'TabLine' } } }
local win = api.nvim_open_win(0, true, {
relative = 'win',
row = 3,
col = 3,
width = 12,
height = 3,
border = 'single',
title = title,
footer = footer,
})
local cfg = api.nvim_win_get_config(win)
eq(title, cfg.title)
eq(footer, cfg.footer)
end)
it('includes split for normal windows', function()
local win = api.nvim_open_win(0, true, {
vertical = true,
win = -1,
})
eq('left', api.nvim_win_get_config(win).split)
api.nvim_win_set_config(win, {
vertical = false,
win = -1,
})
eq('above', api.nvim_win_get_config(win).split)
api.nvim_win_set_config(win, {
split = 'below',
win = -1,
})
eq('below', api.nvim_win_get_config(win).split)
end)
it('includes split when splitting with ex commands', function()
local win = api.nvim_get_current_win()
eq('left', api.nvim_win_get_config(win).split)
command('vsplit')
local win2 = api.nvim_get_current_win()
-- initial window now be marked as right split
-- since it was split with a vertical split
-- and 'splitright' is false by default
eq('right', api.nvim_win_get_config(win).split)
eq('left', api.nvim_win_get_config(win2).split)
api.nvim_set_option_value('splitbelow', true, {
scope = 'global',
})
api.nvim_win_close(win, true)
command('split')
local win3 = api.nvim_get_current_win()
eq('below', api.nvim_win_get_config(win3).split)
end)
it("includes the correct 'split' option in complex layouts", function()
local initial_win = api.nvim_get_current_win()
local win = api.nvim_open_win(0, false, {
split = 'right',
win = -1,
})
local win2 = api.nvim_open_win(0, false, {
split = 'below',
win = win,
})
api.nvim_win_set_config(win2, {
width = 50,
})
api.nvim_win_set_config(win, {
split = 'left',
win = -1,
})
local win3 = api.nvim_open_win(0, false, {
split = 'above',
win = -1,
})
local float = api.nvim_open_win(0, false, {
relative = 'editor',
width = 40,
height = 20,
col = 20,
row = 10,
})
api.nvim_win_set_config(float, {
split = 'right',
win = -1,
})
local layout = fn.winlayout()
eq({
'row',
{
{
'col',
{
{ 'leaf', win3 },
{
'row',
{
{ 'leaf', win },
{ 'leaf', initial_win },
{ 'leaf', win2 },
},
},
},
},
{
'leaf',
float,
},
},
}, layout)
eq('above', api.nvim_win_get_config(win3).split)
eq('left', api.nvim_win_get_config(win).split)
eq('left', api.nvim_win_get_config(initial_win).split)
eq('right', api.nvim_win_get_config(win2).split)
eq('right', api.nvim_win_get_config(float).split)
end)
it('includes style', function()
local unused_style1 = api.nvim_open_win(0, false, {
width = 10,
height = 10,
relative = 'editor',
row = 10,
col = 10,
})
local unused_style2 = api.nvim_open_win(0, false, {
width = 10,
height = 10,
relative = 'editor',
row = 10,
col = 10,
style = '',
})
local minimal_style = api.nvim_open_win(0, false, {
width = 10,
height = 10,
relative = 'editor',
row = 10,
col = 10,
style = 'minimal',
})
eq('', api.nvim_win_get_config(unused_style1).style)
eq('', api.nvim_win_get_config(unused_style2).style)
eq('minimal', api.nvim_win_get_config(minimal_style).style)
-- "style" is allowed for splits too.
eq('', api.nvim_win_get_config(0).relative)
eq('', api.nvim_win_get_config(0).style)
api.nvim_win_set_config(0, { style = 'minimal' })
eq('minimal', api.nvim_win_get_config(0).style)
api.nvim_win_set_config(0, { height = 1 }) -- "style" unchanged when not included.
eq('minimal', api.nvim_win_get_config(0).style)
api.nvim_win_set_config(0, { style = '' })
eq('', api.nvim_win_get_config(0).style)
end)
end)
describe('set_config', function()
it('no crash with invalid title', function()
local win = api.nvim_open_win(0, true, {
width = 10,
height = 10,
relative = 'editor',
row = 10,
col = 10,
title = { { 'test' } },
border = 'single',
})
eq(
'title/footer must be string or array',
pcall_err(api.nvim_win_set_config, win, { title = 0 })
)
command('redraw!')
assert_alive()
eq(
'title/footer cannot be an empty array',
pcall_err(api.nvim_win_set_config, win, { title = {} })
)
command('redraw!')
assert_alive()
end)
it('no crash with invalid footer', function()
local win = api.nvim_open_win(0, true, {
width = 10,
height = 10,
relative = 'editor',
row = 10,
col = 10,
footer = { { 'test' } },
border = 'single',
})
eq(
'title/footer must be string or array',
pcall_err(api.nvim_win_set_config, win, { footer = 0 })
)
command('redraw!')
assert_alive()
eq(
'title/footer cannot be an empty array',
pcall_err(api.nvim_win_set_config, win, { footer = {} })
)
command('redraw!')
assert_alive()
end)
describe('no crash or memory leak', function()
local win
before_each(function()
win = api.nvim_open_win(0, false, {
relative = 'editor',
row = 10,
col = 10,
height = 10,
width = 10,
border = 'single',
title = { { 'OLD_TITLE' } },
footer = { { 'OLD_FOOTER' } },
})
end)
it('with valid title and invalid footer', function()
eq(
'title/footer must be string or array',
pcall_err(api.nvim_win_set_config, win, {
title = { { 'NEW_TITLE' } },
footer = 0,
})
)
command('redraw!')
assert_alive()
eq({ { 'OLD_TITLE' } }, api.nvim_win_get_config(win).title)
end)
it('with invalid title and valid footer', function()
eq(
'title/footer must be string or array',
pcall_err(api.nvim_win_set_config, win, {
title = 0,
footer = { { 'NEW_FOOTER' } },
})
)
command('redraw!')
assert_alive()
eq({ { 'OLD_FOOTER' } }, api.nvim_win_get_config(win).footer)
end)
end)
it('cannot split from a float', function()
local win = api.nvim_get_current_win()
local float_win = api.nvim_open_win(0, true, {
relative = 'editor',
width = 10,
height = 10,
row = 10,
col = 10,
})
eq(
'Cannot split a floating window',
pcall_err(api.nvim_win_set_config, win, { win = float_win, split = 'right' })
)
eq(
'Cannot split a floating window',
pcall_err(api.nvim_win_set_config, win, { win = 0, split = 'right' })
)
-- No errors when not actually splitting.
local cfg = api.nvim_win_get_config(win)
api.nvim_win_set_config(win, {})
eq(cfg, api.nvim_win_get_config(win))
eq(1, eval('&cmdheight'))
api.nvim_win_set_config(win, { height = 1 })
cfg.height = 1
eq(cfg, api.nvim_win_get_config(win))
eq(23, eval('&cmdheight'))
api.nvim_win_set_config(win, { style = 'minimal' })
cfg.style = 'minimal'
eq(cfg, api.nvim_win_get_config(win))
end)
it('cannot move autocmd window between tabpages', function()
local win_type, split_ok, split_err, float_ok, float_err = exec_lua(function()
local other_tp_win = vim.api.nvim_get_current_win()
vim.cmd.tabnew()
local win_type, split_ok, split_err, float_ok, float_err
vim.api.nvim_buf_call(vim.api.nvim_create_buf(true, true), function()
win_type = vim.fn.win_gettype()
split_ok, split_err =
pcall(vim.api.nvim_win_set_config, 0, { win = other_tp_win, split = 'right' })
float_ok, float_err = pcall(vim.api.nvim_win_set_config, 0, { win = other_tp_win })
end)
return win_type, split_ok, split_err, float_ok, float_err
end)
eq('autocmd', win_type)
eq({ false, 'Cannot move autocmd window to another tabpage' }, { split_ok, split_err })
eq({ false, 'Cannot move autocmd window to another tabpage' }, { float_ok, float_err })
end)
it('cannot move cmdwin between tabpages', function()
local other_tp_win = api.nvim_get_current_win()
command('tabnew')
local old_curwin = api.nvim_get_current_win()
feed('q:')
eq('command', fn.win_gettype())
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_config, 0, { win = other_tp_win, split = 'right' })
)
-- Shouldn't move the old curwin from before we entered the cmdwin either.
eq(
'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(api.nvim_win_set_config, old_curwin, { win = other_tp_win, split = 'right' })
)
end)
it('minimal style persists through float-to-split and buffer change #37067', function()
-- Set all options globally
command('set number relativenumber cursorline cursorcolumn spell list')
command('set signcolumn=yes colorcolumn=80 statuscolumn=%l foldcolumn=2')
local buf1 = api.nvim_create_buf(false, true)
local win = api.nvim_open_win(buf1, true, {
relative = 'editor',
width = 10,
height = 10,
row = 5,
col = 5,
style = 'minimal',
})
-- Convert to split then change buffer
api.nvim_win_set_config(win, { split = 'below', win = -1 })
local buf2 = api.nvim_create_buf(false, true)
api.nvim_win_set_buf(win, buf2)
eq(false, api.nvim_get_option_value('number', { win = win }))
eq(false, api.nvim_get_option_value('relativenumber', { win = win }))
eq(false, api.nvim_get_option_value('cursorline', { win = win }))
eq(false, api.nvim_get_option_value('cursorcolumn', { win = win }))
eq(false, api.nvim_get_option_value('spell', { win = win }))
eq(false, api.nvim_get_option_value('list', { win = win }))
eq('0', api.nvim_get_option_value('foldcolumn', { win = win }))
eq('auto', api.nvim_get_option_value('signcolumn', { win = win }))
eq('', api.nvim_get_option_value('colorcolumn', { win = win }))
eq('', api.nvim_get_option_value('statuscolumn', { win = win }))
end)
it('merges configs only after successfully configuring split', function()
local win = api.nvim_open_win(0, true, {
relative = 'editor',
width = 10,
height = 10,
row = 5,
col = 5,
})
local cfg = api.nvim_win_get_config(win)
eq('', cfg.style)
command('set cursorline | tabnew')
local tp2_win = api.nvim_get_current_win()
command('tabfirst | autocmd WinEnter * ++once wincmd p')
eq(
'Failed to switch away from window 1001',
pcall_err(
api.nvim_win_set_config,
win,
{ split = 'below', win = tp2_win, style = 'minimal' }
)
)
eq(cfg, api.nvim_win_get_config(win))
eq(true, api.nvim_get_option_value('cursorline', { win = win }))
exec([[
autocmd WinLeave * ++once let g:style_before = nvim_win_get_config(0).style
\| let g:cul_before = &cursorline
\| call nvim_win_set_config(0, #{style: ""})
]])
api.nvim_win_set_config(win, { split = 'below', win = tp2_win, style = 'minimal' })
eq('', eval('g:style_before'))
eq(1, eval('g:cul_before'))
eq('minimal', api.nvim_win_get_config(win).style)
eq(false, api.nvim_get_option_value('cursorline', { win = win }))
end)
it('minimal style not re-applied if style is unchanged', function()
api.nvim_open_win(0, true, { relative = 'editor', width = 10, height = 10, row = 5, col = 5 })
command('setlocal number rightleft')
api.nvim_win_set_config(0, { style = 'minimal' })
eq(0, eval('&number')) -- style changed; should've reset
command('setlocal number')
api.nvim_win_set_config(0, { style = 'minimal' })
eq(1, eval('&number'))
eq(1, eval('&rightleft')) -- unrelated option unaffected
end)
it('minimal style does not leak WinInfo fold memory', function()
feed('zfG')
api.nvim_open_win(0, true, { split = 'below', style = 'minimal' })
command('quit')
end)
it('preserve current floating window when moving fails', function()
local buf = api.nvim_create_buf(false, true)
local tab1_win = api.nvim_get_current_win()
local float_win = api.nvim_open_win(buf, true, {
relative = 'editor',
row = 1,
col = 1,
width = 10,
height = 5,
})
command('tabnew')
local tab2_win = api.nvim_get_current_win()
command('tabprev')
api.nvim_set_current_win(float_win)
command('autocmd WinLeave * ++once call nvim_win_close(' .. tab2_win .. ', v:true)')
eq(
'Target windows were closed',
pcall_err(api.nvim_win_set_config, float_win, { win = tab2_win })
)
eq(float_win, api.nvim_get_current_win())
command('tabnew')
local tab3_win = api.nvim_get_current_win()
command('tabprev | autocmd WinEnter * ++once wincmd p')
eq(
('Failed to switch away from window %d'):format(float_win),
pcall_err(api.nvim_win_set_config, float_win, { win = tab3_win })
)
eq(float_win, api.nvim_get_current_win())
command(
('autocmd WinLeave * ++once call nvim_win_set_config(%d, #{split: "left", win: %d})'):format(
float_win,
tab1_win
)
)
eq(
('Window %d was made non-floating'):format(float_win),
pcall_err(api.nvim_win_set_config, float_win, { win = tab3_win })
)
eq(float_win, api.nvim_get_current_win())
-- Need multigrid for external windows.
Screen.new(20, 9, { ext_multigrid = true })
api.nvim_win_set_config(float_win, { external = true, width = 5, height = 5 })
eq(true, api.nvim_win_get_config(float_win).external)
eq(
('Cannot move external window to another tabpage'):format(float_win),
pcall_err(
api.nvim_win_set_config,
float_win,
{ relative = 'win', win = tab3_win, row = 0, col = 0 }
)
)
eq(float_win, api.nvim_get_current_win())
-- Error if made external by autocommand when attempting to move.
api.nvim_win_set_config(
float_win,
{ relative = 'editor', row = 0, col = 0, width = 5, height = 5 }
)
eq(false, api.nvim_win_get_config(float_win).external)
command(
('autocmd WinLeave * ++once call nvim_win_set_config(%d, #{external: 1})'):format(float_win)
)
eq(
('Cannot move external window to another tabpage'):format(float_win),
pcall_err(api.nvim_win_set_config, float_win, { win = tab3_win })
)
eq(float_win, api.nvim_get_current_win())
end)
end)
end)
Reference in New Issue View Git Blame Copy Permalink