neovim/test/functional/editor/completion_spec.lua
bfredl e61228a214 fix(tests): needing two calls to setup a screen is cringe
Before calling "attach" a screen object is just a dummy container for
(row, col) values whose purpose is to be sent as part of the "attach"
function call anyway.

Just create the screen in an attached state directly. Keep the complete
(row, col, options) config together. It is still completely valid to
later detach and re-attach as needed, including to another session.
2024-11-14 12:40:57 +01:00

1307 lines
56 KiB
Lua

local t = require('test.testutil')
local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')
local assert_alive = n.assert_alive
local clear, feed = n.clear, n.feed
local eval, eq, neq, ok = n.eval, t.eq, t.neq, t.ok
local feed_command, source, expect = n.feed_command, n.source, n.expect
local fn = n.fn
local command = n.command
local api = n.api
local poke_eventloop = n.poke_eventloop
describe('completion', function()
local screen
before_each(function()
clear()
screen = Screen.new(60, 8)
screen:add_extra_attr_ids {
[100] = { foreground = Screen.colors.Gray0, background = Screen.colors.Yellow },
[101] = { background = Screen.colors.Gray0 },
}
end)
describe('v:completed_item', function()
it('is empty dict until completion', function()
eq({}, eval('v:completed_item'))
end)
it('is empty dict if the candidate is not inserted', function()
feed('ifoo<ESC>o<C-x><C-n>')
screen:expect([[
foo |
foo^ |
{1:~ }|*5
{5:-- Keyword Local completion (^N^P) The only match} |
]])
feed('<C-e>')
screen:expect([[
foo |
^ |
{1:~ }|*5
{5:-- INSERT --} |
]])
feed('<ESC>')
eq({}, eval('v:completed_item'))
end)
it('returns expected dict in normal completion', function()
feed('ifoo<ESC>o<C-x><C-n>')
eq('foo', eval('getline(2)'))
eq(
{ word = 'foo', abbr = '', menu = '', info = '', kind = '', user_data = '' },
eval('v:completed_item')
)
end)
it('is readonly', function()
screen:try_resize(80, 8)
feed('ifoo<ESC>o<C-x><C-n><ESC>')
feed_command('let v:completed_item.word = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
feed_command('let v:completed_item.abbr = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
feed_command('let v:completed_item.menu = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
feed_command('let v:completed_item.info = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
feed_command('let v:completed_item.kind = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
feed_command('let v:completed_item.user_data = "bar"')
neq(nil, string.find(eval('v:errmsg'), '^E46: '))
feed_command('let v:errmsg = ""')
end)
it('returns expected dict in omni completion', function()
source([[
function! TestOmni(findstart, base) abort
return a:findstart ? 0 : [{'word': 'foo', 'abbr': 'bar',
\ 'menu': 'baz', 'info': 'foobar', 'kind': 'foobaz'},
\ {'word': 'word', 'abbr': 'abbr', 'menu': 'menu',
\ 'info': 'info', 'kind': 'kind'}]
endfunction
setlocal omnifunc=TestOmni
]])
feed('i<C-x><C-o>')
eq('foo', eval('getline(1)'))
screen:expect([[
foo^ |
{12:bar foobaz baz }{1: }|
{4:abbr kind menu }{1: }|
{1:~ }|*4
{5:-- Omni completion (^O^N^P) }{6:match 1 of 2} |
]])
eq({
word = 'foo',
abbr = 'bar',
menu = 'baz',
info = 'foobar',
kind = 'foobaz',
user_data = '',
}, eval('v:completed_item'))
end)
end)
describe('completeopt', function()
before_each(function()
source([[
function! TestComplete() abort
call complete(1, ['foo'])
return ''
endfunction
]])
end)
it('inserts the first candidate if default', function()
feed_command('set completeopt+=menuone')
feed('ifoo<ESC>o')
screen:expect([[
foo |
^ |
{1:~ }|*5
{5:-- INSERT --} |
]])
feed('<C-x>')
-- the ^X prompt, only test this once
screen:expect([[
foo |
^ |
{1:~ }|*5
{5:-- ^X mode (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)} |
]])
feed('<C-n>')
screen:expect([[
foo |
foo^ |
{12:foo }{1: }|
{1:~ }|*4
{5:-- Keyword Local completion (^N^P) The only match} |
]])
feed('bar<ESC>')
eq('foobar', eval('getline(2)'))
feed('o<C-r>=TestComplete()<CR>')
screen:expect([[
foo |
foobar |
foo^ |
{12:foo }{1: }|
{1:~ }|*3
{5:-- INSERT --} |
]])
eq('foo', eval('getline(3)'))
end)
it('selects the first candidate if noinsert', function()
feed_command('set completeopt+=menuone,noinsert')
feed('ifoo<ESC>o<C-x><C-n>')
screen:expect([[
foo |
^ |
{12:foo }{1: }|
{1:~ }|*4
{5:-- Keyword Local completion (^N^P) The only match} |
]])
feed('<C-y>')
screen:expect([[
foo |
foo^ |
{1:~ }|*5
{5:-- INSERT --} |
]])
feed('<ESC>')
eq('foo', eval('getline(2)'))
feed('o<C-r>=TestComplete()<CR>')
screen:expect([[
foo |*2
^ |
{12:foo }{1: }|
{1:~ }|*3
{5:-- INSERT --} |
]])
feed('<C-y><ESC>')
eq('foo', eval('getline(3)'))
end)
it('does not insert the first candidate if noselect', function()
feed_command('set completeopt+=menuone,noselect')
feed('ifoo<ESC>o<C-x><C-n>')
screen:expect([[
foo |
^ |
{4:foo }{1: }|
{1:~ }|*4
{5:-- Keyword Local completion (^N^P) }{19:Back at original} |
]])
feed('b')
screen:expect([[
foo |
b^ |
{1:~ }|*5
{5:-- Keyword Local completion (^N^P) }{19:Back at original} |
]])
feed('ar<ESC>')
eq('bar', eval('getline(2)'))
feed('o<C-r>=TestComplete()<CR>')
screen:expect([[
foo |
bar |
^ |
{4:foo }{1: }|
{1:~ }|*3
{5:-- INSERT --} |
]])
feed('bar<ESC>')
eq('bar', eval('getline(3)'))
end)
it('does not select/insert the first candidate if noselect and noinsert', function()
feed_command('set completeopt+=menuone,noselect,noinsert')
feed('ifoo<ESC>o<C-x><C-n>')
screen:expect([[
foo |
^ |
{4:foo }{1: }|
{1:~ }|*4
{5:-- Keyword Local completion (^N^P) }{19:Back at original} |
]])
feed('<ESC>')
screen:expect([[
foo |
^ |
{1:~ }|*5
|
]])
eq('', eval('getline(2)'))
feed('o<C-r>=TestComplete()<CR>')
screen:expect([[
foo |
|
^ |
{4:foo }{1: }|
{1:~ }|*3
{5:-- INSERT --} |
]])
feed('<ESC>')
screen:expect([[
foo |
|
^ |
{1:~ }|*4
|
]])
eq('', eval('getline(3)'))
end)
it('does not change modified state if noinsert', function()
feed_command('set completeopt+=menuone,noinsert')
feed_command('setlocal nomodified')
feed('i<C-r>=TestComplete()<CR><ESC>')
eq(0, eval('&l:modified'))
end)
it('does not change modified state if noselect', function()
feed_command('set completeopt+=menuone,noselect')
feed_command('setlocal nomodified')
feed('i<C-r>=TestComplete()<CR><ESC>')
eq(0, eval('&l:modified'))
end)
end)
describe('completeopt+=noinsert does not add blank undo items', function()
before_each(function()
source([[
function! TestComplete() abort
call complete(1, ['foo', 'bar'])
return ''
endfunction
]])
feed_command('set completeopt+=noselect,noinsert')
feed_command('inoremap <right> <c-r>=TestComplete()<cr>')
end)
local tests = {
['<up>, <down>, <cr>'] = { '<down><cr>', '<up><cr>' },
['<c-n>, <c-p>, <c-y>'] = { '<c-n><c-y>', '<c-p><c-y>' },
}
for name, seq in pairs(tests) do
it('using ' .. name, function()
feed('iaaa<esc>')
feed('A<right>' .. seq[1] .. '<esc>')
feed('A<right><esc>A<right><esc>')
feed('A<cr>bbb<esc>')
feed('A<right>' .. seq[2] .. '<esc>')
feed('A<right><esc>A<right><esc>')
feed('A<cr>ccc<esc>')
feed('A<right>' .. seq[1] .. '<esc>')
feed('A<right><esc>A<right><esc>')
local expected = {
{ 'foo', 'bar', 'foo' },
{ 'foo', 'bar', 'ccc' },
{ 'foo', 'bar' },
{ 'foo', 'bbb' },
{ 'foo' },
{ 'aaa' },
{ '' },
}
for i = 1, #expected do
if i > 1 then
feed('u')
end
eq(expected[i], eval('getline(1, "$")'))
end
for i = #expected, 1, -1 do
if i < #expected then
feed('<c-r>')
end
eq(expected[i], eval('getline(1, "$")'))
end
end)
end
end)
describe('with refresh:always and noselect', function()
before_each(function()
source([[
function! TestCompletion(findstart, base) abort
if a:findstart
let line = getline('.')
let start = col('.') - 1
while start > 0 && line[start - 1] =~ '\a'
let start -= 1
endwhile
return start
else
let ret = []
for m in split("January February March April May June July August September October November December")
if m =~ a:base " match by regex
call add(ret, m)
endif
endfor
return {'words':ret, 'refresh':'always'}
endif
endfunction
set completeopt=menuone,noselect
set completefunc=TestCompletion
]])
end)
it('completes on each input char', function()
feed('i<C-x><C-u>')
screen:expect([[
^ |
{4:January }{101: }{1: }|
{4:February }{101: }{1: }|
{4:March }{101: }{1: }|
{4:April }{12: }{1: }|
{4:May }{12: }{1: }|
{4:June }{12: }{1: }|
{5:-- User defined completion (^U^N^P) }{19:Back at original} |
]])
feed('u')
screen:expect([[
u^ |
{4:January }{1: }|
{4:February }{1: }|
{4:June }{1: }|
{4:July }{1: }|
{4:August }{1: }|
{1:~ }|
{5:-- User defined completion (^U^N^P) }{19:Back at original} |
]])
feed('g')
screen:expect([[
ug^ |
{4:August }{1: }|
{1:~ }|*5
{5:-- User defined completion (^U^N^P) }{19:Back at original} |
]])
feed('<Down>')
screen:expect([[
ug^ |
{12:August }{1: }|
{1:~ }|*5
{5:-- User defined completion (^U^N^P) The only match} |
]])
feed('<C-y>')
screen:expect([[
August^ |
{1:~ }|*6
{5:-- INSERT --} |
]])
expect('August')
end)
it('repeats correctly after backspace #2674', function()
feed('o<C-x><C-u>Ja')
screen:expect([[
|
Ja^ |
{4:January }{1: }|
{1:~ }|*4
{5:-- User defined completion (^U^N^P) }{19:Back at original} |
]])
feed('<BS>')
screen:expect([[
|
J^ |
{4:January }{1: }|
{4:June }{1: }|
{4:July }{1: }|
{1:~ }|*2
{5:-- User defined completion (^U^N^P) }{19:Back at original} |
]])
feed('<C-n>')
screen:expect([[
|
January^ |
{12:January }{1: }|
{4:June }{1: }|
{4:July }{1: }|
{1:~ }|*2
{5:-- User defined completion (^U^N^P) }{6:match 1 of 3} |
]])
feed('<C-n>')
screen:expect([[
|
June^ |
{4:January }{1: }|
{12:June }{1: }|
{4:July }{1: }|
{1:~ }|*2
{5:-- User defined completion (^U^N^P) }{6:match 2 of 3} |
]])
feed('<Esc>')
screen:expect([[
|
Jun^e |
{1:~ }|*5
|
]])
feed('.')
screen:expect([[
|
June |
Jun^e |
{1:~ }|*4
|
]])
expect([[
June
June]])
end)
it('Enter does not select original text', function()
feed('iJ<C-x><C-u>')
poke_eventloop()
feed('u')
poke_eventloop()
feed('<CR>')
expect([[
Ju
]])
feed('J<C-x><C-u>')
poke_eventloop()
feed('<CR>')
expect([[
Ju
J
]])
end)
end)
describe('with noselect but not refresh:always', function()
before_each(function()
source([[
function! TestCompletion(findstart, base) abort
if a:findstart
let line = getline('.')
let start = col('.') - 1
while start > 0 && line[start - 1] =~ '\a'
let start -= 1
endwhile
return start
else
let ret = []
for m in split("January February March April May June July August September October November December")
if m =~ a:base " match by regex
call add(ret, m)
endif
endfor
return {'words':ret}
endif
endfunction
set completeopt=menuone,noselect
set completefunc=TestCompletion
]])
end)
it('Enter selects original text after adding leader', function()
feed('iJ<C-x><C-u>')
poke_eventloop()
feed('u')
poke_eventloop()
feed('<CR>')
expect('Ju')
feed('<Esc>')
poke_eventloop()
-- The behavior should be the same when completion has been interrupted,
-- which can happen interactively if the completion function is slow.
feed('SJ<C-x><C-u>u<CR>')
expect('Ju')
end)
end)
describe('with a lot of items', function()
before_each(function()
source([[
function! TestComplete() abort
call complete(1, map(range(0,100), "string(v:val)"))
return ''
endfunction
]])
feed_command('set completeopt=menuone,noselect')
end)
it('works', function()
feed('i<C-r>=TestComplete()<CR>')
screen:expect([[
^ |
{4:0 }{101: }{1: }|
{4:1 }{12: }{1: }|
{4:2 }{12: }{1: }|
{4:3 }{12: }{1: }|
{4:4 }{12: }{1: }|
{4:5 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('7')
screen:expect([[
7^ |
{4:7 }{101: }{1: }|
{4:70 }{101: }{1: }|
{4:71 }{101: }{1: }|
{4:72 }{12: }{1: }|
{4:73 }{12: }{1: }|
{4:74 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<c-n>')
screen:expect([[
7^ |
{12:7 }{101: }{1: }|
{4:70 }{101: }{1: }|
{4:71 }{101: }{1: }|
{4:72 }{12: }{1: }|
{4:73 }{12: }{1: }|
{4:74 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<c-n>')
screen:expect([[
70^ |
{4:7 }{101: }{1: }|
{12:70 }{101: }{1: }|
{4:71 }{101: }{1: }|
{4:72 }{12: }{1: }|
{4:73 }{12: }{1: }|
{4:74 }{12: }{1: }|
{5:-- INSERT --} |
]])
end)
it('can be navigated with <PageDown>, <PageUp>', function()
feed('i<C-r>=TestComplete()<CR>')
screen:expect([[
^ |
{4:0 }{101: }{1: }|
{4:1 }{12: }{1: }|
{4:2 }{12: }{1: }|
{4:3 }{12: }{1: }|
{4:4 }{12: }{1: }|
{4:5 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageDown>')
screen:expect([[
^ |
{4:0 }{101: }{1: }|
{4:1 }{12: }{1: }|
{4:2 }{12: }{1: }|
{12:3 }{1: }|
{4:4 }{12: }{1: }|
{4:5 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageDown>')
screen:expect([[
^ |
{4:5 }{101: }{1: }|
{4:6 }{12: }{1: }|
{12:7 }{1: }|
{4:8 }{12: }{1: }|
{4:9 }{12: }{1: }|
{4:10 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<Down>')
screen:expect([[
^ |
{4:5 }{101: }{1: }|
{4:6 }{12: }{1: }|
{4:7 }{12: }{1: }|
{12:8 }{1: }|
{4:9 }{12: }{1: }|
{4:10 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageUp>')
screen:expect([[
^ |
{4:2 }{101: }{1: }|
{4:3 }{12: }{1: }|
{12:4 }{1: }|
{4:5 }{12: }{1: }|
{4:6 }{12: }{1: }|
{4:7 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageUp>') -- stop on first item
screen:expect([[
^ |
{12:0 }{101: }{1: }|
{4:1 }{12: }{1: }|
{4:2 }{12: }{1: }|
{4:3 }{12: }{1: }|
{4:4 }{12: }{1: }|
{4:5 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageUp>') -- when on first item, unselect
screen:expect([[
^ |
{4:0 }{101: }{1: }|
{4:1 }{12: }{1: }|
{4:2 }{12: }{1: }|
{4:3 }{12: }{1: }|
{4:4 }{12: }{1: }|
{4:5 }{12: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageUp>') -- when unselected, select last item
screen:expect([[
^ |
{4:95 }{12: }{1: }|
{4:96 }{12: }{1: }|
{4:97 }{12: }{1: }|
{4:98 }{12: }{1: }|
{4:99 }{12: }{1: }|
{12:100 }{101: }{1: }|
{5:-- INSERT --} |
]])
feed('<PageUp>')
screen:expect([[
^ |
{4:94 }{12: }{1: }|
{4:95 }{12: }{1: }|
{12:96 }{1: }|
{4:97 }{12: }{1: }|
{4:98 }{12: }{1: }|
{4:99 }{101: }{1: }|
{5:-- INSERT --} |
]])
feed('<cr>')
screen:expect([[
96^ |
{1:~ }|*6
{5:-- INSERT --} |
]])
end)
end)
it('does not indent until an item is selected #8345', function()
-- Indents on "ind", unindents on "unind".
source([[
function! TestIndent()
let line = getline(v:lnum)
if (line =~ '^\s*ind')
return indent(v:lnum-1) + shiftwidth()
elseif (line =~ '^\s*unind')
return indent(v:lnum-1) - shiftwidth()
else
return indent(v:lnum-1)
endif
endfunction
set indentexpr=TestIndent()
set indentkeys=o,O,!^F,=ind,=unind
set completeopt+=menuone
]])
-- Give some words to complete.
feed('iinc uninc indent unindent<CR>')
-- Does not indent when "ind" is typed.
feed('in<C-X><C-N>')
-- Completion list is generated incorrectly if we send everything at once
-- via nvim_input(). So poke_eventloop() before sending <BS>. #8480
poke_eventloop()
feed('<BS>d')
screen:expect([[
inc uninc indent unindent |
ind^ |
{12:indent }{1: }|
{1:~ }|*4
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 2} |
]])
-- Indents when the item is selected
feed('<C-Y>')
screen:expect([[
inc uninc indent unindent |
indent^ |
{1:~ }|*5
{5:-- INSERT --} |
]])
-- Indents when completion is exited using ESC.
feed('<CR>in<C-N><BS>d<Esc>')
screen:expect([[
inc uninc indent unindent |
indent |
in^d |
{1:~ }|*4
|
]])
-- Works for unindenting too.
feed('ounin<C-X><C-N>')
poke_eventloop()
feed('<BS>d')
screen:expect([[
inc uninc indent unindent |
indent |
ind |
unind^ |
{1:~ }{12: unindent }{1: }|
{1:~ }|*2
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 2} |
]])
-- Works when going back and forth.
feed('<BS>c')
screen:expect([[
inc uninc indent unindent |
indent |
ind |
uninc^ |
{1:~ }{12: uninc }{1: }|
{1:~ }|*2
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 2} |
]])
feed('<BS>d')
screen:expect([[
inc uninc indent unindent |
indent |
ind |
unind^ |
{1:~ }{12: unindent }{1: }|
{1:~ }|*2
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 2} |
]])
feed('<C-N><C-N><C-Y><Esc>')
screen:expect([[
inc uninc indent unindent |
indent |
ind |
uninden^t |
{1:~ }|*3
|
]])
end)
it('disables folding during completion', function()
feed_command('set foldmethod=indent')
feed('i<Tab>foo<CR><Tab>bar<Esc>gg')
screen:expect([[
^foo |
bar |
{1:~ }|*5
|
]])
feed('A<C-x><C-l>')
screen:expect([[
foo^ |
bar |
{1:~ }|*5
{5:-- Whole line completion (^L^N^P) }{9:Pattern not found} |
]])
eq(-1, eval('foldclosed(1)'))
end)
it('popupmenu is not interrupted by events', function()
feed_command('set complete=.')
feed('ifoobar fooegg<cr>f<c-p>')
screen:expect([[
foobar fooegg |
fooegg^ |
{4:foobar }{1: }|
{12:fooegg }{1: }|
{1:~ }|*3
{5:-- Keyword completion (^N^P) }{6:match 1 of 2} |
]])
assert_alive()
-- popupmenu still visible
screen:expect {
grid = [[
foobar fooegg |
fooegg^ |
{4:foobar }{1: }|
{12:fooegg }{1: }|
{1:~ }|*3
{5:-- Keyword completion (^N^P) }{6:match 1 of 2} |
]],
unchanged = true,
}
feed('<c-p>')
-- Didn't restart completion: old matches still used
screen:expect([[
foobar fooegg |
foobar^ |
{12:foobar }{1: }|
{4:fooegg }{1: }|
{1:~ }|*3
{5:-- Keyword completion (^N^P) }{6:match 2 of 2} |
]])
end)
describe('lua completion', function()
it('expands when there is only one match', function()
feed(':lua CURRENT_TESTING_VAR = 1<CR>')
feed(':lua CURRENT_TESTING_<TAB>')
screen:expect {
grid = [[
|
{1:~ }|*6
:lua CURRENT_TESTING_VAR^ |
]],
}
end)
it('expands when there is only one match', function()
feed(':lua CURRENT_TESTING_FOO = 1<CR>')
feed(':lua CURRENT_TESTING_BAR = 1<CR>')
feed(':lua CURRENT_TESTING_<TAB>')
screen:expect {
grid = [[
|
{1:~ }|*5
{100:CURRENT_TESTING_BAR}{3: CURRENT_TESTING_FOO }|
:lua CURRENT_TESTING_BAR^ |
]],
unchanged = true,
}
end)
it('prefix is not included in completion for cmdline mode', function()
feed(':lua math.a<Tab>')
screen:expect([[
|
{1:~ }|*5
{100:abs}{3: acos asin atan atan2 }|
:lua math.abs^ |
]])
feed('<Tab>')
screen:expect([[
|
{1:~ }|*5
{3:abs }{100:acos}{3: asin atan atan2 }|
:lua math.acos^ |
]])
end)
it('prefix is not included in completion for i_CTRL-X_CTRL-V #19623', function()
feed('ilua math.a<C-X><C-V>')
screen:expect([[
lua math.abs^ |
{1:~ }{12: abs }{1: }|
{1:~ }{4: acos }{1: }|
{1:~ }{4: asin }{1: }|
{1:~ }{4: atan }{1: }|
{1:~ }{4: atan2 }{1: }|
{1:~ }|
{5:-- Command-line completion (^V^N^P) }{6:match 1 of 5} |
]])
feed('<C-V>')
screen:expect([[
lua math.acos^ |
{1:~ }{4: abs }{1: }|
{1:~ }{12: acos }{1: }|
{1:~ }{4: asin }{1: }|
{1:~ }{4: atan }{1: }|
{1:~ }{4: atan2 }{1: }|
{1:~ }|
{5:-- Command-line completion (^V^N^P) }{6:match 2 of 5} |
]])
end)
it('works when cursor is in the middle of cmdline #29586', function()
feed(':lua math.a(); 1<Left><Left><Left><Left><Left><Tab>')
screen:expect([[
|
{1:~ }|*5
{100:abs}{3: acos asin atan atan2 }|
:lua math.abs^(); 1 |
]])
end)
it('provides completion from `getcompletion()`', function()
eq({ 'vim' }, fn.getcompletion('vi', 'lua'))
eq({ 'api' }, fn.getcompletion('vim.ap', 'lua'))
eq({ 'tbl_filter' }, fn.getcompletion('vim.tbl_fil', 'lua'))
eq({ 'vim' }, fn.getcompletion('print(vi', 'lua'))
eq({ 'abs', 'acos', 'asin', 'atan', 'atan2' }, fn.getcompletion('math.a', 'lua'))
eq({ 'abs', 'acos', 'asin', 'atan', 'atan2' }, fn.getcompletion('lua math.a', 'cmdline'))
-- fuzzy completion is not supported, so the result should be the same
command('set wildoptions+=fuzzy')
eq({ 'vim' }, fn.getcompletion('vi', 'lua'))
end)
end)
it('cmdline completion supports various string options', function()
eq('auto', fn.getcompletion('set foldcolumn=', 'cmdline')[2])
eq({ 'nosplit', 'split' }, fn.getcompletion('set inccommand=', 'cmdline'))
eq({ 'ver:3,hor:6', 'hor:', 'ver:' }, fn.getcompletion('set mousescroll=', 'cmdline'))
eq('BS', fn.getcompletion('set termpastefilter=', 'cmdline')[2])
eq('SpecialKey', fn.getcompletion('set winhighlight=', 'cmdline')[1])
eq('SpecialKey', fn.getcompletion('set winhighlight=NonText:', 'cmdline')[1])
end)
it('cmdline completion for -complete does not contain spaces', function()
for _, str in ipairs(fn.getcompletion('command -complete=', 'cmdline')) do
ok(not str:find(' '), 'string without spaces', str)
end
end)
describe('from the commandline window', function()
it('is cleared after CTRL-C', function()
feed('q:')
feed('ifoo faa fee f')
screen:expect([[
|
{2:[No Name] }|
{1::}foo faa fee f^ |
{1:~ }|*3
{3:[Command Line] }|
{5:-- INSERT --} |
]])
feed('<c-x><c-n>')
screen:expect([[
|
{2:[No Name] }|
{1::}foo faa fee foo^ |
{1:~ }{12: foo }{1: }|
{1:~ }{4: faa }{1: }|
{1:~ }{4: fee }{1: }|
{3:[Command Line] }|
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 3} |
]])
feed('<c-c>')
screen:expect([[
|
{2:[No Name] }|
{1::}foo faa fee foo |
{1:~ }|*3
{3:[Command Line] }|
:foo faa fee foo^ |
]])
end)
end)
describe('with numeric items', function()
before_each(function()
source([[
function! TestComplete() abort
call complete(1, g:_complist)
return ''
endfunction
]])
api.nvim_set_option_value('completeopt', 'menuone,noselect', {})
api.nvim_set_var('_complist', {
{
word = 0,
abbr = 1,
menu = 2,
kind = 3,
info = 4,
icase = 5,
dup = 6,
empty = 7,
},
})
end)
it('shows correct variant as word', function()
feed('i<C-r>=TestComplete()<CR>')
screen:expect([[
^ |
{4:1 3 2 }{1: }|
{1:~ }|*5
{5:-- INSERT --} |
]])
end)
end)
it("'ignorecase' 'infercase' CTRL-X CTRL-N #6451", function()
feed_command('set ignorecase infercase')
feed_command('edit runtime/doc/backers.txt')
feed('oX<C-X><C-N>')
screen:expect {
grid = [[
*backers.txt* Nvim |
Xnull^ |
{12:Xnull }{101: } |
{4:Xoxomoon }{101: } |
{4:Xu }{101: } NVIM REFERENCE MANUAL |
{4:Xpayn }{12: } |
{4:Xinity }{12: } |
{5:-- Keyword Local completion (^N^P) }{6:match 1 of 7} |
]],
}
end)
it('CompleteChanged autocommand', function()
api.nvim_buf_set_lines(0, 0, 1, false, { 'foo', 'bar', 'foobar', '' })
source([[
set complete=. completeopt=noinsert,noselect,menuone
function! OnPumChange()
let g:event = copy(v:event)
let g:item = get(v:event, 'completed_item', {})
let g:word = get(g:item, 'word', v:null)
endfunction
autocmd! CompleteChanged * :call OnPumChange()
call cursor(4, 1)
]])
-- v:event.size should be set with ext_popupmenu #20646
screen:set_option('ext_popupmenu', true)
feed('Sf<C-N>')
screen:expect({
grid = [[
foo |
bar |
foobar |
f^ |
{1:~ }|*3
{5:-- Keyword completion (^N^P) }{19:Back at original} |
]],
popupmenu = {
anchor = { 1, 3, 0 },
items = { { 'foo', '', '', '' }, { 'foobar', '', '', '' } },
pos = -1,
},
})
eq(
{ completed_item = {}, width = 0, height = 2, size = 2, col = 0, row = 4, scrollbar = false },
eval('g:event')
)
feed('oob')
screen:expect({
grid = [[
foo |
bar |
foobar |
foob^ |
{1:~ }|*3
{5:-- Keyword completion (^N^P) }{19:Back at original} |
]],
popupmenu = {
anchor = { 1, 3, 0 },
items = { { 'foobar', '', '', '' } },
pos = -1,
},
})
eq(
{ completed_item = {}, width = 0, height = 1, size = 1, col = 0, row = 4, scrollbar = false },
eval('g:event')
)
feed('<Esc>')
screen:set_option('ext_popupmenu', false)
feed('Sf<C-N>')
screen:expect([[
foo |
bar |
foobar |
f^ |
{4:foo }{1: }|
{4:foobar }{1: }|
{1:~ }|
{5:-- Keyword completion (^N^P) }{19:Back at original} |
]])
eq(
{ completed_item = {}, width = 15, height = 2, size = 2, col = 0, row = 4, scrollbar = false },
eval('g:event')
)
feed('<C-N>')
screen:expect([[
foo |
bar |
foobar |
foo^ |
{12:foo }{1: }|
{4:foobar }{1: }|
{1:~ }|
{5:-- Keyword completion (^N^P) }{6:match 1 of 2} |
]])
eq('foo', eval('g:word'))
feed('<C-N>')
screen:expect([[
foo |
bar |
foobar |
foobar^ |
{4:foo }{1: }|
{12:foobar }{1: }|
{1:~ }|
{5:-- Keyword completion (^N^P) }{6:match 2 of 2} |
]])
eq('foobar', eval('g:word'))
feed('<up>')
screen:expect([[
foo |
bar |
foobar |
foobar^ |
{12:foo }{1: }|
{4:foobar }{1: }|
{1:~ }|
{5:-- Keyword completion (^N^P) }{6:match 1 of 2} |
]])
eq('foo', eval('g:word'))
feed('<down>')
screen:expect([[
foo |
bar |
foobar |
foobar^ |
{4:foo }{1: }|
{12:foobar }{1: }|
{1:~ }|
{5:-- Keyword completion (^N^P) }{6:match 2 of 2} |
]])
eq('foobar', eval('g:word'))
feed('<esc>')
end)
it('is stopped by :stopinsert from timer #12976', function()
screen:try_resize(32, 14)
command([[call setline(1, ['hello', 'hullo', 'heeee', ''])]])
feed('Gah<c-x><c-n>')
screen:expect([[
hello |
hullo |
heeee |
hello^ |
{12:hello }{1: }|
{4:hullo }{1: }|
{4:heeee }{1: }|
{1:~ }|*6
{5:-- }{6:match 1 of 3} |
]])
command([[call timer_start(100, { -> execute('stopinsert') })]])
vim.uv.sleep(200)
feed('k') -- cursor should move up in Normal mode
screen:expect([[
hello |
hullo |
heee^e |
hello |
{1:~ }|*9
|
]])
end)
-- oldtest: Test_complete_changed_complete_info()
it('no crash calling complete_info() in CompleteChanged', function()
source([[
set completeopt=menuone
autocmd CompleteChanged * call complete_info(['items'])
call feedkeys("iii\<cr>\<c-p>")
]])
screen:expect([[
ii |
ii^ |
{12:ii }{1: }|
{1:~ }|*4
{5:-- Keyword completion (^N^P) The only match} |
]])
assert_alive()
end)
it('no crash if text changed by first call to complete function #17489', function()
source([[
func Complete(findstart, base) abort
if a:findstart
let col = col('.')
call complete_add('#')
return col - 1
else
return []
endif
endfunc
set completeopt=longest
set completefunc=Complete
]])
feed('ifoo#<C-X><C-U>')
assert_alive()
end)
it('no crash using i_CTRL-X_CTRL-V to complete non-existent colorscheme', function()
feed('icolorscheme NOSUCHCOLORSCHEME<C-X><C-V>')
expect('colorscheme NOSUCHCOLORSCHEME')
assert_alive()
end)
it('complete with f flag #25598', function()
screen:try_resize(20, 9)
command('set complete+=f | edit foo | edit bar |edit foa |edit .hidden')
feed('i<C-n>')
screen:expect {
grid = [[
foo^ |
{12:foo }{1: }|
{4:bar }{1: }|
{4:foa }{1: }|
{4:.hidden }{1: }|
{1:~ }|*3
{5:-- }{6:match 1 of 4} |
]],
}
feed('<Esc>ccf<C-n>')
screen:expect {
grid = [[
foo^ |
{12:foo }{1: }|
{4:foa }{1: }|
{1:~ }|*5
{5:-- }{6:match 1 of 2} |
]],
}
end)
it('restores extmarks if original text is restored #23653', function()
screen:try_resize(screen._width, 4)
command([[
call setline(1, ['aaaa'])
let ns_id = nvim_create_namespace('extmark')
let mark_id = nvim_buf_set_extmark(0, ns_id, 0, 0, { 'end_col':2, 'hl_group':'Error'})
let mark = nvim_buf_get_extmark_by_id(0, ns_id, mark_id, { 'details':1 })
inoremap <C-x> <C-r>=Complete()<CR>
function Complete() abort
call complete(1, [{ 'word': 'aaaaa' }])
return ''
endfunction
]])
feed('A<C-X><C-E><Esc>')
eq(eval('mark'), eval("nvim_buf_get_extmark_by_id(0, ns_id, mark_id, { 'details':1 })"))
feed('A<C-N>')
eq(eval('mark'), eval("nvim_buf_get_extmark_by_id(0, ns_id, mark_id, { 'details':1 })"))
feed('<Esc>0Yppia<Esc>ggI<C-N>')
screen:expect([[
aaaa{9:^aa}aa |
{12:aaaa } |
{4:aaaaa } |
{5:-- Keyword completion (^N^P) }{6:match 1 of 2} |
]])
feed('<C-N><C-N><Esc>')
eq(eval('mark'), eval("nvim_buf_get_extmark_by_id(0, ns_id, mark_id, { 'details':1 })"))
feed('A<C-N>')
eq(eval('mark'), eval("nvim_buf_get_extmark_by_id(0, ns_id, mark_id, { 'details':1 })"))
feed('<C-N>')
screen:expect([[
aaaaa^ |
{4:aaaa } |
{12:aaaaa } |
{5:-- Keyword completion (^N^P) }{6:match 2 of 2} |
]])
feed('<C-E>')
screen:expect([[
{9:aa}aa^ |
aaaa |
aaaaa |
{5:-- INSERT --} |
]])
end)
end)