mirror of
https://github.com/neovim/neovim.git
synced 2024-12-22 20:25:16 -07:00
310 lines
9.5 KiB
Lua
310 lines
9.5 KiB
Lua
-- Test suite for testing interactions with API bindings
|
|
local helpers = require('test.functional.helpers')(after_each)
|
|
|
|
local command = helpers.command
|
|
local meths = helpers.meths
|
|
local clear = helpers.clear
|
|
local eq = helpers.eq
|
|
local exec_lua = helpers.exec_lua
|
|
local feed = helpers.feed
|
|
local deepcopy = helpers.deepcopy
|
|
|
|
local origlines = {"original line 1",
|
|
"original line 2",
|
|
"original line 3",
|
|
"original line 4",
|
|
"original line 5",
|
|
"original line 6",
|
|
" indented line"}
|
|
|
|
local function attach_buffer(evname)
|
|
exec_lua([[
|
|
local evname = ...
|
|
local events = {}
|
|
|
|
function test_register(bufnr, id, changedtick, utf_sizes)
|
|
local function callback(...)
|
|
table.insert(events, {id, ...})
|
|
if test_unreg == id then
|
|
return true
|
|
end
|
|
end
|
|
local opts = {[evname]=callback, on_detach=callback, utf_sizes=utf_sizes}
|
|
if changedtick then
|
|
opts.on_changedtick = callback
|
|
end
|
|
vim.api.nvim_buf_attach(bufnr, false, opts)
|
|
end
|
|
|
|
function get_events()
|
|
local ret_events = events
|
|
events = {}
|
|
return ret_events
|
|
end
|
|
]], evname)
|
|
end
|
|
|
|
describe('lua buffer event callbacks: on_lines', function()
|
|
before_each(function()
|
|
clear()
|
|
attach_buffer('on_lines')
|
|
end)
|
|
|
|
|
|
-- verifying the sizes with nvim_buf_get_offset is nice (checks we cannot
|
|
-- assert the wrong thing), but masks errors with unflushed lines (as
|
|
-- nvim_buf_get_offset forces a flush of the memline). To be safe run the
|
|
-- test both ways.
|
|
local function check(verify,utf_sizes)
|
|
local lastsize
|
|
meths.buf_set_lines(0, 0, -1, true, origlines)
|
|
if verify then
|
|
lastsize = meths.buf_get_offset(0, meths.buf_line_count(0))
|
|
end
|
|
exec_lua("return test_register(...)", 0, "test1",false,utf_sizes)
|
|
local tick = meths.buf_get_changedtick(0)
|
|
|
|
local verify_name = "test1"
|
|
local function check_events(expected)
|
|
local events = exec_lua("return get_events(...)" )
|
|
if utf_sizes then
|
|
-- this test case uses ASCII only, so sizes should be the same.
|
|
-- Unicode is tested below.
|
|
for _, event in ipairs(expected) do
|
|
event[9] = event[8]
|
|
event[10] = event[8]
|
|
end
|
|
end
|
|
eq(expected, events)
|
|
if verify then
|
|
for _, event in ipairs(events) do
|
|
if event[1] == verify_name and event[2] == "lines" then
|
|
local startline, endline = event[5], event[7]
|
|
local newrange = meths.buf_get_offset(0, endline) - meths.buf_get_offset(0, startline)
|
|
local newsize = meths.buf_get_offset(0, meths.buf_line_count(0))
|
|
local oldrange = newrange + lastsize - newsize
|
|
eq(oldrange, event[8])
|
|
lastsize = newsize
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
command('set autoindent')
|
|
command('normal! GyyggP')
|
|
tick = tick + 1
|
|
check_events({{ "test1", "lines", 1, tick, 0, 0, 1, 0}})
|
|
|
|
meths.buf_set_lines(0, 3, 5, true, {"changed line"})
|
|
tick = tick + 1
|
|
check_events({{ "test1", "lines", 1, tick, 3, 5, 4, 32 }})
|
|
|
|
exec_lua("return test_register(...)", 0, "test2", true, utf_sizes)
|
|
tick = tick + 1
|
|
command('undo')
|
|
|
|
-- plugins can opt in to receive changedtick events, or choose
|
|
-- to only receive actual changes.
|
|
check_events({{ "test1", "lines", 1, tick, 3, 4, 5, 13 },
|
|
{ "test2", "lines", 1, tick, 3, 4, 5, 13 },
|
|
{ "test2", "changedtick", 1, tick+1 } })
|
|
tick = tick + 1
|
|
|
|
-- simulate next callback returning true
|
|
exec_lua("test_unreg = 'test1'")
|
|
|
|
meths.buf_set_lines(0, 6, 7, true, {"x1","x2","x3"})
|
|
tick = tick + 1
|
|
|
|
-- plugins can opt in to receive changedtick events, or choose
|
|
-- to only receive actual changes.
|
|
check_events({{ "test1", "lines", 1, tick, 6, 7, 9, 16 },
|
|
{ "test2", "lines", 1, tick, 6, 7, 9, 16 }})
|
|
|
|
verify_name = "test2"
|
|
|
|
meths.buf_set_lines(0, 1, 1, true, {"added"})
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 1, 1, 2, 0 }})
|
|
|
|
feed('wix')
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 4, 5, 5, 16 }})
|
|
|
|
-- check hot path for multiple insert
|
|
feed('yz')
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 4, 5, 5, 17 }})
|
|
|
|
feed('<bs>')
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 4, 5, 5, 19 }})
|
|
|
|
feed('<esc>Go')
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 11, 11, 12, 0 }})
|
|
|
|
feed('x')
|
|
tick = tick + 1
|
|
check_events({{ "test2", "lines", 1, tick, 11, 12, 12, 5 }})
|
|
|
|
command('bwipe!')
|
|
check_events({{ "test2", "detach", 1 }})
|
|
end
|
|
|
|
it('works', function()
|
|
check(false)
|
|
end)
|
|
|
|
it('works with verify', function()
|
|
check(true)
|
|
end)
|
|
|
|
it('works with utf_sizes and ASCII text', function()
|
|
check(false,true)
|
|
end)
|
|
|
|
it('works with utf_sizes and unicode text', function()
|
|
local unicode_text = {"ascii text",
|
|
"latin text åäö",
|
|
"BMP text ɧ αλφά",
|
|
"BMP text 汉语 ↥↧",
|
|
"SMP 🤦 🦄🦃",
|
|
"combining å بِيَّة"}
|
|
meths.buf_set_lines(0, 0, -1, true, unicode_text)
|
|
feed('gg')
|
|
exec_lua("return test_register(...)", 0, "test1", false, true)
|
|
local tick = meths.buf_get_changedtick(0)
|
|
|
|
feed('dd')
|
|
tick = tick + 1
|
|
eq({{ "test1", "lines", 1, tick, 0, 1, 0, 11, 11, 11 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('A<bs>')
|
|
tick = tick + 1
|
|
eq({{ "test1", "lines", 1, tick, 0, 1, 1, 18, 15, 15 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('<esc>jylp')
|
|
tick = tick + 1
|
|
eq({{ "test1", "lines", 1, tick, 1, 2, 2, 21, 16, 16 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('+eea<cr>')
|
|
tick = tick + 1
|
|
eq({{ "test1", "lines", 1, tick, 2, 3, 4, 23, 15, 15 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('<esc>jdw')
|
|
tick = tick + 1
|
|
-- non-BMP chars count as 2 UTF-2 codeunits
|
|
eq({{ "test1", "lines", 1, tick, 4, 5, 5, 18, 9, 12 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('+rx')
|
|
tick = tick + 1
|
|
-- count the individual codepoints of a composed character.
|
|
eq({{ "test1", "lines", 1, tick, 5, 6, 6, 27, 20, 20 }}, exec_lua("return get_events(...)" ))
|
|
|
|
feed('kJ')
|
|
tick = tick + 1
|
|
-- NB: this is inefficient (but not really wrong).
|
|
eq({{ "test1", "lines", 1, tick, 4, 5, 5, 14, 5, 8 },
|
|
{ "test1", "lines", 1, tick+1, 5, 6, 5, 27, 20, 20 }}, exec_lua("return get_events(...)" ))
|
|
end)
|
|
|
|
it('has valid cursor position while shifting', function()
|
|
meths.buf_set_lines(0, 0, -1, true, {'line1'})
|
|
exec_lua([[
|
|
vim.api.nvim_buf_attach(0, false, {
|
|
on_lines = function()
|
|
vim.api.nvim_set_var('listener_cursor_line', vim.api.nvim_win_get_cursor(0)[1])
|
|
end,
|
|
})
|
|
]])
|
|
feed('>>')
|
|
eq(1, meths.get_var('listener_cursor_line'))
|
|
end)
|
|
|
|
it('does not SEGFAULT when calling win_findbuf in on_detach', function()
|
|
|
|
exec_lua[[
|
|
local buf = vim.api.nvim_create_buf(false, false)
|
|
|
|
vim.cmd"split"
|
|
vim.api.nvim_win_set_buf(0, buf)
|
|
|
|
vim.api.nvim_buf_attach(buf, false, {
|
|
on_detach = function(_, buf)
|
|
vim.fn.win_findbuf(buf)
|
|
end
|
|
})
|
|
]]
|
|
|
|
command("q!")
|
|
helpers.assert_alive()
|
|
end)
|
|
|
|
end)
|
|
|
|
describe('lua buffer event callbacks: on_bytes', function()
|
|
before_each(function()
|
|
clear()
|
|
attach_buffer('on_bytes')
|
|
end)
|
|
|
|
|
|
-- verifying the sizes with nvim_buf_get_offset is nice (checks we cannot
|
|
-- assert the wrong thing), but masks errors with unflushed lines (as
|
|
-- nvim_buf_get_offset forces a flush of the memline). To be safe run the
|
|
-- test both ways.
|
|
local function check(verify)
|
|
meths.buf_set_lines(0, 0, -1, true, origlines)
|
|
local shadow = deepcopy(origlines)
|
|
local shadowbytes = table.concat(shadow, '\n') .. '\n'
|
|
if verify then
|
|
meths.buf_get_offset(0, meths.buf_line_count(0))
|
|
end
|
|
exec_lua("return test_register(...)", 0, "test1",false, nil)
|
|
meths.buf_get_changedtick(0)
|
|
|
|
local verify_name = "test1"
|
|
local function check_events(expected)
|
|
local events = exec_lua("return get_events(...)" )
|
|
eq(expected, events)
|
|
if verify then
|
|
for _, event in ipairs(events) do
|
|
if event[1] == verify_name and event[2] == "bytes" then
|
|
local _, _, _, _, _, _, start_byte, _, _, old_byte, _, _, new_byte = unpack(event)
|
|
local before = string.sub(shadowbytes, 1, start_byte)
|
|
-- no text in the tests will contain 0xff bytes (invalid UTF-8)
|
|
-- so we can use it as marker for unknown bytes
|
|
local unknown = string.rep('\255', new_byte)
|
|
local after = string.sub(shadowbytes, start_byte + old_byte + 1)
|
|
shadowbytes = before .. unknown .. after
|
|
end
|
|
end
|
|
local text = meths.buf_get_lines(0, 0, -1, true)
|
|
local bytes = table.concat(text, '\n') .. '\n'
|
|
eq(string.len(bytes), string.len(shadowbytes), shadowbytes)
|
|
for i = 1, string.len(shadowbytes) do
|
|
local shadowbyte = string.sub(shadowbytes, i, i)
|
|
if shadowbyte ~= '\255' then
|
|
eq(string.sub(bytes, i, i), shadowbyte, i)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
feed('ggJ')
|
|
check_events({{'test1', 'bytes', 1, 3, 0, 15, 15, 1, 0, 1, 0, 1, 1}})
|
|
|
|
feed('3J')
|
|
check_events({
|
|
{'test1', 'bytes', 1, 5, 0, 31, 31, 1, 0, 1, 0, 1, 1},
|
|
{'test1', 'bytes', 1, 5, 0, 47, 47, 1, 0, 1, 0, 1, 1},
|
|
})
|
|
end
|
|
|
|
it('works with verify', function()
|
|
check(true)
|
|
end)
|
|
end)
|
|
|