mirror of
https://github.com/neovim/neovim.git
synced 2025-01-01 17:23:36 -07:00
65fb622000
Hope this will make people using feed_command less likely: this hides bugs. Already found at least two: 1. msgpackparse() will show internal error: hash_add() in case of duplicate keys, though it will still work correctly. Currently silenced. 2. ttimeoutlen was spelled incorrectly, resulting in option not being set when expected. Test was still functioning somehow though. Currently fixed.
737 lines
27 KiB
Lua
737 lines
27 KiB
Lua
-- Test for various eval features.
|
|
|
|
local helpers = require('test.functional.helpers')(after_each)
|
|
local feed, insert, source = helpers.feed, helpers.insert, helpers.source
|
|
local clear, command, expect = helpers.clear, helpers.command, helpers.expect
|
|
local eq, eval, write_file = helpers.eq, helpers.eval, helpers.write_file
|
|
local wait = helpers.wait
|
|
local exc_exec = helpers.exc_exec
|
|
|
|
describe('eval', function()
|
|
setup(function()
|
|
write_file('test_eval_setup.vim', [[
|
|
set noswapfile
|
|
lang C
|
|
|
|
fun AppendRegContents(reg)
|
|
call AppendRegParts(a:reg, getregtype(a:reg), getreg(a:reg), string(getreg(a:reg, 0, 1)), getreg(a:reg, 1), string(getreg(a:reg, 1, 1)))
|
|
endfun
|
|
|
|
fun AppendRegParts(reg, type, cont, strcont, cont1, strcont1)
|
|
call append('$', printf('%s: type %s; value: %s (%s), expr: %s (%s)', a:reg, a:type, a:cont, a:strcont, a:cont1, a:strcont1))
|
|
endfun
|
|
|
|
command -nargs=? AR :call AppendRegContents(<q-args>)
|
|
|
|
fun SetReg(...)
|
|
call call('setreg', a:000)
|
|
call append('$', printf('{{{2 setreg(%s)', string(a:000)[1:-2]))
|
|
call AppendRegContents(a:1)
|
|
if a:1 isnot# '='
|
|
execute "silent normal! Go==\n==\e\"".a:1."P"
|
|
endif
|
|
endfun
|
|
]])
|
|
end)
|
|
before_each(clear)
|
|
teardown(function()
|
|
os.remove('test_eval_setup.vim')
|
|
end)
|
|
|
|
it(':let', function()
|
|
command('so test_eval_setup.vim')
|
|
command([[let @" = 'abc']])
|
|
command('AR "')
|
|
command([[let @" = "abc\n"]])
|
|
source('AR "')
|
|
command([[let @" = "abc\<C-m>"]])
|
|
command('AR "')
|
|
command([[let @= = '"abc"']])
|
|
command('AR =')
|
|
expect([[
|
|
|
|
": type v; value: abc (['abc']), expr: abc (['abc'])
|
|
": type V; value: abc]].."\000 (['abc']), expr: abc\000"..[[ (['abc'])
|
|
": type V; value: abc]].."\r\000 (['abc\r']), expr: abc\r\000 (['abc\r"..[['])
|
|
=: type v; value: abc (['abc']), expr: "abc" (['"abc"'])]])
|
|
end)
|
|
|
|
it('basic setreg() tests', function()
|
|
command('so test_eval_setup.vim')
|
|
insert('{{{1 Basic setreg tests')
|
|
command([[call SetReg('a', 'abcA', 'c')]])
|
|
command([[call SetReg('b', 'abcB', 'v')]])
|
|
command([[call SetReg('c', 'abcC', 'l')]])
|
|
command([[call SetReg('d', 'abcD', 'V')]])
|
|
command([[call SetReg('e', 'abcE', 'b')]])
|
|
command([[call SetReg('f', 'abcF', "\<C-v>")]])
|
|
command([[call SetReg('g', 'abcG', 'b10')]])
|
|
command([[call SetReg('h', 'abcH', "\<C-v>10")]])
|
|
command([[call SetReg('I', 'abcI')]])
|
|
|
|
feed('Go{{{1 Appending single lines with setreg()<esc>')
|
|
wait()
|
|
command([[call SetReg('A', 'abcAc', 'c')]])
|
|
command([[call SetReg('A', 'abcAl', 'l')]])
|
|
command([[call SetReg('A', 'abcAc2','c')]])
|
|
command([[call SetReg('b', 'abcBc', 'ca')]])
|
|
command([[call SetReg('b', 'abcBb', 'ba')]])
|
|
command([[call SetReg('b', 'abcBc2','ca')]])
|
|
command([[call SetReg('b', 'abcBb2','b50a')]])
|
|
command([[call SetReg('C', 'abcCl', 'l')]])
|
|
command([[call SetReg('C', 'abcCc', 'c')]])
|
|
command([[call SetReg('D', 'abcDb', 'b')]])
|
|
command([[call SetReg('E', 'abcEb', 'b')]])
|
|
command([[call SetReg('E', 'abcEl', 'l')]])
|
|
command([[call SetReg('F', 'abcFc', 'c')]])
|
|
expect([[
|
|
{{{1 Basic setreg tests
|
|
{{{2 setreg('a', 'abcA', 'c')
|
|
a: type v; value: abcA (['abcA']), expr: abcA (['abcA'])
|
|
==
|
|
=abcA=
|
|
{{{2 setreg('b', 'abcB', 'v')
|
|
b: type v; value: abcB (['abcB']), expr: abcB (['abcB'])
|
|
==
|
|
=abcB=
|
|
{{{2 setreg('c', 'abcC', 'l')
|
|
c: type V; value: abcC]].."\000 (['abcC']), expr: abcC\000"..[[ (['abcC'])
|
|
==
|
|
abcC
|
|
==
|
|
{{{2 setreg('d', 'abcD', 'V')
|
|
d: type V; value: abcD]].."\000 (['abcD']), expr: abcD\000"..[[ (['abcD'])
|
|
==
|
|
abcD
|
|
==
|
|
{{{2 setreg('e', 'abcE', 'b')
|
|
e: type ]]..'\022'..[[4; value: abcE (['abcE']), expr: abcE (['abcE'])
|
|
==
|
|
=abcE=
|
|
{{{2 setreg('f', 'abcF', ']]..'\022'..[[')
|
|
f: type ]]..'\022'..[[4; value: abcF (['abcF']), expr: abcF (['abcF'])
|
|
==
|
|
=abcF=
|
|
{{{2 setreg('g', 'abcG', 'b10')
|
|
g: type ]]..'\022'..[[10; value: abcG (['abcG']), expr: abcG (['abcG'])
|
|
==
|
|
=abcG =
|
|
{{{2 setreg('h', 'abcH', ']]..'\022'..[[10')
|
|
h: type ]]..'\022'..[[10; value: abcH (['abcH']), expr: abcH (['abcH'])
|
|
==
|
|
=abcH =
|
|
{{{2 setreg('I', 'abcI')
|
|
I: type v; value: abcI (['abcI']), expr: abcI (['abcI'])
|
|
==
|
|
=abcI=
|
|
{{{1 Appending single lines with setreg()
|
|
{{{2 setreg('A', 'abcAc', 'c')
|
|
A: type v; value: abcAabcAc (['abcAabcAc']), expr: abcAabcAc (['abcAabcAc'])
|
|
==
|
|
=abcAabcAc=
|
|
{{{2 setreg('A', 'abcAl', 'l')
|
|
A: type V; value: abcAabcAcabcAl]].."\000 (['abcAabcAcabcAl']), expr: abcAabcAcabcAl\000"..[[ (['abcAabcAcabcAl'])
|
|
==
|
|
abcAabcAcabcAl
|
|
==
|
|
{{{2 setreg('A', 'abcAc2', 'c')
|
|
A: type v; value: abcAabcAcabcAl]].."\000abcAc2 (['abcAabcAcabcAl', 'abcAc2']), expr: abcAabcAcabcAl\000"..[[abcAc2 (['abcAabcAcabcAl', 'abcAc2'])
|
|
==
|
|
=abcAabcAcabcAl
|
|
abcAc2=
|
|
{{{2 setreg('b', 'abcBc', 'ca')
|
|
b: type v; value: abcBabcBc (['abcBabcBc']), expr: abcBabcBc (['abcBabcBc'])
|
|
==
|
|
=abcBabcBc=
|
|
{{{2 setreg('b', 'abcBb', 'ba')
|
|
b: type ]]..'\022'..[[5; value: abcBabcBcabcBb (['abcBabcBcabcBb']), expr: abcBabcBcabcBb (['abcBabcBcabcBb'])
|
|
==
|
|
=abcBabcBcabcBb=
|
|
{{{2 setreg('b', 'abcBc2', 'ca')
|
|
b: type v; value: abcBabcBcabcBb]].."\000abcBc2 (['abcBabcBcabcBb', 'abcBc2']), expr: abcBabcBcabcBb\000"..[[abcBc2 (['abcBabcBcabcBb', 'abcBc2'])
|
|
==
|
|
=abcBabcBcabcBb
|
|
abcBc2=
|
|
{{{2 setreg('b', 'abcBb2', 'b50a')
|
|
b: type ]].."\02250; value: abcBabcBcabcBb\000abcBc2abcBb2 (['abcBabcBcabcBb', 'abcBc2abcBb2']), expr: abcBabcBcabcBb\000"..[[abcBc2abcBb2 (['abcBabcBcabcBb', 'abcBc2abcBb2'])
|
|
==
|
|
=abcBabcBcabcBb =
|
|
abcBc2abcBb2
|
|
{{{2 setreg('C', 'abcCl', 'l')
|
|
C: type V; value: abcC]].."\000abcCl\000 (['abcC', 'abcCl']), expr: abcC\000abcCl\000"..[[ (['abcC', 'abcCl'])
|
|
==
|
|
abcC
|
|
abcCl
|
|
==
|
|
{{{2 setreg('C', 'abcCc', 'c')
|
|
C: type v; value: abcC]].."\000abcCl\000abcCc (['abcC', 'abcCl', 'abcCc']), expr: abcC\000abcCl\000"..[[abcCc (['abcC', 'abcCl', 'abcCc'])
|
|
==
|
|
=abcC
|
|
abcCl
|
|
abcCc=
|
|
{{{2 setreg('D', 'abcDb', 'b')
|
|
D: type ]].."\0225; value: abcD\000abcDb (['abcD', 'abcDb']), expr: abcD\000"..[[abcDb (['abcD', 'abcDb'])
|
|
==
|
|
=abcD =
|
|
abcDb
|
|
{{{2 setreg('E', 'abcEb', 'b')
|
|
E: type ]].."\0225; value: abcE\000abcEb (['abcE', 'abcEb']), expr: abcE\000"..[[abcEb (['abcE', 'abcEb'])
|
|
==
|
|
=abcE =
|
|
abcEb
|
|
{{{2 setreg('E', 'abcEl', 'l')
|
|
E: type V; value: abcE]].."\000abcEb\000abcEl\000 (['abcE', 'abcEb', 'abcEl']), expr: abcE\000abcEb\000abcEl\000"..[[ (['abcE', 'abcEb', 'abcEl'])
|
|
==
|
|
abcE
|
|
abcEb
|
|
abcEl
|
|
==
|
|
{{{2 setreg('F', 'abcFc', 'c')
|
|
F: type v; value: abcF]].."\000abcFc (['abcF', 'abcFc']), expr: abcF\000"..[[abcFc (['abcF', 'abcFc'])
|
|
==
|
|
=abcF
|
|
abcFc=]])
|
|
end)
|
|
|
|
it('appending NL with setreg()', function()
|
|
command('so test_eval_setup.vim')
|
|
|
|
command([[call setreg('a', 'abcA2', 'c')]])
|
|
command([[call setreg('b', 'abcB2', 'v')]])
|
|
command([[call setreg('c', 'abcC2', 'l')]])
|
|
command([[call setreg('d', 'abcD2', 'V')]])
|
|
command([[call setreg('e', 'abcE2', 'b')]])
|
|
command([[call setreg('f', 'abcF2', "\<C-v>")]])
|
|
-- These registers where set like this in the old test_eval.in but never
|
|
-- copied to the output buffer with SetReg(). They do not appear in
|
|
-- test_eval.ok. Therefore they are commented out.
|
|
--execute([[call setreg('g', 'abcG2', 'b10')]])
|
|
--execute([[call setreg('h', 'abcH2', "\<C-v>10")]])
|
|
--execute([[call setreg('I', 'abcI2')]])
|
|
|
|
command([[call SetReg('A', "\n")]])
|
|
command([[call SetReg('B', "\n", 'c')]])
|
|
command([[call SetReg('C', "\n")]])
|
|
command([[call SetReg('D', "\n", 'l')]])
|
|
command([[call SetReg('E', "\n")]])
|
|
command([[call SetReg('F', "\n", 'b')]])
|
|
expect([[
|
|
|
|
{{{2 setreg('A', ']]..'\000'..[[')
|
|
A: type V; value: abcA2]].."\000 (['abcA2']), expr: abcA2\000"..[[ (['abcA2'])
|
|
==
|
|
abcA2
|
|
==
|
|
{{{2 setreg('B', ']]..'\000'..[[', 'c')
|
|
B: type v; value: abcB2]].."\000 (['abcB2', '']), expr: abcB2\000"..[[ (['abcB2', ''])
|
|
==
|
|
=abcB2
|
|
=
|
|
{{{2 setreg('C', ']]..'\000'..[[')
|
|
C: type V; value: abcC2]].."\000\000 (['abcC2', '']), expr: abcC2\000\000"..[[ (['abcC2', ''])
|
|
==
|
|
abcC2
|
|
|
|
==
|
|
{{{2 setreg('D', ']]..'\000'..[[', 'l')
|
|
D: type V; value: abcD2]].."\000\000 (['abcD2', '']), expr: abcD2\000\000"..[[ (['abcD2', ''])
|
|
==
|
|
abcD2
|
|
|
|
==
|
|
{{{2 setreg('E', ']]..'\000'..[[')
|
|
E: type V; value: abcE2]].."\000\000 (['abcE2', '']), expr: abcE2\000\000"..[[ (['abcE2', ''])
|
|
==
|
|
abcE2
|
|
|
|
==
|
|
{{{2 setreg('F', ']]..'\000'..[[', 'b')
|
|
F: type ]].."\0220; value: abcF2\000 (['abcF2', '']), expr: abcF2\000"..[[ (['abcF2', ''])
|
|
==
|
|
=abcF2=
|
|
]])
|
|
end)
|
|
|
|
it('setting and appending list with setreg()', function()
|
|
command('so test_eval_setup.vim')
|
|
|
|
command([[$put ='{{{1 Setting lists with setreg()']])
|
|
command([=[call SetReg('a', ['abcA3'], 'c')]=])
|
|
command([=[call SetReg('b', ['abcB3'], 'l')]=])
|
|
command([=[call SetReg('c', ['abcC3'], 'b')]=])
|
|
command([=[call SetReg('d', ['abcD3'])]=])
|
|
command([=[call SetReg('e', [1, 2, 'abc', 3])]=])
|
|
command([=[call SetReg('f', [1, 2, 3])]=])
|
|
|
|
command([[$put ='{{{1 Appending lists with setreg()']])
|
|
command([=[call SetReg('A', ['abcA3c'], 'c')]=])
|
|
command([=[call SetReg('b', ['abcB3l'], 'la')]=])
|
|
command([=[call SetReg('C', ['abcC3b'], 'lb')]=])
|
|
command([=[call SetReg('D', ['abcD32'])]=])
|
|
command([=[call SetReg('A', ['abcA32'])]=])
|
|
command([=[call SetReg('B', ['abcB3c'], 'c')]=])
|
|
command([=[call SetReg('C', ['abcC3l'], 'l')]=])
|
|
command([=[call SetReg('D', ['abcD3b'], 'b')]=])
|
|
expect([[
|
|
|
|
{{{1 Setting lists with setreg()
|
|
{{{2 setreg('a', ['abcA3'], 'c')
|
|
a: type v; value: abcA3 (['abcA3']), expr: abcA3 (['abcA3'])
|
|
==
|
|
=abcA3=
|
|
{{{2 setreg('b', ['abcB3'], 'l')
|
|
b: type V; value: abcB3]].."\000 (['abcB3']), expr: abcB3\000"..[[ (['abcB3'])
|
|
==
|
|
abcB3
|
|
==
|
|
{{{2 setreg('c', ['abcC3'], 'b')
|
|
c: type ]]..'\022'..[[5; value: abcC3 (['abcC3']), expr: abcC3 (['abcC3'])
|
|
==
|
|
=abcC3=
|
|
{{{2 setreg('d', ['abcD3'])
|
|
d: type V; value: abcD3]].."\000 (['abcD3']), expr: abcD3\000"..[[ (['abcD3'])
|
|
==
|
|
abcD3
|
|
==
|
|
{{{2 setreg('e', [1, 2, 'abc', 3])
|
|
e: type V; value: 1]].."\0002\000abc\0003\000 (['1', '2', 'abc', '3']), expr: 1\0002\000abc\0003\000"..[[ (['1', '2', 'abc', '3'])
|
|
==
|
|
1
|
|
2
|
|
abc
|
|
3
|
|
==
|
|
{{{2 setreg('f', [1, 2, 3])
|
|
f: type V; value: 1]].."\0002\0003\000 (['1', '2', '3']), expr: 1\0002\0003\000"..[[ (['1', '2', '3'])
|
|
==
|
|
1
|
|
2
|
|
3
|
|
==
|
|
{{{1 Appending lists with setreg()
|
|
{{{2 setreg('A', ['abcA3c'], 'c')
|
|
A: type v; value: abcA3]].."\000abcA3c (['abcA3', 'abcA3c']), expr: abcA3\000"..[[abcA3c (['abcA3', 'abcA3c'])
|
|
==
|
|
=abcA3
|
|
abcA3c=
|
|
{{{2 setreg('b', ['abcB3l'], 'la')
|
|
b: type V; value: abcB3]].."\000abcB3l\000 (['abcB3', 'abcB3l']), expr: abcB3\000abcB3l\000"..[[ (['abcB3', 'abcB3l'])
|
|
==
|
|
abcB3
|
|
abcB3l
|
|
==
|
|
{{{2 setreg('C', ['abcC3b'], 'lb')
|
|
C: type ]].."\0226; value: abcC3\000abcC3b (['abcC3', 'abcC3b']), expr: abcC3\000"..[[abcC3b (['abcC3', 'abcC3b'])
|
|
==
|
|
=abcC3 =
|
|
abcC3b
|
|
{{{2 setreg('D', ['abcD32'])
|
|
D: type V; value: abcD3]].."\000abcD32\000 (['abcD3', 'abcD32']), expr: abcD3\000abcD32\000"..[[ (['abcD3', 'abcD32'])
|
|
==
|
|
abcD3
|
|
abcD32
|
|
==
|
|
{{{2 setreg('A', ['abcA32'])
|
|
A: type V; value: abcA3]].."\000abcA3c\000abcA32\000 (['abcA3', 'abcA3c', 'abcA32']), expr: abcA3\000abcA3c\000abcA32\000"..[[ (['abcA3', 'abcA3c', 'abcA32'])
|
|
==
|
|
abcA3
|
|
abcA3c
|
|
abcA32
|
|
==
|
|
{{{2 setreg('B', ['abcB3c'], 'c')
|
|
B: type v; value: abcB3]].."\000abcB3l\000abcB3c (['abcB3', 'abcB3l', 'abcB3c']), expr: abcB3\000abcB3l\000"..[[abcB3c (['abcB3', 'abcB3l', 'abcB3c'])
|
|
==
|
|
=abcB3
|
|
abcB3l
|
|
abcB3c=
|
|
{{{2 setreg('C', ['abcC3l'], 'l')
|
|
C: type V; value: abcC3]].."\000abcC3b\000abcC3l\000 (['abcC3', 'abcC3b', 'abcC3l']), expr: abcC3\000abcC3b\000abcC3l\000"..[[ (['abcC3', 'abcC3b', 'abcC3l'])
|
|
==
|
|
abcC3
|
|
abcC3b
|
|
abcC3l
|
|
==
|
|
{{{2 setreg('D', ['abcD3b'], 'b')
|
|
D: type ]].."\0226; value: abcD3\000abcD32\000abcD3b (['abcD3', 'abcD32', 'abcD3b']), expr: abcD3\000abcD32\000"..[[abcD3b (['abcD3', 'abcD32', 'abcD3b'])
|
|
==
|
|
=abcD3 =
|
|
abcD32
|
|
abcD3b]])
|
|
|
|
-- From now on we delete the buffer contents after each expect() to make
|
|
-- the next expect() easier to write. This is neccessary because null
|
|
-- bytes on a line by itself don't play well together with the dedent
|
|
-- function used in expect().
|
|
command('%delete')
|
|
command([[$put ='{{{1 Appending lists with NL with setreg()']])
|
|
command([=[call SetReg('A', ["\n", 'abcA3l2'], 'l')]=])
|
|
expect(
|
|
'\n'..
|
|
'{{{1 Appending lists with NL with setreg()\n'..
|
|
"{{{2 setreg('A', ['\000', 'abcA3l2'], 'l')\n"..
|
|
"A: type V; value: abcA3\000abcA3c\000abcA32\000\000\000abcA3l2\000 (['abcA3', 'abcA3c', 'abcA32', '\000', 'abcA3l2']), expr: abcA3\000abcA3c\000abcA32\000\000\000abcA3l2\000 (['abcA3', 'abcA3c', 'abcA32', '\000', 'abcA3l2'])\n"..
|
|
'==\n'..
|
|
'abcA3\n'..
|
|
'abcA3c\n'..
|
|
'abcA32\n'..
|
|
'\000\n'..
|
|
'abcA3l2\n'..
|
|
'==')
|
|
command('%delete')
|
|
command([=[call SetReg('B', ["\n", 'abcB3c2'], 'c')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('B', ['\000', 'abcB3c2'], 'c')\n"..
|
|
"B: type v; value: abcB3\000abcB3l\000abcB3c\000\000\000abcB3c2 (['abcB3', 'abcB3l', 'abcB3c', '\000', 'abcB3c2']), expr: abcB3\000abcB3l\000abcB3c\000\000\000abcB3c2 (['abcB3', 'abcB3l', 'abcB3c', '\000', 'abcB3c2'])\n"..
|
|
'==\n'..
|
|
'=abcB3\n'..
|
|
'abcB3l\n'..
|
|
'abcB3c\n'..
|
|
'\000\n'..
|
|
'abcB3c2=')
|
|
command('%delete')
|
|
command([=[call SetReg('C', ["\n", 'abcC3b2'], 'b')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('C', ['\000', 'abcC3b2'], 'b')\n"..
|
|
"C: type \0227; value: abcC3\000abcC3b\000abcC3l\000\000\000abcC3b2 (['abcC3', 'abcC3b', 'abcC3l', '\000', 'abcC3b2']), expr: abcC3\000abcC3b\000abcC3l\000\000\000abcC3b2 (['abcC3', 'abcC3b', 'abcC3l', '\000', 'abcC3b2'])\n"..
|
|
'==\n'..
|
|
'=abcC3 =\n'..
|
|
' abcC3b\n'..
|
|
' abcC3l\n'..
|
|
' \000\n'..
|
|
' abcC3b2')
|
|
command('%delete')
|
|
command([=[call SetReg('D', ["\n", 'abcD3b50'],'b50')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('D', ['\000', 'abcD3b50'], 'b50')\n"..
|
|
"D: type \02250; value: abcD3\000abcD32\000abcD3b\000\000\000abcD3b50 (['abcD3', 'abcD32', 'abcD3b', '\000', 'abcD3b50']), expr: abcD3\000abcD32\000abcD3b\000\000\000abcD3b50 (['abcD3', 'abcD32', 'abcD3b', '\000', 'abcD3b50'])\n"..
|
|
'==\n'..
|
|
'=abcD3 =\n'..
|
|
' abcD32\n'..
|
|
' abcD3b\n'..
|
|
' \000\n'..
|
|
' abcD3b50')
|
|
end)
|
|
|
|
-- The tests for setting lists with NLs are split into seperate it() blocks
|
|
-- to make the expect() calls easier to write. Otherwise the null byte can
|
|
-- make trouble on a line on its own.
|
|
it('setting lists with NLs with setreg(), part 1', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('a', ['abcA4-0', "\n", "abcA4-2\n", "\nabcA4-3", "abcA4-4\nabcA4-4-2"])]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('a', ['abcA4-0', '\000', 'abcA4-2\000', '\000abcA4-3', 'abcA4-4\000abcA4-4-2'])\n"..
|
|
"a: type V; value: abcA4-0\000\000\000abcA4-2\000\000\000abcA4-3\000abcA4-4\000abcA4-4-2\000 (['abcA4-0', '\000', 'abcA4-2\000', '\000abcA4-3', 'abcA4-4\000abcA4-4-2']), expr: abcA4-0\000\000\000abcA4-2\000\000\000abcA4-3\000abcA4-4\000abcA4-4-2\000 (['abcA4-0', '\000', 'abcA4-2\000', '\000abcA4-3', 'abcA4-4\000abcA4-4-2'])\n"..
|
|
'==\n'..
|
|
'abcA4-0\n'..
|
|
'\000\n'..
|
|
'abcA4-2\000\n'..
|
|
'\000abcA4-3\n'..
|
|
'abcA4-4\000abcA4-4-2\n'..
|
|
'==')
|
|
end)
|
|
|
|
it('setting lists with NLs with setreg(), part 2', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('b', ['abcB4c-0', "\n", "abcB4c-2\n", "\nabcB4c-3", "abcB4c-4\nabcB4c-4-2"], 'c')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('b', ['abcB4c-0', '\000', 'abcB4c-2\000', '\000abcB4c-3', 'abcB4c-4\000abcB4c-4-2'], 'c')\n"..
|
|
"b: type v; value: abcB4c-0\000\000\000abcB4c-2\000\000\000abcB4c-3\000abcB4c-4\000abcB4c-4-2 (['abcB4c-0', '\000', 'abcB4c-2\000', '\000abcB4c-3', 'abcB4c-4\000abcB4c-4-2']), expr: abcB4c-0\000\000\000abcB4c-2\000\000\000abcB4c-3\000abcB4c-4\000abcB4c-4-2 (['abcB4c-0', '\000', 'abcB4c-2\000', '\000abcB4c-3', 'abcB4c-4\000abcB4c-4-2'])\n"..
|
|
'==\n'..
|
|
'=abcB4c-0\n'..
|
|
'\000\n'..
|
|
'abcB4c-2\000\n'..
|
|
'\000abcB4c-3\n'..
|
|
'abcB4c-4\000abcB4c-4-2=')
|
|
end)
|
|
|
|
it('setting lists with NLs with setreg(), part 3', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('c', ['abcC4l-0', "\n", "abcC4l-2\n", "\nabcC4l-3", "abcC4l-4\nabcC4l-4-2"], 'l')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('c', ['abcC4l-0', '\000', 'abcC4l-2\000', '\000abcC4l-3', 'abcC4l-4\000abcC4l-4-2'], 'l')\n"..
|
|
"c: type V; value: abcC4l-0\000\000\000abcC4l-2\000\000\000abcC4l-3\000abcC4l-4\000abcC4l-4-2\000 (['abcC4l-0', '\000', 'abcC4l-2\000', '\000abcC4l-3', 'abcC4l-4\000abcC4l-4-2']), expr: abcC4l-0\000\000\000abcC4l-2\000\000\000abcC4l-3\000abcC4l-4\000abcC4l-4-2\000 (['abcC4l-0', '\000', 'abcC4l-2\000', '\000abcC4l-3', 'abcC4l-4\000abcC4l-4-2'])\n"..
|
|
'==\n'..
|
|
'abcC4l-0\n'..
|
|
'\000\n'..
|
|
'abcC4l-2\000\n'..
|
|
'\000abcC4l-3\n'..
|
|
'abcC4l-4\000abcC4l-4-2\n'..
|
|
'==')
|
|
end)
|
|
it('setting lists with NLs with setreg(), part 4', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('d', ['abcD4b-0', "\n", "abcD4b-2\n", "\nabcD4b-3", "abcD4b-4\nabcD4b-4-2"], 'b')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('d', ['abcD4b-0', '\000', 'abcD4b-2\000', '\000abcD4b-3', 'abcD4b-4\000abcD4b-4-2'], 'b')\n"..
|
|
"d: type \02219; value: abcD4b-0\000\000\000abcD4b-2\000\000\000abcD4b-3\000abcD4b-4\000abcD4b-4-2 (['abcD4b-0', '\000', 'abcD4b-2\000', '\000abcD4b-3', 'abcD4b-4\000abcD4b-4-2']), expr: abcD4b-0\000\000\000abcD4b-2\000\000\000abcD4b-3\000abcD4b-4\000abcD4b-4-2 (['abcD4b-0', '\000', 'abcD4b-2\000', '\000abcD4b-3', 'abcD4b-4\000abcD4b-4-2'])\n"..
|
|
'==\n'..
|
|
'=abcD4b-0 =\n'..
|
|
' \000\n'..
|
|
' abcD4b-2\000\n'..
|
|
' \000abcD4b-3\n'..
|
|
' abcD4b-4\000abcD4b-4-2')
|
|
end)
|
|
it('setting lists with NLs with setreg(), part 5', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('e', ['abcE4b10-0', "\n", "abcE4b10-2\n", "\nabcE4b10-3", "abcE4b10-4\nabcE4b10-4-2"], 'b10')]=])
|
|
expect(
|
|
'\n'..
|
|
"{{{2 setreg('e', ['abcE4b10-0', '\000', 'abcE4b10-2\000', '\000abcE4b10-3', 'abcE4b10-4\000abcE4b10-4-2'], 'b10')\n"..
|
|
"e: type \02210; value: abcE4b10-0\000\000\000abcE4b10-2\000\000\000abcE4b10-3\000abcE4b10-4\000abcE4b10-4-2 (['abcE4b10-0', '\000', 'abcE4b10-2\000', '\000abcE4b10-3', 'abcE4b10-4\000abcE4b10-4-2']), expr: abcE4b10-0\000\000\000abcE4b10-2\000\000\000abcE4b10-3\000abcE4b10-4\000abcE4b10-4-2 (['abcE4b10-0', '\000', 'abcE4b10-2\000', '\000abcE4b10-3', 'abcE4b10-4\000abcE4b10-4-2'])\n"..
|
|
'==\n'..
|
|
'=abcE4b10-0=\n'..
|
|
' \000\n'..
|
|
' abcE4b10-2\000\n'..
|
|
' \000abcE4b10-3\n'..
|
|
' abcE4b10-4\000abcE4b10-4-2')
|
|
end)
|
|
|
|
it('getreg("a",1,1) returns a valid list when "a is unset', function()
|
|
-- Precondition: "a is actually unset and "0 is nonempty
|
|
eq('', eval("getregtype('a')"))
|
|
eq('', eval("getreg('a')"))
|
|
command("call setreg('0','text')")
|
|
|
|
-- This used to return a NULL list
|
|
-- which setreg didn't handle
|
|
command("let x = getreg('a',1,1)")
|
|
command("call setreg('0',x)")
|
|
|
|
-- nvim didn't crash and "0 was emptied
|
|
eq(2, eval("1+1"))
|
|
eq({}, eval("getreg('0',1,1)"))
|
|
|
|
-- x is a mutable list
|
|
command("let y = x")
|
|
eq({}, eval("y"))
|
|
command("call add(x, 'item')")
|
|
eq({'item'}, eval("y"))
|
|
end)
|
|
|
|
it('search and expressions', function()
|
|
command('so test_eval_setup.vim')
|
|
command([=[call SetReg('/', ['abc/'])]=])
|
|
command([=[call SetReg('/', ["abc/\n"])]=])
|
|
command([=[call SetReg('=', ['"abc/"'])]=])
|
|
command([=[call SetReg('=', ["\"abc/\n\""])]=])
|
|
expect([[
|
|
|
|
{{{2 setreg('/', ['abc/'])
|
|
/: type v; value: abc/ (['abc/']), expr: abc/ (['abc/'])
|
|
==
|
|
=abc/=
|
|
{{{2 setreg('/', ['abc/]]..'\000'..[['])
|
|
/: type v; value: abc/]].."\000 (['abc/\000']), expr: abc/\000 (['abc/\000"..[['])
|
|
==
|
|
=abc/]]..'\000'..[[=
|
|
{{{2 setreg('=', ['"abc/"'])
|
|
=: type v; value: abc/ (['abc/']), expr: "abc/" (['"abc/"'])
|
|
{{{2 setreg('=', ['"abc/]]..'\000'..[["'])
|
|
=: type v; value: abc/]].."\000 (['abc/\000"..[[']), expr: "abc/]]..'\000'..[[" (['"abc/]]..'\000'..[["'])]])
|
|
end)
|
|
|
|
describe('system clipboard', function()
|
|
before_each(function()
|
|
command('let &runtimepath = "test/functional/fixtures,".&runtimepath')
|
|
command('call getreg("*")') -- force load of provider
|
|
end)
|
|
|
|
it('works', function()
|
|
insert([[
|
|
Some first line (this text was at the top of the old test_eval.in).
|
|
|
|
Note: system clipboard is saved, changed and restored.
|
|
|
|
clipboard contents
|
|
something else]])
|
|
command('so test_eval_setup.vim')
|
|
-- Save and restore system clipboard.
|
|
command("let _clipreg = ['*', getreg('*'), getregtype('*')]")
|
|
command('let _clipopt = &cb')
|
|
command("let &cb='unnamed'")
|
|
command('5y')
|
|
command('AR *')
|
|
command('tabdo :windo :echo "hi"')
|
|
command('6y')
|
|
command('AR *')
|
|
command('let &cb=_clipopt')
|
|
command("call call('setreg', _clipreg)")
|
|
expect([[
|
|
Some first line (this text was at the top of the old test_eval.in).
|
|
|
|
Note: system clipboard is saved, changed and restored.
|
|
|
|
clipboard contents
|
|
something else
|
|
*: type V; value: clipboard contents]]..'\00'..[[ (['clipboard contents']), expr: clipboard contents]]..'\00'..[[ (['clipboard contents'])
|
|
*: type V; value: something else]]..'\00'..[[ (['something else']), expr: something else]]..'\00'..[[ (['something else'])]])
|
|
end)
|
|
end)
|
|
|
|
it('errors', function()
|
|
source([[
|
|
fun ErrExe(str)
|
|
call append('$', 'Executing '.a:str)
|
|
try
|
|
execute a:str
|
|
catch
|
|
$put =v:exception
|
|
endtry
|
|
endfun]])
|
|
command([[call ErrExe('call setreg()')]])
|
|
command([[call ErrExe('call setreg(1)')]])
|
|
command([[call ErrExe('call setreg(1, 2, 3, 4)')]])
|
|
command([=[call ErrExe('call setreg([], 2)')]=])
|
|
command([[call ErrExe('call setreg(1, {})')]])
|
|
command([=[call ErrExe('call setreg(1, 2, [])')]=])
|
|
command([=[call ErrExe('call setreg("/", ["1", "2"])')]=])
|
|
command([=[call ErrExe('call setreg("=", ["1", "2"])')]=])
|
|
command([=[call ErrExe('call setreg(1, ["", "", [], ""])')]=])
|
|
expect([[
|
|
|
|
Executing call setreg()
|
|
Vim(call):E119: Not enough arguments for function: setreg
|
|
Executing call setreg(1)
|
|
Vim(call):E119: Not enough arguments for function: setreg
|
|
Executing call setreg(1, 2, 3, 4)
|
|
Vim(call):E118: Too many arguments for function: setreg
|
|
Executing call setreg([], 2)
|
|
Vim(call):E730: using List as a String
|
|
Executing call setreg(1, {})
|
|
Vim(call):E731: using Dictionary as a String
|
|
Executing call setreg(1, 2, [])
|
|
Vim(call):E730: using List as a String
|
|
Executing call setreg("/", ["1", "2"])
|
|
Vim(call):E883: search pattern and expression register may not contain two or more lines
|
|
Executing call setreg("=", ["1", "2"])
|
|
Vim(call):E883: search pattern and expression register may not contain two or more lines
|
|
Executing call setreg(1, ["", "", [], ""])
|
|
Vim(call):E730: using List as a String]])
|
|
end)
|
|
|
|
it('function name not starting with a capital', function()
|
|
command('try')
|
|
command(' func! g:test()')
|
|
command(' echo "test"')
|
|
command(' endfunc')
|
|
command('catch')
|
|
command(' let tmp = v:exception')
|
|
command('endtry')
|
|
eq('Vim(function):E128: Function name must start with a capital or "s:": g:test()', eval('tmp'))
|
|
end)
|
|
|
|
it('Function name followed by #', function()
|
|
command('try')
|
|
command(' func! test2() "#')
|
|
command(' echo "test2"')
|
|
command(' endfunc')
|
|
command('catch')
|
|
command(' let tmp = v:exception')
|
|
command('endtry')
|
|
eq('Vim(function):E128: Function name must start with a capital or "s:": test2() "#', eval('tmp'))
|
|
end)
|
|
|
|
it('function name includes a colon', function()
|
|
command('try')
|
|
command(' func! b:test()')
|
|
command(' echo "test"')
|
|
command(' endfunc')
|
|
command('catch')
|
|
command(' let tmp = v:exception')
|
|
command('endtry')
|
|
eq('Vim(function):E128: Function name must start with a capital or "s:": b:test()', eval('tmp'))
|
|
end)
|
|
|
|
it('function name starting with/without "g:", buffer-local funcref', function()
|
|
command('function! g:Foo(n)')
|
|
command(" $put ='called Foo(' . a:n . ')'")
|
|
command('endfunction')
|
|
command("let b:my_func = function('Foo')")
|
|
command('call b:my_func(1)')
|
|
command('echo g:Foo(2)')
|
|
command('echo Foo(3)')
|
|
expect([[
|
|
|
|
called Foo(1)
|
|
called Foo(2)
|
|
called Foo(3)]])
|
|
end)
|
|
|
|
it('script-local function used in Funcref must exist', function()
|
|
source([[
|
|
" Vim script used in test_eval.in. Needed for script-local function.
|
|
|
|
func! s:Testje()
|
|
return "foo"
|
|
endfunc
|
|
|
|
let Bar = function('s:Testje')
|
|
|
|
$put ='s:Testje exists: ' . exists('s:Testje')
|
|
$put ='func s:Testje exists: ' . exists('*s:Testje')
|
|
$put ='Bar exists: ' . exists('Bar')
|
|
$put ='func Bar exists: ' . exists('*Bar')
|
|
]])
|
|
expect([[
|
|
|
|
s:Testje exists: 0
|
|
func s:Testje exists: 1
|
|
Bar exists: 1
|
|
func Bar exists: 1]])
|
|
end)
|
|
|
|
it("using $ instead of '$' must give an error", function()
|
|
eq('Vim(call):E116: Invalid arguments for function append',
|
|
exc_exec('call append($, "foobar")'))
|
|
end)
|
|
|
|
it('getcurpos/setpos', function()
|
|
insert([[
|
|
012345678
|
|
012345678
|
|
|
|
start:]])
|
|
command('/^012345678')
|
|
feed('6l')
|
|
wait()
|
|
command('let sp = getcurpos()')
|
|
feed('0')
|
|
wait()
|
|
command("call setpos('.', sp)")
|
|
feed('jyl')
|
|
wait()
|
|
command('$put')
|
|
expect([[
|
|
012345678
|
|
012345678
|
|
|
|
start:
|
|
6]])
|
|
end)
|
|
|
|
it('substring and variable name', function()
|
|
command("let str = 'abcdef'")
|
|
command('let n = 3')
|
|
eq('def', eval('str[n:]'))
|
|
eq('abcd', eval('str[:n]'))
|
|
eq('d', eval('str[n:n]'))
|
|
command('unlet n')
|
|
command('let nn = 3')
|
|
eq('def', eval('str[nn:]'))
|
|
eq('abcd', eval('str[:nn]'))
|
|
eq('d', eval('str[nn:nn]'))
|
|
command('unlet nn')
|
|
command('let b:nn = 4')
|
|
eq('ef', eval('str[b:nn:]'))
|
|
eq('abcde', eval('str[:b:nn]'))
|
|
eq('e', eval('str[b:nn:b:nn]'))
|
|
end)
|
|
end)
|