GitHub/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim synced 2025-07-16 01:01:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: Eliminate expect_err

Browse Source 
Eliminate `expect_err` in favor of `pcall_err` + `eq` or `matches`.
This commit is contained in:
Justin M. Keyes
2019-09-06 17:17:37 -07:00
parent af946046b9
commit 7e1c959861
21 changed files with 214 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
test/functional/api/buffer_spec.lua
View File

@ -13,7 +13,6 @@ local NIL = helpers.NIL
local command = helpers.command
local bufmeths = helpers.bufmeths
local feed = helpers.feed
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
describe('api/buf', function()
@ -191,14 +190,14 @@ describe('api/buf', function()
it('fails correctly when input is not valid', function()
eq(1, curbufmeths.get_number())
expect_err([[String cannot contain newlines]],
bufmeths.set_lines, 1, 1, 2, false, {'b\na'})
eq([[String cannot contain newlines]],
pcall_err(bufmeths.set_lines, 1, 1, 2, false, {'b\na'}))
end)
it("fails if 'nomodifiable'", function()
command('set nomodifiable')
expect_err([[Buffer is not 'modifiable']],
bufmeths.set_lines, 1, 1, 2, false, {'a','b'})
eq([[Buffer is not 'modifiable']],
pcall_err(bufmeths.set_lines, 1, 1, 2, false, {'a','b'}))
end)
it('has correct line_count when inserting and deleting', function()

4
test/functional/api/buffer_updates_spec.lua
View File

@ -3,8 +3,8 @@ local clear = helpers.clear
local eq, ok = helpers.eq, helpers.ok
local buffer, command, eval, nvim, next_msg = helpers.buffer,
helpers.command, helpers.eval, helpers.nvim, helpers.next_msg
local expect_err = helpers.expect_err
local nvim_prog = helpers.nvim_prog
local pcall_err = helpers.pcall_err
local sleep = helpers.sleep
local write_file = helpers.write_file
@ -760,7 +760,7 @@ describe('API: buffer events:', function()
it('returns a proper error on nonempty options dict', function()
clear()
local b = editoriginal(false)
expect_err("unexpected key: builtin", buffer, 'attach', b, false, {builtin="asfd"})
eq("unexpected key: builtin", pcall_err(buffer, 'attach', b, false, {builtin="asfd"}))
end)
it('nvim_buf_attach returns response after delay #8634', function()

10
test/functional/api/command_spec.lua
View File

@ -5,9 +5,9 @@ local clear = helpers.clear
local command = helpers.command
local curbufmeths = helpers.curbufmeths
local eq = helpers.eq
local expect_err = helpers.expect_err
local meths = helpers.meths
local source = helpers.source
local pcall_err = helpers.pcall_err
describe('nvim_get_commands', function()
local cmd_dict = { addr=NIL, bang=false, bar=false, complete=NIL, complete_arg=NIL, count=NIL, definition='echo "Hello World"', name='Hello', nargs='1', range=NIL, register=false, script_id=0, }
@ -19,10 +19,10 @@ describe('nvim_get_commands', function()
end)
it('validates input', function()
expect_err('builtin=true not implemented', meths.get_commands,
{builtin=true})
expect_err('unexpected key: foo', meths.get_commands,
{foo='blah'})
eq('builtin=true not implemented', pcall_err(meths.get_commands,
{builtin=true}))
eq('unexpected key: foo', pcall_err(meths.get_commands,
{foo='blah'}))
end)
it('gets global user-defined commands', function()

95
test/functional/api/keymap_spec.lua
View File

@ -5,11 +5,11 @@ local clear = helpers.clear
local command = helpers.command
local curbufmeths = helpers.curbufmeths
local eq, neq = helpers.eq, helpers.neq
local expect_err = helpers.expect_err
local feed = helpers.feed
local funcs = helpers.funcs
local meths = helpers.meths
local source = helpers.source
local pcall_err = helpers.pcall_err
local shallowcopy = helpers.shallowcopy
local sleep = helpers.sleep
@ -360,12 +360,9 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
it('error on empty LHS', function()
-- escape parentheses in lua string, else comparison fails erroneously
expect_err('Invalid %(empty%) LHS',
meths.set_keymap, '', '', 'rhs', {})
expect_err('Invalid %(empty%) LHS',
meths.set_keymap, '', '', '', {})
expect_err('Invalid %(empty%) LHS', meths.del_keymap, '', '')
eq('Invalid (empty) LHS', pcall_err(meths.set_keymap, '', '', 'rhs', {}))
eq('Invalid (empty) LHS', pcall_err(meths.set_keymap, '', '', '', {}))
eq('Invalid (empty) LHS', pcall_err(meths.del_keymap, '', ''))
end)
it('error if LHS longer than MAXMAPLEN', function()
@ -385,10 +382,10 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
-- 51 chars should produce an error
lhs = lhs..'1'
expect_err('LHS exceeds maximum map length: '..lhs,
meths.set_keymap, '', lhs, 'rhs', {})
expect_err('LHS exceeds maximum map length: '..lhs,
meths.del_keymap, '', lhs)
eq('LHS exceeds maximum map length: '..lhs,
pcall_err(meths.set_keymap, '', lhs, 'rhs', {}))
eq('LHS exceeds maximum map length: '..lhs,
pcall_err(meths.del_keymap, '', lhs))
end)
it('does not throw errors when rhs is longer than MAXMAPLEN', function()
@ -404,48 +401,48 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
end)
it('throws errors when given too-long mode shortnames', function()
expect_err('Shortname is too long: map',
meths.set_keymap, 'map', 'lhs', 'rhs', {})
eq('Shortname is too long: map',
pcall_err(meths.set_keymap, 'map', 'lhs', 'rhs', {}))
expect_err('Shortname is too long: vmap',
meths.set_keymap, 'vmap', 'lhs', 'rhs', {})
eq('Shortname is too long: vmap',
pcall_err(meths.set_keymap, 'vmap', 'lhs', 'rhs', {}))
expect_err('Shortname is too long: xnoremap',
meths.set_keymap, 'xnoremap', 'lhs', 'rhs', {})
eq('Shortname is too long: xnoremap',
pcall_err(meths.set_keymap, 'xnoremap', 'lhs', 'rhs', {}))
expect_err('Shortname is too long: map', meths.del_keymap, 'map', 'lhs')
expect_err('Shortname is too long: vmap', meths.del_keymap, 'vmap', 'lhs')
expect_err('Shortname is too long: xnoremap', meths.del_keymap, 'xnoremap', 'lhs')
eq('Shortname is too long: map', pcall_err(meths.del_keymap, 'map', 'lhs'))
eq('Shortname is too long: vmap', pcall_err(meths.del_keymap, 'vmap', 'lhs'))
eq('Shortname is too long: xnoremap', pcall_err(meths.del_keymap, 'xnoremap', 'lhs'))
end)
it('error on invalid mode shortname', function()
expect_err('Invalid mode shortname: " "',
meths.set_keymap, ' ', 'lhs', 'rhs', {})
expect_err('Invalid mode shortname: "m"',
meths.set_keymap, 'm', 'lhs', 'rhs', {})
expect_err('Invalid mode shortname: "?"',
meths.set_keymap, '?', 'lhs', 'rhs', {})
expect_err('Invalid mode shortname: "y"',
meths.set_keymap, 'y', 'lhs', 'rhs', {})
expect_err('Invalid mode shortname: "p"',
meths.set_keymap, 'p', 'lhs', 'rhs', {})
expect_err('Invalid mode shortname: "?"', meths.del_keymap, '?', 'lhs')
expect_err('Invalid mode shortname: "y"', meths.del_keymap, 'y', 'lhs')
expect_err('Invalid mode shortname: "p"', meths.del_keymap, 'p', 'lhs')
eq('Invalid mode shortname: " "',
pcall_err(meths.set_keymap, ' ', 'lhs', 'rhs', {}))
eq('Invalid mode shortname: "m"',
pcall_err(meths.set_keymap, 'm', 'lhs', 'rhs', {}))
eq('Invalid mode shortname: "?"',
pcall_err(meths.set_keymap, '?', 'lhs', 'rhs', {}))
eq('Invalid mode shortname: "y"',
pcall_err(meths.set_keymap, 'y', 'lhs', 'rhs', {}))
eq('Invalid mode shortname: "p"',
pcall_err(meths.set_keymap, 'p', 'lhs', 'rhs', {}))
eq('Invalid mode shortname: "?"', pcall_err(meths.del_keymap, '?', 'lhs'))
eq('Invalid mode shortname: "y"', pcall_err(meths.del_keymap, 'y', 'lhs'))
eq('Invalid mode shortname: "p"', pcall_err(meths.del_keymap, 'p', 'lhs'))
end)
it('error on invalid optnames', function()
expect_err('Invalid key: silentt',
meths.set_keymap, 'n', 'lhs', 'rhs', {silentt = true})
expect_err('Invalid key: sidd',
meths.set_keymap, 'n', 'lhs', 'rhs', {sidd = false})
expect_err('Invalid key: nowaiT',
meths.set_keymap, 'n', 'lhs', 'rhs', {nowaiT = false})
eq('Invalid key: silentt',
pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {silentt = true}))
eq('Invalid key: sidd',
pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {sidd = false}))
eq('Invalid key: nowaiT',
pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {nowaiT = false}))
end)
it('error on <buffer> option key', function()
expect_err('Invalid key: buffer',
meths.set_keymap, 'n', 'lhs', 'rhs', {buffer = true})
eq('Invalid key: buffer',
pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {buffer = true}))
end)
local optnames = {'nowait', 'silent', 'script', 'expr', 'unique'}
@ -454,8 +451,8 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
it('throws an error when given non-boolean value for '..opt, function()
local opts = {}
opts[opt] = 2
expect_err('Gave non%-boolean value for an opt: '..opt,
meths.set_keymap, 'n', 'lhs', 'rhs', opts)
eq('Gave non-boolean value for an opt: '..opt,
pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', opts))
end)
end
@ -581,8 +578,8 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
it('throws appropriate error messages when setting <unique> maps', function()
meths.set_keymap('l', 'lhs', 'rhs', {})
expect_err('E227: mapping already exists for lhs',
meths.set_keymap, 'l', 'lhs', 'rhs', {unique = true})
eq('E227: mapping already exists for lhs',
pcall_err(meths.set_keymap, 'l', 'lhs', 'rhs', {unique = true}))
-- different mapmode, no error should be thrown
meths.set_keymap('t', 'lhs', 'rhs', {unique = true})
end)
@ -750,8 +747,8 @@ describe('nvim_buf_set_keymap, nvim_buf_del_keymap', function()
end
it('rejects negative bufnr values', function()
expect_err('Wrong type for argument 1, expecting Buffer',
bufmeths.set_keymap, -1, '', 'lhs', 'rhs', {})
eq('Wrong type for argument 1, expecting Buffer',
pcall_err(bufmeths.set_keymap, -1, '', 'lhs', 'rhs', {}))
end)
it('can set mappings active in the current buffer but not others', function()
@ -800,8 +797,8 @@ describe('nvim_buf_set_keymap, nvim_buf_del_keymap', function()
it("can't disable mappings given wrong buffer handle", function()
local first, second = make_two_buffers(false)
bufmeths.set_keymap(first, '', 'lhs', 'irhs<Esc>', {})
expect_err('E31: No such mapping',
bufmeths.del_keymap, second, '', 'lhs')
eq('E31: No such mapping',
pcall_err(bufmeths.del_keymap, second, '', 'lhs'))
-- should still work
switch_to_buf(first)

22
test/functional/api/ui_spec.lua
View File

@ -3,9 +3,9 @@ local Screen = require('test.functional.ui.screen')
local clear = helpers.clear
local eq = helpers.eq
local eval = helpers.eval
local expect_err = helpers.expect_err
local meths = helpers.meths
local request = helpers.request
local pcall_err = helpers.pcall_err
describe('nvim_ui_attach()', function()
before_each(function()
@ -18,20 +18,20 @@ describe('nvim_ui_attach()', function()
eq(999, eval('&columns'))
end)
it('invalid option returns error', function()
expect_err('No such UI option: foo',
meths.ui_attach, 80, 24, { foo={'foo'} })
eq('No such UI option: foo',
pcall_err(meths.ui_attach, 80, 24, { foo={'foo'} }))
end)
it('validates channel arg', function()
expect_err('UI not attached to channel: 1',
request, 'nvim_ui_try_resize', 40, 10)
expect_err('UI not attached to channel: 1',
request, 'nvim_ui_set_option', 'rgb', true)
expect_err('UI not attached to channel: 1',
request, 'nvim_ui_detach')
eq('UI not attached to channel: 1',
pcall_err(request, 'nvim_ui_try_resize', 40, 10))
eq('UI not attached to channel: 1',
pcall_err(request, 'nvim_ui_set_option', 'rgb', true))
eq('UI not attached to channel: 1',
pcall_err(request, 'nvim_ui_detach'))
local screen = Screen.new()
screen:attach({rgb=false})
expect_err('UI already attached to channel: 1',
request, 'nvim_ui_attach', 40, 10, { rgb=false })
eq('UI already attached to channel: 1',
pcall_err(request, 'nvim_ui_attach', 40, 10, { rgb=false }))
end)
end)

125
test/functional/api/vim_spec.lua
View File

@ -9,6 +9,7 @@ local expect = helpers.expect
local funcs = helpers.funcs
local iswin = helpers.iswin
local meths = helpers.meths
local matches = helpers.matches
local ok, nvim_async, feed = helpers.ok, helpers.nvim_async, helpers.feed
local is_os = helpers.is_os
local parse_context = helpers.parse_context
@ -17,7 +18,6 @@ local source = helpers.source
local next_msg = helpers.next_msg
local pcall_err = helpers.pcall_err
local expect_err = helpers.expect_err
local format_string = helpers.format_string
local intchar2lua = helpers.intchar2lua
local mergedicts_copy = helpers.mergedicts_copy
@ -27,25 +27,25 @@ describe('API', function()
it('validates requests', function()
-- RPC
expect_err('Invalid method: bogus$',
request, 'bogus')
expect_err('Invalid method: … の り 。…$',
request, '… の り 。…')
expect_err('Invalid method: <empty>$',
request, '')
matches('Invalid method: bogus$',
pcall_err(request, 'bogus'))
matches('Invalid method: … の り 。…$',
pcall_err(request, '… の り 。…'))
matches('Invalid method: <empty>$',
pcall_err(request, ''))
-- Non-RPC: rpcrequest(v:servername) uses internal channel.
expect_err('Invalid method: … の り 。…$',
request, 'nvim_eval',
[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=])
expect_err('Invalid method: bogus$',
request, 'nvim_eval',
[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=])
matches('Invalid method: … の り 。…$',
pcall_err(request, 'nvim_eval',
[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=]))
matches('Invalid method: bogus$',
pcall_err(request, 'nvim_eval',
[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=]))
-- XXX: This must be the last one, else next one will fail:
-- "Packer instance already working. Use another Packer ..."
expect_err("can't serialize object$",
request, nil)
matches("can't serialize object$",
pcall_err(request, nil))
end)
it('handles errors in async requests', function()
@ -203,8 +203,8 @@ describe('API', function()
end)
it("VimL error: returns error details, does NOT update v:errmsg", function()
expect_err('E121: Undefined variable: bogus$', request,
'nvim_eval', 'bogus expression')
eq('Vim:E121: Undefined variable: bogus',
pcall_err(request, 'nvim_eval', 'bogus expression'))
eq('', eval('v:errmsg')) -- v:errmsg was not updated.
end)
end)
@ -218,21 +218,21 @@ describe('API', function()
end)
it("VimL validation error: returns specific error, does NOT update v:errmsg", function()
expect_err('E117: Unknown function: bogus function$', request,
'nvim_call_function', 'bogus function', {'arg1'})
expect_err('E119: Not enough arguments for function: atan', request,
'nvim_call_function', 'atan', {})
eq('Vim:E117: Unknown function: bogus function',
pcall_err(request, 'nvim_call_function', 'bogus function', {'arg1'}))
eq('Vim:E119: Not enough arguments for function: atan',
pcall_err(request, 'nvim_call_function', 'atan', {}))
eq('', eval('v:exception'))
eq('', eval('v:errmsg')) -- v:errmsg was not updated.
end)
it("VimL error: returns error details, does NOT update v:errmsg", function()
expect_err('E808: Number or Float required$', request,
'nvim_call_function', 'atan', {'foo'})
expect_err('Invalid channel stream "xxx"$', request,
'nvim_call_function', 'chanclose', {999, 'xxx'})
expect_err('E900: Invalid channel id$', request,
'nvim_call_function', 'chansend', {999, 'foo'})
eq('Vim:E808: Number or Float required',
pcall_err(request, 'nvim_call_function', 'atan', {'foo'}))
eq('Vim:Invalid channel stream "xxx"',
pcall_err(request, 'nvim_call_function', 'chanclose', {999, 'xxx'}))
eq('Vim:E900: Invalid channel id',
pcall_err(request, 'nvim_call_function', 'chansend', {999, 'foo'}))
eq('', eval('v:exception'))
eq('', eval('v:errmsg')) -- v:errmsg was not updated.
end)
@ -243,8 +243,7 @@ describe('API', function()
throw 'wtf'
endfunction
]])
expect_err('wtf$', request,
'nvim_call_function', 'Foo', {})
eq('wtf', pcall_err(request, 'nvim_call_function', 'Foo', {}))
eq('', eval('v:exception'))
eq('', eval('v:errmsg')) -- v:errmsg was not updated.
end)
@ -257,8 +256,8 @@ describe('API', function()
endfunction
]])
-- E740
expect_err('Function called with too many arguments$', request,
'nvim_call_function', 'Foo', too_many_args)
eq('Function called with too many arguments',
pcall_err(request, 'nvim_call_function', 'Foo', too_many_args))
end)
end)
@ -293,24 +292,24 @@ describe('API', function()
it('validates args', function()
command('let g:d={"baz":"zub","meep":[]}')
expect_err('Not found: bogus$', request,
'nvim_call_dict_function', 'g:d', 'bogus', {1,2})
expect_err('Not a function: baz$', request,
'nvim_call_dict_function', 'g:d', 'baz', {1,2})
expect_err('Not a function: meep$', request,
'nvim_call_dict_function', 'g:d', 'meep', {1,2})
expect_err('E117: Unknown function: f$', request,
'nvim_call_dict_function', { f = '' }, 'f', {1,2})
expect_err('Not a function: f$', request,
'nvim_call_dict_function', "{ 'f': '' }", 'f', {1,2})
expect_err('dict argument type must be String or Dictionary$', request,
'nvim_call_dict_function', 42, 'f', {1,2})
expect_err('Failed to evaluate dict expression$', request,
'nvim_call_dict_function', 'foo', 'f', {1,2})
expect_err('dict not found$', request,
'nvim_call_dict_function', '42', 'f', {1,2})
expect_err('Invalid %(empty%) function name$', request,
'nvim_call_dict_function', "{ 'f': '' }", '', {1,2})
eq('Not found: bogus',
pcall_err(request, 'nvim_call_dict_function', 'g:d', 'bogus', {1,2}))
eq('Not a function: baz',
pcall_err(request, 'nvim_call_dict_function', 'g:d', 'baz', {1,2}))
eq('Not a function: meep',
pcall_err(request, 'nvim_call_dict_function', 'g:d', 'meep', {1,2}))
eq('Vim:E117: Unknown function: f',
pcall_err(request, 'nvim_call_dict_function', { f = '' }, 'f', {1,2}))
eq('Not a function: f',
pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", 'f', {1,2}))
eq('dict argument type must be String or Dictionary',
pcall_err(request, 'nvim_call_dict_function', 42, 'f', {1,2}))
eq('Failed to evaluate dict expression',
pcall_err(request, 'nvim_call_dict_function', 'foo', 'f', {1,2}))
eq('dict not found',
pcall_err(request, 'nvim_call_dict_function', '42', 'f', {1,2}))
eq('Invalid (empty) function name',
pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", '', {1,2}))
end)
end)
@ -363,10 +362,10 @@ describe('API', function()
describe('nvim_paste', function()
it('validates args', function()
expect_err('Invalid phase: %-2', request,
'nvim_paste', 'foo', true, -2)
expect_err('Invalid phase: 4', request,
'nvim_paste', 'foo', true, 4)
eq('Invalid phase: -2',
pcall_err(request, 'nvim_paste', 'foo', true, -2))
eq('Invalid phase: 4',
pcall_err(request, 'nvim_paste', 'foo', true, 4))
end)
it('stream: multiple chunks form one undo-block', function()
nvim('paste', '1/chunk 1 (start)\n', true, 1)
@ -455,22 +454,22 @@ describe('API', function()
end)
it('vim.paste() failure', function()
nvim('execute_lua', 'vim.paste = (function(lines, phase) error("fake fail") end)', {})
expect_err([[Error executing lua: %[string "%<nvim>"]:1: fake fail]],
request, 'nvim_paste', 'line 1\nline 2\nline 3', false, 1)
eq([[Error executing lua: [string "<nvim>"]:1: fake fail]],
pcall_err(request, 'nvim_paste', 'line 1\nline 2\nline 3', false, 1))
end)
end)
describe('nvim_put', function()
it('validates args', function()
expect_err('Invalid lines %(expected array of strings%)', request,
'nvim_put', {42}, 'l', false, false)
expect_err("Invalid type: 'x'", request,
'nvim_put', {'foo'}, 'x', false, false)
eq('Invalid lines (expected array of strings)',
pcall_err(request, 'nvim_put', {42}, 'l', false, false))
eq("Invalid type: 'x'",
pcall_err(request, 'nvim_put', {'foo'}, 'x', false, false))
end)
it("fails if 'nomodifiable'", function()
command('set nomodifiable')
expect_err([[Vim:E21: Cannot make changes, 'modifiable' is off]], request,
'nvim_put', {'a','b'}, 'l', true, true)
eq([[Vim:E21: Cannot make changes, 'modifiable' is off]],
pcall_err(request, 'nvim_put', {'a','b'}, 'l', true, true))
end)
it('inserts text', function()
-- linewise
@ -613,8 +612,8 @@ describe('API', function()
it('nvim_get_vvar, nvim_set_vvar', function()
-- Set readonly v: var.
expect_err('Key is read%-only: count$', request,
'nvim_set_vvar', 'count', 42)
eq('Key is read-only: count',
pcall_err(request, 'nvim_set_vvar', 'count', 42))
-- Set writable v: var.
meths.set_vvar('errmsg', 'set by API')
eq('set by API', meths.get_vvar('errmsg'))

8
test/functional/api/window_spec.lua
View File

@ -10,7 +10,6 @@ local request = helpers.request
local NIL = helpers.NIL
local meths = helpers.meths
local command = helpers.command
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
-- check if str is visible at the beginning of some line
@ -56,8 +55,8 @@ describe('API/win', function()
end)
it('validates args', function()
expect_err('Invalid buffer id$', window, 'set_buf', nvim('get_current_win'), 23)
expect_err('Invalid window id$', window, 'set_buf', 23, nvim('get_current_buf'))
eq('Invalid buffer id', pcall_err(window, 'set_buf', nvim('get_current_win'), 23))
eq('Invalid window id', pcall_err(window, 'set_buf', 23, nvim('get_current_buf')))
end)
end)
@ -340,7 +339,8 @@ describe('API/win', function()
eq(3, #meths.list_wins())
eq(':', funcs.getcmdwintype())
-- Vim: not allowed to close other windows from cmdline-window.
expect_err('E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$', meths.win_close, oldwin, true)
eq('E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
pcall_err(meths.win_close, oldwin, true))
-- Close cmdline-window.
meths.win_close(0,true)
eq(2, #meths.list_wins())

6
test/functional/core/job_spec.lua
View File

@ -17,7 +17,7 @@ local pathroot = helpers.pathroot
local nvim_set = helpers.nvim_set
local expect_twostreams = helpers.expect_twostreams
local expect_msg_seq = helpers.expect_msg_seq
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
local Screen = require('test.functional.ui.screen')
-- Kill process with given pid
@ -122,8 +122,8 @@ describe('jobs', function()
local dir = 'Xtest_not_executable_dir'
mkdir(dir)
funcs.setfperm(dir, 'rw-------')
expect_err('E475: Invalid argument: expected valid directory$', nvim,
'command', "call jobstart('pwd', {'cwd': '" .. dir .. "'})")
eq('Vim(call):E475: Invalid argument: expected valid directory',
pcall_err(nvim, 'command', "call jobstart('pwd', {'cwd': '"..dir.."'})"))
rmdir(dir)
end)

6
test/functional/eval/buf_functions_spec.lua
View File

@ -15,7 +15,7 @@ local curwinmeths = helpers.curwinmeths
local curtabmeths = helpers.curtabmeths
local get_pathsep = helpers.get_pathsep
local rmdir = helpers.rmdir
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
local fname = 'Xtest-functional-eval-buf_functions'
local fname2 = fname .. '.2'
@ -297,8 +297,8 @@ describe('setbufvar() function', function()
eq('Vim(call):E461: Illegal variable name: b:',
exc_exec('call setbufvar(1, "", 0)'))
eq(true, bufmeths.get_var(buf1, 'number'))
expect_err('Vim:E46: Cannot change read%-only variable "b:changedtick"',
funcs.setbufvar, 1, 'changedtick', true)
eq('Vim:E46: Cannot change read-only variable "b:changedtick"',
pcall_err(funcs.setbufvar, 1, 'changedtick', true))
eq(2, funcs.getbufvar(1, 'changedtick'))
end)
end)

38
test/functional/eval/ctx_functions_spec.lua
View File

@ -5,7 +5,6 @@ local clear = helpers.clear
local command = helpers.command
local eq = helpers.eq
local eval = helpers.eval
local expect_err = helpers.expect_err
local feed = helpers.feed
local map = helpers.map
local nvim = helpers.nvim
@ -14,6 +13,7 @@ local redir_exec = helpers.redir_exec
local source = helpers.source
local trim = helpers.trim
local write_file = helpers.write_file
local pcall_err = helpers.pcall_err
describe('context functions', function()
local fname1 = 'Xtest-functional-eval-ctx1'
@ -110,9 +110,9 @@ describe('context functions', function()
nvim('del_var', 'one')
nvim('del_var', 'Two')
nvim('del_var', 'THREE')
expect_err('E121: Undefined variable: g:one', eval, 'g:one')
expect_err('E121: Undefined variable: g:Two', eval, 'g:Two')
expect_err('E121: Undefined variable: g:THREE', eval, 'g:THREE')
eq('Vim:E121: Undefined variable: g:one', pcall_err(eval, 'g:one'))
eq('Vim:E121: Undefined variable: g:Two', pcall_err(eval, 'g:Two'))
eq('Vim:E121: Undefined variable: g:THREE', pcall_err(eval, 'g:THREE'))
call('ctxpop')
eq({1, 2 ,3}, eval('[g:one, g:Two, g:THREE]'))
@ -120,9 +120,9 @@ describe('context functions', function()
nvim('del_var', 'one')
nvim('del_var', 'Two')
nvim('del_var', 'THREE')
expect_err('E121: Undefined variable: g:one', eval, 'g:one')
expect_err('E121: Undefined variable: g:Two', eval, 'g:Two')
expect_err('E121: Undefined variable: g:THREE', eval, 'g:THREE')
eq('Vim:E121: Undefined variable: g:one', pcall_err(eval, 'g:one'))
eq('Vim:E121: Undefined variable: g:Two', pcall_err(eval, 'g:Two'))
eq('Vim:E121: Undefined variable: g:THREE', pcall_err(eval, 'g:THREE'))
call('ctxpop')
eq({1, 2 ,3}, eval('[g:one, g:Two, g:THREE]'))
@ -217,9 +217,9 @@ describe('context functions', function()
command('delfunction Greet')
command('delfunction GreetAll')
expect_err('Vim:E117: Unknown function: Greet', call, 'Greet', 'World')
expect_err('Vim:E117: Unknown function: Greet', call, 'GreetAll',
'World', 'One', 'Two', 'Three')
eq('Vim:E117: Unknown function: Greet', pcall_err(call, 'Greet', 'World'))
eq('Vim:E117: Unknown function: GreetAll',
pcall_err(call, 'GreetAll', 'World', 'One', 'Two', 'Three'))
call('ctxpop')
@ -233,13 +233,13 @@ describe('context functions', function()
it('errors out when context stack is empty', function()
local err = 'Vim:Context stack is empty'
expect_err(err, call, 'ctxpop')
expect_err(err, call, 'ctxpop')
eq(err, pcall_err(call, 'ctxpop'))
eq(err, pcall_err(call, 'ctxpop'))
call('ctxpush')
call('ctxpush')
call('ctxpop')
call('ctxpop')
expect_err(err, call, 'ctxpop')
eq(err, pcall_err(call, 'ctxpop'))
end)
end)
@ -263,11 +263,11 @@ describe('context functions', function()
describe('ctxget()', function()
it('errors out when index is out of bounds', function()
expect_err(outofbounds, call, 'ctxget')
eq(outofbounds, pcall_err(call, 'ctxget'))
call('ctxpush')
expect_err(outofbounds, call, 'ctxget', 1)
eq(outofbounds, pcall_err(call, 'ctxget', 1))
call('ctxpop')
expect_err(outofbounds, call, 'ctxget', 0)
eq(outofbounds, pcall_err(call, 'ctxget', 0))
end)
it('returns context dictionary at index in context stack', function()
@ -370,11 +370,11 @@ describe('context functions', function()
describe('ctxset()', function()
it('errors out when index is out of bounds', function()
expect_err(outofbounds, call, 'ctxset', {dummy = 1})
eq(outofbounds, pcall_err(call, 'ctxset', {dummy = 1}))
call('ctxpush')
expect_err(outofbounds, call, 'ctxset', {dummy = 1}, 1)
eq(outofbounds, pcall_err(call, 'ctxset', {dummy = 1}, 1))
call('ctxpop')
expect_err(outofbounds, call, 'ctxset', {dummy = 1}, 0)
eq(outofbounds, pcall_err(call, 'ctxset', {dummy = 1}, 0))
end)
it('sets context dictionary at index in context stack', function()

10
test/functional/eval/match_functions_spec.lua
View File

@ -6,7 +6,7 @@ local clear = helpers.clear
local funcs = helpers.funcs
local command = helpers.command
local exc_exec = helpers.exc_exec
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
before_each(clear)
@ -41,11 +41,11 @@ describe('setmatches()', function()
end)
it('fails with -1 if highlight group is not defined', function()
expect_err('E28: No such highlight group name: 1', funcs.setmatches,
{{group=1, pattern=2, id=3, priority=4}})
eq('Vim:E28: No such highlight group name: 1',
pcall_err(funcs.setmatches, {{group=1, pattern=2, id=3, priority=4}}))
eq({}, funcs.getmatches())
expect_err('E28: No such highlight group name: 1', funcs.setmatches,
{{group=1, pos1={2}, pos2={6}, id=3, priority=4, conceal=5}})
eq('Vim:E28: No such highlight group name: 1',
pcall_err(funcs.setmatches, {{group=1, pos1={2}, pos2={6}, id=3, priority=4, conceal=5}}))
eq({}, funcs.getmatches())
end)
end)

6
test/functional/eval/server_spec.lua
View File

@ -5,7 +5,7 @@ local clear, funcs, meths = helpers.clear, helpers.funcs, helpers.meths
local iswin = helpers.iswin
local ok = helpers.ok
local matches = helpers.matches
local expect_err = helpers.expect_err
local pcall_err = helpers.pcall_err
local function clear_serverlist()
for _, server in pairs(funcs.serverlist()) do
@ -102,8 +102,8 @@ describe('server', function()
eq(expected, funcs.serverlist())
clear_serverlist()
expect_err('Failed to start server: invalid argument',
funcs.serverstart, '127.0.0.1:65536') -- invalid port
eq('Vim:Failed to start server: invalid argument',
pcall_err(funcs.serverstart, '127.0.0.1:65536')) -- invalid port
eq({}, funcs.serverlist())
end)

15
test/functional/eval/wait_spec.lua
View File

@ -4,12 +4,12 @@ local clear = helpers.clear
local command = helpers.command
local eval = helpers.eval
local eq = helpers.eq
local expect_err = helpers.expect_err
local feed = helpers.feed
local feed_command = helpers.feed_command
local next_msg = helpers.next_msg
local nvim = helpers.nvim
local source = helpers.source
local pcall_err = helpers.pcall_err
before_each(function()
clear()
@ -66,13 +66,10 @@ describe('wait()', function()
eq(5, nvim('get_var', 'counter'))
end)
it('errors out on invalid timeout value', function()
expect_err('Invalid value for argument', call, 'wait', '', 1)
end)
it('errors out on invalid interval', function()
expect_err('Invalid value for argument', call, 'wait', 0, 1, -1)
expect_err('Invalid value for argument', call, 'wait', 0, 1, 0)
expect_err('Invalid value for argument', call, 'wait', 0, 1, '')
it('validates args', function()
eq('Vim:E475: Invalid value for argument 1', pcall_err(call, 'wait', '', 1))
eq('Vim:E475: Invalid value for argument 3', pcall_err(call, 'wait', 0, 1, -1))
eq('Vim:E475: Invalid value for argument 3', pcall_err(call, 'wait', 0, 1, 0))
eq('Vim:E475: Invalid value for argument 3', pcall_err(call, 'wait', 0, 1, ''))
end)
end)

10
test/functional/ex_cmds/swapfile_preserve_recover_spec.lua
View File

@ -5,7 +5,6 @@ local eq, eval, expect, source =
helpers.eq, helpers.eval, helpers.expect, helpers.source
local clear = helpers.clear
local command = helpers.command
local expect_err = helpers.expect_err
local feed = helpers.feed
local nvim_prog = helpers.nvim_prog
local ok = helpers.ok
@ -14,6 +13,7 @@ local set_session = helpers.set_session
local spawn = helpers.spawn
local nvim_async = helpers.nvim_async
local expect_msg_seq = helpers.expect_msg_seq
local pcall_err = helpers.pcall_err
describe(':recover', function()
before_each(clear)
@ -21,11 +21,11 @@ describe(':recover', function()
it('fails if given a non-existent swapfile', function()
local swapname = 'bogus_swapfile'
local swapname2 = 'bogus_swapfile.swp'
expect_err('E305: No swap file found for '..swapname,
command, 'recover '..swapname) -- Should not segfault. #2117
eq('Vim(recover):E305: No swap file found for '..swapname,
pcall_err(command, 'recover '..swapname)) -- Should not segfault. #2117
-- Also check filename ending with ".swp". #9504
expect_err('Vim%(recover%):E306: Cannot open '..swapname2,
command, 'recover '..swapname2) -- Should not segfault. #2117
eq('Vim(recover):E306: Cannot open '..swapname2,
pcall_err(command, 'recover '..swapname2)) -- Should not segfault. #2117
eq(2, eval('1+1')) -- Still alive?
end)

11
test/functional/normal/search_spec.lua
View File

@ -1,16 +1,17 @@
local helpers = require('test.functional.helpers')(after_each)
local clear = helpers.clear
local command = helpers.command
local expect_err = helpers.expect_err
local eq = helpers.eq
local pcall_err = helpers.pcall_err
describe('search (/)', function()
before_each(clear)
it('fails with huge column (%c) value #9930', function()
expect_err("Vim:E951: \\%% value too large",
command, "/\\v%18446744071562067968c")
expect_err("Vim:E951: \\%% value too large",
command, "/\\v%2147483648c")
eq([[Vim:E951: \% value too large]],
pcall_err(command, "/\\v%18446744071562067968c"))
eq([[Vim:E951: \% value too large]],
pcall_err(command, "/\\v%2147483648c"))
end)
end)

11
test/functional/provider/provider_spec.lua
View File

@ -2,7 +2,8 @@
local helpers = require('test.functional.helpers')(after_each)
local clear, eval = helpers.clear, helpers.eval
local command = helpers.command
local expect_err = helpers.expect_err
local eq = helpers.eq
local pcall_err = helpers.pcall_err
describe('providers', function()
before_each(function()
@ -13,14 +14,14 @@ describe('providers', function()
command('set loadplugins')
-- Using test-fixture with broken impl:
-- test/functional/fixtures/autoload/provider/python.vim
expect_err('Vim:provider: python: missing required variable g:loaded_python_provider',
eval, "has('python')")
eq('Vim:provider: python: missing required variable g:loaded_python_provider',
pcall_err(eval, "has('python')"))
end)
it('with g:loaded_xx_provider, missing #Call()', function()
-- Using test-fixture with broken impl:
-- test/functional/fixtures/autoload/provider/ruby.vim
expect_err('Vim:provider: ruby: g:loaded_ruby_provider=2 but provider#ruby#Call is not defined',
eval, "has('ruby')")
eq('Vim:provider: ruby: g:loaded_ruby_provider=2 but provider#ruby#Call is not defined',
pcall_err(eval, "has('ruby')"))
end)
end)

7
test/functional/provider/python3_spec.lua
View File

@ -2,18 +2,19 @@ local helpers = require('test.functional.helpers')(after_each)
local eval, command, feed = helpers.eval, helpers.command, helpers.feed
local eq, clear, insert = helpers.eq, helpers.clear, helpers.insert
local expect, write_file = helpers.expect, helpers.write_file
local expect_err = helpers.expect_err
local feed_command = helpers.feed_command
local source = helpers.source
local missing_provider = helpers.missing_provider
local matches = helpers.matches
local pcall_err = helpers.pcall_err
do
clear()
if missing_provider('python3') then
it(':python3 reports E319 if provider is missing', function()
local expected = [[Vim%(py3.*%):E319: No "python3" provider found.*]]
expect_err(expected, command, 'py3 print("foo")')
expect_err(expected, command, 'py3file foo')
matches(expected, pcall_err(command, 'py3 print("foo")'))
matches(expected, pcall_err(command, 'py3file foo'))
end)
pending('Python 3 (or the pynvim module) is broken/missing', function() end)
return

7
test/functional/provider/python_spec.lua
View File

@ -8,20 +8,21 @@ local funcs = helpers.funcs
local meths = helpers.meths
local insert = helpers.insert
local expect = helpers.expect
local expect_err = helpers.expect_err
local command = helpers.command
local exc_exec = helpers.exc_exec
local write_file = helpers.write_file
local curbufmeths = helpers.curbufmeths
local missing_provider = helpers.missing_provider
local matches = helpers.matches
local pcall_err = helpers.pcall_err
do
clear()
if missing_provider('python') then
it(':python reports E319 if provider is missing', function()
local expected = [[Vim%(py.*%):E319: No "python" provider found.*]]
expect_err(expected, command, 'py print("foo")')
expect_err(expected, command, 'pyfile foo')
matches(expected, pcall_err(command, 'py print("foo")'))
matches(expected, pcall_err(command, 'pyfile foo'))
end)
pending('Python 2 (or the pynvim module) is broken/missing', function() end)
return

7
test/functional/provider/ruby_spec.lua
View File

@ -6,22 +6,23 @@ local curbufmeths = helpers.curbufmeths
local eq = helpers.eq
local eval = helpers.eval
local expect = helpers.expect
local expect_err = helpers.expect_err
local feed = helpers.feed
local feed_command = helpers.feed_command
local funcs = helpers.funcs
local insert = helpers.insert
local meths = helpers.meths
local missing_provider = helpers.missing_provider
local matches = helpers.matches
local write_file = helpers.write_file
local pcall_err = helpers.pcall_err
do
clear()
if missing_provider('ruby') then
it(':ruby reports E319 if provider is missing', function()
local expected = [[Vim%(ruby.*%):E319: No "ruby" provider found.*]]
expect_err(expected, command, 'ruby puts "foo"')
expect_err(expected, command, 'rubyfile foo')
matches(expected, pcall_err(command, 'ruby puts "foo"'))
matches(expected, pcall_err(command, 'rubyfile foo'))
end)
pending("Missing neovim RubyGem.", function() end)
return

8
test/functional/terminal/scrollback_spec.lua
View File

@ -10,8 +10,8 @@ local wait = helpers.wait
local retry = helpers.retry
local curbufmeths = helpers.curbufmeths
local nvim = helpers.nvim
local expect_err = helpers.expect_err
local feed_data = thelpers.feed_data
local pcall_err = helpers.pcall_err
describe(':terminal scrollback', function()
local screen
@ -455,8 +455,10 @@ describe("'scrollback' option", function()
end)
it('error if set to invalid value', function()
expect_err('E474:', command, 'set scrollback=-2')
expect_err('E474:', command, 'set scrollback=100001')
eq('Vim(set):E474: Invalid argument: scrollback=-2',
pcall_err(command, 'set scrollback=-2'))
eq('Vim(set):E474: Invalid argument: scrollback=100001',
pcall_err(command, 'set scrollback=100001'))
end)
it('defaults to -1 on normal buffers', function()

15
test/helpers.lua
View File

@ -74,15 +74,14 @@ function module.matches(pat, actual)
error(string.format('Pattern does not match.\nPattern:\n%s\nActual:\n%s', pat, actual))
end
-- Expects an error matching Lua pattern `pat`.
--
function module.expect_err(pat, fn, ...)
assert(type(fn) == 'function')
local fn_args = {...}
assert.error_matches(function() return fn(unpack(fn_args)) end, pat)
end
-- Invokes `fn` and returns the error string, or raises an error if `fn` succeeds.
--
-- Usage:
-- -- Match exact string.
-- eq('e', pcall_err(function(a, b) error('e') end, 'arg1', 'arg2'))
-- -- Match Lua pattern.
-- matches('e[or]+$', pcall_err(function(a, b) error('some error') end, 'arg1', 'arg2'))
--
function module.pcall_err(fn, ...)
assert(type(fn) == 'function')
local status, rv = pcall(fn, ...)