test: Eliminate expect_err

Eliminate `expect_err` in favor of `pcall_err` + `eq` or `matches`.

test/functional/api/buffer_spec.lua

@@ -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]],
+      eq([[String cannot contain newlines]],
-        bufmeths.set_lines, 1, 1, 2, false, {'b\na'})
+        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']],
+      eq([[Buffer is not 'modifiable']],
-        bufmeths.set_lines, 1, 1, 2, false, {'a','b'})
+        pcall_err(bufmeths.set_lines, 1, 1, 2, false, {'a','b'}))
     end)
 
     it('has correct line_count when inserting and deleting', function()

test/functional/api/buffer_updates_spec.lua

@@ -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()

test/functional/api/command_spec.lua

@@ -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,
+    eq('builtin=true not implemented', pcall_err(meths.get_commands,
-               {builtin=true})
+      {builtin=true}))
-    expect_err('unexpected key: foo', meths.get_commands,
+    eq('unexpected key: foo', pcall_err(meths.get_commands,
-               {foo='blah'})
+      {foo='blah'}))
   end)
 
   it('gets global user-defined commands', function()

test/functional/api/keymap_spec.lua

@@ -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',
+    eq('Invalid (empty) LHS', pcall_err(meths.set_keymap, '', '', 'rhs', {}))
-               meths.set_keymap, '', '', 'rhs', {})
+    eq('Invalid (empty) LHS', pcall_err(meths.set_keymap, '', '', '', {}))
-    expect_err('Invalid %(empty%) LHS',
+    eq('Invalid (empty) LHS', pcall_err(meths.del_keymap, '', ''))
-               meths.set_keymap, '', '', '', {})
-
-    expect_err('Invalid %(empty%) LHS', 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,
+    eq('LHS exceeds maximum map length: '..lhs,
-               meths.set_keymap, '', lhs, 'rhs', {})
+      pcall_err(meths.set_keymap, '', lhs, 'rhs', {}))
-    expect_err('LHS exceeds maximum map length: '..lhs,
+    eq('LHS exceeds maximum map length: '..lhs,
-               meths.del_keymap, '', 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',
+    eq('Shortname is too long: map',
-               meths.set_keymap, 'map', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'map', 'lhs', 'rhs', {}))
 
-    expect_err('Shortname is too long: vmap',
+    eq('Shortname is too long: vmap',
-               meths.set_keymap, 'vmap', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'vmap', 'lhs', 'rhs', {}))
 
-    expect_err('Shortname is too long: xnoremap',
+    eq('Shortname is too long: xnoremap',
-               meths.set_keymap, 'xnoremap', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'xnoremap', 'lhs', 'rhs', {}))
 
-    expect_err('Shortname is too long: map', meths.del_keymap, 'map', 'lhs')
+    eq('Shortname is too long: map', pcall_err(meths.del_keymap, 'map', 'lhs'))
-    expect_err('Shortname is too long: vmap', meths.del_keymap, 'vmap', 'lhs')
+    eq('Shortname is too long: vmap', pcall_err(meths.del_keymap, 'vmap', 'lhs'))
-    expect_err('Shortname is too long: xnoremap', meths.del_keymap, 'xnoremap', '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: " "',
+    eq('Invalid mode shortname: " "',
-               meths.set_keymap, ' ', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, ' ', 'lhs', 'rhs', {}))
-    expect_err('Invalid mode shortname: "m"',
+    eq('Invalid mode shortname: "m"',
-               meths.set_keymap, 'm', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'm', 'lhs', 'rhs', {}))
-    expect_err('Invalid mode shortname: "?"',
+    eq('Invalid mode shortname: "?"',
-               meths.set_keymap, '?', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, '?', 'lhs', 'rhs', {}))
-    expect_err('Invalid mode shortname: "y"',
+    eq('Invalid mode shortname: "y"',
-               meths.set_keymap, 'y', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'y', 'lhs', 'rhs', {}))
-    expect_err('Invalid mode shortname: "p"',
+    eq('Invalid mode shortname: "p"',
-               meths.set_keymap, 'p', 'lhs', 'rhs', {})
+      pcall_err(meths.set_keymap, 'p', 'lhs', 'rhs', {}))
-    expect_err('Invalid mode shortname: "?"', meths.del_keymap, '?', 'lhs')
+    eq('Invalid mode shortname: "?"', pcall_err(meths.del_keymap, '?', 'lhs'))
-    expect_err('Invalid mode shortname: "y"', meths.del_keymap, 'y', 'lhs')
+    eq('Invalid mode shortname: "y"', pcall_err(meths.del_keymap, 'y', 'lhs'))
-    expect_err('Invalid mode shortname: "p"', meths.del_keymap, 'p', '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',
+    eq('Invalid key: silentt',
-               meths.set_keymap, 'n', 'lhs', 'rhs', {silentt = true})
+      pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {silentt = true}))
-    expect_err('Invalid key: sidd',
+    eq('Invalid key: sidd',
-               meths.set_keymap, 'n', 'lhs', 'rhs', {sidd = false})
+      pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {sidd = false}))
-    expect_err('Invalid key: nowaiT',
+    eq('Invalid key: nowaiT',
-               meths.set_keymap, 'n', 'lhs', 'rhs', {nowaiT = false})
+      pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {nowaiT = false}))
   end)
 
   it('error on <buffer> option key', function()
-    expect_err('Invalid key: buffer',
+    eq('Invalid key: buffer',
-               meths.set_keymap, 'n', 'lhs', 'rhs', {buffer = true})
+      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,
+      eq('Gave non-boolean value for an opt: '..opt,
-                 meths.set_keymap, 'n', 'lhs', 'rhs', opts)
+        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',
+    eq('E227: mapping already exists for lhs',
-               meths.set_keymap, 'l', 'lhs', 'rhs', {unique = true})
+      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',
+    eq('Wrong type for argument 1, expecting Buffer',
-               bufmeths.set_keymap, -1, '', 'lhs', 'rhs', {})
+      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',
+    eq('E31: No such mapping',
-               bufmeths.del_keymap, second, '', 'lhs')
+      pcall_err(bufmeths.del_keymap, second, '', 'lhs'))
 
     -- should still work
     switch_to_buf(first)

test/functional/api/ui_spec.lua

@@ -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',
+    eq('No such UI option: foo',
-               meths.ui_attach, 80, 24, { foo={'foo'} })
+      pcall_err(meths.ui_attach, 80, 24, { foo={'foo'} }))
   end)
   it('validates channel arg', function()
-    expect_err('UI not attached to channel: 1',
+    eq('UI not attached to channel: 1',
-               request, 'nvim_ui_try_resize', 40, 10)
+      pcall_err(request, 'nvim_ui_try_resize', 40, 10))
-    expect_err('UI not attached to channel: 1',
+    eq('UI not attached to channel: 1',
-               request, 'nvim_ui_set_option', 'rgb', true)
+      pcall_err(request, 'nvim_ui_set_option', 'rgb', true))
-    expect_err('UI not attached to channel: 1',
+    eq('UI not attached to channel: 1',
-               request, 'nvim_ui_detach')
+      pcall_err(request, 'nvim_ui_detach'))
 
     local screen = Screen.new()
     screen:attach({rgb=false})
-    expect_err('UI already attached to channel: 1',
+    eq('UI already attached to channel: 1',
-               request, 'nvim_ui_attach', 40, 10, { rgb=false })
+      pcall_err(request, 'nvim_ui_attach', 40, 10, { rgb=false }))
   end)
 end)

test/functional/api/vim_spec.lua

@@ -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$',
+    matches('Invalid method: bogus$',
-               request, 'bogus')
+      pcall_err(request, 'bogus'))
-    expect_err('Invalid method: … の り 。…$',
+    matches('Invalid method: … の り 。…$',
-               request, '… の り 。…')
+      pcall_err(request, '… の り 。…'))
-    expect_err('Invalid method: <empty>$',
+    matches('Invalid method: <empty>$',
-               request, '')
+      pcall_err(request, ''))
 
     -- Non-RPC: rpcrequest(v:servername) uses internal channel.
-    expect_err('Invalid method: … の り 。…$',
+    matches('Invalid method: … の り 。…$',
-               request, 'nvim_eval',
+      pcall_err(request, 'nvim_eval',
-               [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=])
+        [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=]))
-    expect_err('Invalid method: bogus$',
+    matches('Invalid method: bogus$',
-               request, 'nvim_eval',
+      pcall_err(request, 'nvim_eval',
-               [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=])
+        [=[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$",
+    matches("can't serialize object$",
-               request, nil)
+      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,
+      eq('Vim:E121: Undefined variable: bogus',
-                 'nvim_eval', 'bogus expression')
+        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,
+      eq('Vim:E117: Unknown function: bogus function',
-                 'nvim_call_function', 'bogus function', {'arg1'})
+        pcall_err(request, 'nvim_call_function', 'bogus function', {'arg1'}))
-      expect_err('E119: Not enough arguments for function: atan', request,
+      eq('Vim:E119: Not enough arguments for function: atan',
-                 'nvim_call_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,
+      eq('Vim:E808: Number or Float required',
-                 'nvim_call_function', 'atan', {'foo'})
+        pcall_err(request, 'nvim_call_function', 'atan', {'foo'}))
-      expect_err('Invalid channel stream "xxx"$', request,
+      eq('Vim:Invalid channel stream "xxx"',
-                 'nvim_call_function', 'chanclose', {999, 'xxx'})
+        pcall_err(request, 'nvim_call_function', 'chanclose', {999, 'xxx'}))
-      expect_err('E900: Invalid channel id$', request,
+      eq('Vim:E900: Invalid channel id',
-                 'nvim_call_function', 'chansend', {999, 'foo'})
+        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,
+      eq('wtf', pcall_err(request, 'nvim_call_function', 'Foo', {}))
-                 '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,
+      eq('Function called with too many arguments',
-                 'nvim_call_function', 'Foo', too_many_args)
+        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,
+      eq('Not found: bogus',
-                 'nvim_call_dict_function', 'g:d', 'bogus', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', 'g:d', 'bogus', {1,2}))
-      expect_err('Not a function: baz$', request,
+      eq('Not a function: baz',
-                 'nvim_call_dict_function', 'g:d', 'baz', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', 'g:d', 'baz', {1,2}))
-      expect_err('Not a function: meep$', request,
+      eq('Not a function: meep',
-                 'nvim_call_dict_function', 'g:d', 'meep', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', 'g:d', 'meep', {1,2}))
-      expect_err('E117: Unknown function: f$', request,
+      eq('Vim:E117: Unknown function: f',
-                 'nvim_call_dict_function', { f = '' }, 'f', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', { f = '' }, 'f', {1,2}))
-      expect_err('Not a function: f$', request,
+      eq('Not a function: f',
-                 'nvim_call_dict_function', "{ 'f': '' }", 'f', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", 'f', {1,2}))
-      expect_err('dict argument type must be String or Dictionary$', request,
+      eq('dict argument type must be String or Dictionary',
-                 'nvim_call_dict_function', 42, 'f', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', 42, 'f', {1,2}))
-      expect_err('Failed to evaluate dict expression$', request,
+      eq('Failed to evaluate dict expression',
-                 'nvim_call_dict_function', 'foo', 'f', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', 'foo', 'f', {1,2}))
-      expect_err('dict not found$', request,
+      eq('dict not found',
-                 'nvim_call_dict_function', '42', 'f', {1,2})
+        pcall_err(request, 'nvim_call_dict_function', '42', 'f', {1,2}))
-      expect_err('Invalid %(empty%) function name$', request,
+      eq('Invalid (empty) function name',
-                 'nvim_call_dict_function', "{ 'f': '' }", '', {1,2})
+        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,
+      eq('Invalid phase: -2',
-        'nvim_paste', 'foo', true, -2)
+        pcall_err(request, 'nvim_paste', 'foo', true, -2))
-      expect_err('Invalid phase: 4', request,
+      eq('Invalid phase: 4',
-        'nvim_paste', 'foo', true, 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]],
+      eq([[Error executing lua: [string "<nvim>"]:1: fake fail]],
-        request, 'nvim_paste', 'line 1\nline 2\nline 3', false, 1)
+        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,
+      eq('Invalid lines (expected array of strings)',
-        'nvim_put', {42}, 'l', false, false)
+        pcall_err(request, 'nvim_put', {42}, 'l', false, false))
-      expect_err("Invalid type: 'x'", request,
+      eq("Invalid type: 'x'",
-        'nvim_put', {'foo'}, 'x', false, false)
+        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,
+      eq([[Vim:E21: Cannot make changes, 'modifiable' is off]],
-        'nvim_put', {'a','b'}, 'l', true, true)
+        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,
+      eq('Key is read-only: count',
-                 'nvim_set_vvar', 'count', 42)
+        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'))

test/functional/api/window_spec.lua

@@ -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)
+      eq('Invalid buffer id', pcall_err(window, 'set_buf', nvim('get_current_win'), 23))
-      expect_err('Invalid window id$', window, 'set_buf', 23, nvim('get_current_buf'))
+      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())

test/functional/core/job_spec.lua

@@ -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,
+    eq('Vim(call):E475: Invalid argument: expected valid directory',
-               'command', "call jobstart('pwd', {'cwd': '" .. dir .. "'})")
+      pcall_err(nvim, 'command', "call jobstart('pwd', {'cwd': '"..dir.."'})"))
     rmdir(dir)
   end)
 

test/functional/eval/buf_functions_spec.lua

@@ -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"',
+    eq('Vim:E46: Cannot change read-only variable "b:changedtick"',
-               funcs.setbufvar, 1, 'changedtick', true)
+      pcall_err(funcs.setbufvar, 1, 'changedtick', true))
     eq(2, funcs.getbufvar(1, 'changedtick'))
   end)
 end)

test/functional/eval/ctx_functions_spec.lua

@@ -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')
+      eq('Vim:E121: Undefined variable: g:one', pcall_err(eval, 'g:one'))
-      expect_err('E121: Undefined variable: g:Two', eval, 'g:Two')
+      eq('Vim:E121: Undefined variable: g:Two', pcall_err(eval, 'g:Two'))
-      expect_err('E121: Undefined variable: g:THREE', eval, 'g:THREE')
+      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')
+      eq('Vim:E121: Undefined variable: g:one', pcall_err(eval, 'g:one'))
-      expect_err('E121: Undefined variable: g:Two', eval, 'g:Two')
+      eq('Vim:E121: Undefined variable: g:Two', pcall_err(eval, 'g:Two'))
-      expect_err('E121: Undefined variable: g:THREE', eval, 'g:THREE')
+      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')
+      eq('Vim:E117: Unknown function: Greet', pcall_err(call, 'Greet', 'World'))
-      expect_err('Vim:E117: Unknown function: Greet', call, 'GreetAll',
+      eq('Vim:E117: Unknown function: GreetAll',
-                 'World', 'One', 'Two', 'Three')
+        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')
+      eq(err, pcall_err(call, 'ctxpop'))
-      expect_err(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()

test/functional/eval/match_functions_spec.lua

@@ -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,
+    eq('Vim:E28: No such highlight group name: 1',
-               {{group=1, pattern=2, id=3, priority=4}})
+      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,
+    eq('Vim:E28: No such highlight group name: 1',
-               {{group=1, pos1={2}, pos2={6}, id=3, priority=4, conceal=5}})
+      pcall_err(funcs.setmatches, {{group=1, pos1={2}, pos2={6}, id=3, priority=4, conceal=5}}))
     eq({}, funcs.getmatches())
   end)
 end)

test/functional/eval/server_spec.lua

@@ -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',
+    eq('Vim:Failed to start server: invalid argument',
-               funcs.serverstart, '127.0.0.1:65536')  -- invalid port
+      pcall_err(funcs.serverstart, '127.0.0.1:65536'))  -- invalid port
     eq({}, funcs.serverlist())
   end)
 

test/functional/eval/wait_spec.lua

@@ -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()
+  it('validates args', function()
-    expect_err('Invalid value for argument', call, 'wait', '', 1)
+    eq('Vim:E475: Invalid value for argument 1', pcall_err(call, 'wait', '', 1))
-  end)
+    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))
-  it('errors out on invalid interval', function()
+    eq('Vim:E475: Invalid value for argument 3', pcall_err(call, 'wait', 0, 1, ''))
-    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, '')
   end)
 end)

test/functional/ex_cmds/swapfile_preserve_recover_spec.lua

@@ -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,
+    eq('Vim(recover):E305: No swap file found for '..swapname,
-               command, 'recover '..swapname)  -- Should not segfault. #2117
+      pcall_err(command, 'recover '..swapname))  -- Should not segfault. #2117
     -- Also check filename ending with ".swp". #9504
-    expect_err('Vim%(recover%):E306: Cannot open '..swapname2,
+    eq('Vim(recover):E306: Cannot open '..swapname2,
-               command, 'recover '..swapname2)  -- Should not segfault. #2117
+      pcall_err(command, 'recover '..swapname2))  -- Should not segfault. #2117
     eq(2, eval('1+1'))  -- Still alive?
   end)
 

test/functional/normal/search_spec.lua

@@ -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",
+    eq([[Vim:E951: \% value too large]],
-      command, "/\\v%18446744071562067968c")
+      pcall_err(command, "/\\v%18446744071562067968c"))
-    expect_err("Vim:E951: \\%% value too large",
+    eq([[Vim:E951: \% value too large]],
-      command, "/\\v%2147483648c")
+      pcall_err(command, "/\\v%2147483648c"))
   end)
 end)
 

test/functional/provider/provider_spec.lua

@@ -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',
+    eq('Vim:provider: python: missing required variable g:loaded_python_provider',
-      eval, "has('python')")
+      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',
+    eq('Vim:provider: ruby: g:loaded_ruby_provider=2 but provider#ruby#Call is not defined',
-      eval, "has('ruby')")
+      pcall_err(eval, "has('ruby')"))
   end)
 end)

test/functional/provider/python3_spec.lua

@@ -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")')
+      matches(expected, pcall_err(command, 'py3 print("foo")'))
-      expect_err(expected, command, 'py3file foo')
+      matches(expected, pcall_err(command, 'py3file foo'))
     end)
     pending('Python 3 (or the pynvim module) is broken/missing', function() end)
     return

test/functional/provider/python_spec.lua

@@ -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")')
+      matches(expected, pcall_err(command, 'py print("foo")'))
-      expect_err(expected, command, 'pyfile foo')
+      matches(expected, pcall_err(command, 'pyfile foo'))
     end)
     pending('Python 2 (or the pynvim module) is broken/missing', function() end)
     return

test/functional/provider/ruby_spec.lua

@@ -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"')
+      matches(expected, pcall_err(command, 'ruby puts "foo"'))
-      expect_err(expected, command, 'rubyfile foo')
+      matches(expected, pcall_err(command, 'rubyfile foo'))
     end)
     pending("Missing neovim RubyGem.", function() end)
     return

test/functional/terminal/scrollback_spec.lua

@@ -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')
+    eq('Vim(set):E474: Invalid argument: scrollback=-2',
-    expect_err('E474:', command, 'set scrollback=100001')
+      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()

test/helpers.lua

@@ -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, ...)