Merge remote-tracking branch 'upstream/master' into aucmd_textputpost

1 files changed, 567 insertions, 430 deletions

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index 434f117956..0decd710e9 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -1,20 +1,18 @@
 local helpers = require('test.functional.helpers')(after_each)
 
-local bufmeths = helpers.bufmeths
 local clear = helpers.clear
 local command = helpers.command
-local curbufmeths = helpers.curbufmeths
 local eq, neq = helpers.eq, helpers.neq
 local exec_lua = helpers.exec_lua
 local exec = helpers.exec
 local feed = helpers.feed
-local funcs = helpers.funcs
-local meths = helpers.meths
+local fn = helpers.fn
+local api = helpers.api
 local source = helpers.source
 local pcall_err = helpers.pcall_err
 
 local shallowcopy = helpers.shallowcopy
-local sleep = helpers.sleep
+local sleep = vim.uv.sleep
 
 local sid_api_client = -9
 local sid_lua = -8
@@ -39,25 +37,25 @@ describe('nvim_get_keymap', function()
   -- Basic mapping and table to be used to describe results
   local foo_bar_string = 'nnoremap foo bar'
   local foo_bar_map_table = {
-    lhs='foo',
-    lhsraw='foo',
-    script=0,
-    silent=0,
-    rhs='bar',
-    expr=0,
-    sid=0,
-    scriptversion=1,
-    buffer=0,
-    nowait=0,
-    mode='n',
-    mode_bits=0x01,
-    abbr=0,
-    noremap=1,
-    lnum=0,
+    lhs = 'foo',
+    lhsraw = 'foo',
+    script = 0,
+    silent = 0,
+    rhs = 'bar',
+    expr = 0,
+    sid = 0,
+    scriptversion = 1,
+    buffer = 0,
+    nowait = 0,
+    mode = 'n',
+    mode_bits = 0x01,
+    abbr = 0,
+    noremap = 1,
+    lnum = 0,
   }
 
   it('returns empty list when no map', function()
-    eq({}, meths.get_keymap('n'))
+    eq({}, api.nvim_get_keymap('n'))
   end)
 
   it('returns list of all applicable mappings', function()
@@ -66,10 +64,8 @@ describe('nvim_get_keymap', function()
     -- Should be the same as the dictionary we supplied earlier
     -- and the dictionary you would get from maparg
     -- since this is a global map, and not script local
-    eq({foo_bar_map_table}, meths.get_keymap('n'))
-    eq({funcs.maparg('foo', 'n', false, true)},
-      meths.get_keymap('n')
-    )
+    eq({ foo_bar_map_table }, api.nvim_get_keymap('n'))
+    eq({ fn.maparg('foo', 'n', false, true) }, api.nvim_get_keymap('n'))
 
     -- Add another mapping
     command('nnoremap foo_longer bar_longer')
@@ -78,15 +74,11 @@ describe('nvim_get_keymap', function()
     foolong_bar_map_table['lhsraw'] = 'foo_longer'
     foolong_bar_map_table['rhs'] = 'bar_longer'
 
-    eq({foolong_bar_map_table, foo_bar_map_table},
-      meths.get_keymap('n')
-    )
+    eq({ foolong_bar_map_table, foo_bar_map_table }, api.nvim_get_keymap('n'))
 
     -- Remove a mapping
     command('unmap foo_longer')
-    eq({foo_bar_map_table},
-      meths.get_keymap('n')
-    )
+    eq({ foo_bar_map_table }, api.nvim_get_keymap('n'))
   end)
 
   it('works for other modes', function()
@@ -100,7 +92,7 @@ describe('nvim_get_keymap', function()
     insert_table['mode'] = 'i'
     insert_table['mode_bits'] = 0x10
 
-    eq({insert_table}, meths.get_keymap('i'))
+    eq({ insert_table }, api.nvim_get_keymap('i'))
   end)
 
   it('considers scope', function()
@@ -117,8 +109,8 @@ describe('nvim_get_keymap', function()
     command('nnoremap <buffer> foo bar')
 
     -- The buffer mapping should not show up
-    eq({foolong_bar_map_table}, meths.get_keymap('n'))
-    eq({buffer_table}, curbufmeths.get_keymap('n'))
+    eq({ foolong_bar_map_table }, api.nvim_get_keymap('n'))
+    eq({ buffer_table }, api.nvim_buf_get_keymap(0, 'n'))
   end)
 
   it('considers scope for overlapping maps', function()
@@ -129,12 +121,12 @@ describe('nvim_get_keymap', function()
 
     command('nnoremap <buffer> foo bar')
 
-    eq({foo_bar_map_table}, meths.get_keymap('n'))
-    eq({buffer_table}, curbufmeths.get_keymap('n'))
+    eq({ foo_bar_map_table }, api.nvim_get_keymap('n'))
+    eq({ buffer_table }, api.nvim_buf_get_keymap(0, 'n'))
   end)
 
   it('can retrieve mapping for different buffers', function()
-    local original_buffer = curbufmeths.get_number()
+    local original_buffer = api.nvim_buf_get_number(0)
     -- Place something in each of the buffers to make sure they stick around
     -- and set hidden so we can leave them
     command('set hidden')
@@ -143,87 +135,124 @@ describe('nvim_get_keymap', function()
     command('new')
     command('normal! ihello 3')
 
-    local final_buffer = curbufmeths.get_number()
+    local final_buffer = api.nvim_buf_get_number(0)
 
     command('nnoremap <buffer> foo bar')
     -- Final buffer will have buffer mappings
     local buffer_table = shallowcopy(foo_bar_map_table)
     buffer_table['buffer'] = final_buffer
-    eq({buffer_table}, meths.buf_get_keymap(final_buffer, 'n'))
-    eq({buffer_table}, meths.buf_get_keymap(0, 'n'))
+    eq({ buffer_table }, api.nvim_buf_get_keymap(final_buffer, 'n'))
+    eq({ buffer_table }, api.nvim_buf_get_keymap(0, 'n'))
 
     command('buffer ' .. original_buffer)
-    eq(original_buffer, curbufmeths.get_number())
+    eq(original_buffer, api.nvim_buf_get_number(0))
     -- Original buffer won't have any mappings
-    eq({}, meths.get_keymap('n'))
-    eq({}, curbufmeths.get_keymap('n'))
-    eq({buffer_table}, meths.buf_get_keymap(final_buffer, 'n'))
+    eq({}, api.nvim_get_keymap('n'))
+    eq({}, api.nvim_buf_get_keymap(0, 'n'))
+    eq({ buffer_table }, api.nvim_buf_get_keymap(final_buffer, 'n'))
   end)
 
   -- Test toggle switches for basic options
   -- @param  option  The key represented in the `maparg()` result dict
-  local function global_and_buffer_test(map,
-                                        option,
-                                        option_token,
-                                        global_on_result,
-                                        buffer_on_result,
-                                        global_off_result,
-                                        buffer_off_result,
-                                        new_windows)
-
+  local function global_and_buffer_test(
+    map,
+    option,
+    option_token,
+    global_on_result,
+    buffer_on_result,
+    global_off_result,
+    buffer_off_result,
+    new_windows
+  )
     local function make_new_windows(number_of_windows)
       if new_windows == nil then
         return nil
       end
 
-      for _=1,number_of_windows do
+      for _ = 1, number_of_windows do
         command('new')
       end
     end
 
-    local mode = string.sub(map, 1,1)
+    local mode = string.sub(map, 1, 1)
     -- Don't run this for the <buffer> mapping, since it doesn't make sense
     if option_token ~= '<buffer>' then
-      it(string.format( 'returns %d for the key "%s" when %s is used globally with %s (%s)',
-          global_on_result, option, option_token, map, mode), function()
-        make_new_windows(new_windows)
-        command(map .. ' ' .. option_token .. ' foo bar')
-        local result = meths.get_keymap(mode)[1][option]
-        eq(global_on_result, result)
-      end)
+      it(
+        string.format(
+          'returns %d for the key "%s" when %s is used globally with %s (%s)',
+          global_on_result,
+          option,
+          option_token,
+          map,
+          mode
+        ),
+        function()
+          make_new_windows(new_windows)
+          command(map .. ' ' .. option_token .. ' foo bar')
+          local result = api.nvim_get_keymap(mode)[1][option]
+          eq(global_on_result, result)
+        end
+      )
     end
 
-    it(string.format('returns %d for the key "%s" when %s is used for buffers with %s (%s)',
-        buffer_on_result, option, option_token, map, mode), function()
-      make_new_windows(new_windows)
-      command(map .. ' <buffer> ' .. option_token .. ' foo bar')
-      local result = curbufmeths.get_keymap(mode)[1][option]
-      eq(buffer_on_result, result)
-    end)
+    it(
+      string.format(
+        'returns %d for the key "%s" when %s is used for buffers with %s (%s)',
+        buffer_on_result,
+        option,
+        option_token,
+        map,
+        mode
+      ),
+      function()
+        make_new_windows(new_windows)
+        command(map .. ' <buffer> ' .. option_token .. ' foo bar')
+        local result = api.nvim_buf_get_keymap(0, mode)[1][option]
+        eq(buffer_on_result, result)
+      end
+    )
 
     -- Don't run these for the <buffer> mapping, since it doesn't make sense
     if option_token ~= '<buffer>' then
-      it(string.format('returns %d for the key "%s" when %s is not used globally with %s (%s)',
-          global_off_result, option, option_token, map, mode), function()
-        make_new_windows(new_windows)
-        command(map .. ' baz bat')
-        local result = meths.get_keymap(mode)[1][option]
-        eq(global_off_result, result)
-      end)
-
-      it(string.format('returns %d for the key "%s" when %s is not used for buffers with %s (%s)',
-          buffer_off_result, option, option_token, map, mode), function()
-        make_new_windows(new_windows)
-        command(map .. ' <buffer> foo bar')
+      it(
+        string.format(
+          'returns %d for the key "%s" when %s is not used globally with %s (%s)',
+          global_off_result,
+          option,
+          option_token,
+          map,
+          mode
+        ),
+        function()
+          make_new_windows(new_windows)
+          command(map .. ' baz bat')
+          local result = api.nvim_get_keymap(mode)[1][option]
+          eq(global_off_result, result)
+        end
+      )
 
-        local result = curbufmeths.get_keymap(mode)[1][option]
-        eq(buffer_off_result, result)
-      end)
+      it(
+        string.format(
+          'returns %d for the key "%s" when %s is not used for buffers with %s (%s)',
+          buffer_off_result,
+          option,
+          option_token,
+          map,
+          mode
+        ),
+        function()
+          make_new_windows(new_windows)
+          command(map .. ' <buffer> foo bar')
+
+          local result = api.nvim_buf_get_keymap(0, mode)[1][option]
+          eq(buffer_off_result, result)
+        end
+      )
     end
   end
 
   -- Standard modes and returns the same values in the dictionary as maparg()
-  local mode_list = {'nnoremap', 'nmap', 'imap', 'inoremap', 'cnoremap'}
+  local mode_list = { 'nnoremap', 'nmap', 'imap', 'inoremap', 'cnoremap' }
   for mode in pairs(mode_list) do
     global_and_buffer_test(mode_list[mode], 'silent', '<silent>', 1, 1, 0, 0)
     global_and_buffer_test(mode_list[mode], 'nowait', '<nowait>', 1, 1, 0, 0)
@@ -246,9 +275,9 @@ describe('nvim_get_keymap', function()
 
       nnoremap fizz :call <SID>maparg_test_function()<CR>
     ]])
-    local sid_result = meths.get_keymap('n')[1]['sid']
+    local sid_result = api.nvim_get_keymap('n')[1]['sid']
     eq(1, sid_result)
-    eq('testing', meths.call_function('<SNR>' .. sid_result .. '_maparg_test_function', {}))
+    eq('testing', api.nvim_call_function('<SNR>' .. sid_result .. '_maparg_test_function', {}))
   end)
 
   it('returns script numbers for buffer maps', function()
@@ -259,29 +288,29 @@ describe('nvim_get_keymap', function()
 
       nnoremap <buffer> fizz :call <SID>maparg_test_function()<CR>
     ]])
-    local sid_result = curbufmeths.get_keymap('n')[1]['sid']
+    local sid_result = api.nvim_buf_get_keymap(0, 'n')[1]['sid']
     eq(1, sid_result)
-    eq('testing', meths.call_function('<SNR>' .. sid_result .. '_maparg_test_function', {}))
+    eq('testing', api.nvim_call_function('<SNR>' .. sid_result .. '_maparg_test_function', {}))
   end)
 
   it('works with <F12> and others', function()
     command('nnoremap <F12> :let g:maparg_test_var = 1<CR>')
-    eq('<F12>', meths.get_keymap('n')[1]['lhs'])
-    eq(':let g:maparg_test_var = 1<CR>', meths.get_keymap('n')[1]['rhs'])
+    eq('<F12>', api.nvim_get_keymap('n')[1]['lhs'])
+    eq(':let g:maparg_test_var = 1<CR>', api.nvim_get_keymap('n')[1]['rhs'])
   end)
 
   it('works correctly despite various &cpo settings', function()
     local cpo_table = {
-      script=0,
-      silent=0,
-      expr=0,
-      sid=0,
-      scriptversion=1,
-      buffer=0,
-      nowait=0,
-      abbr=0,
-      noremap=1,
-      lnum=0,
+      script = 0,
+      silent = 0,
+      expr = 0,
+      sid = 0,
+      scriptversion = 1,
+      buffer = 0,
+      nowait = 0,
+      abbr = 0,
+      noremap = 1,
+      lnum = 0,
     }
     local function cpomap(lhs, rhs, mode)
       local ret = shallowcopy(cpo_table)
@@ -310,7 +339,7 @@ describe('nvim_get_keymap', function()
 
     -- wrapper around get_keymap() that drops "lhsraw" and "lhsrawalt" which are hard to check
     local function get_keymap_noraw(...)
-      local ret = meths.get_keymap(...)
+      local ret = api.nvim_get_keymap(...)
       for _, item in ipairs(ret) do
         item.lhsraw = nil
         item.lhsrawalt = nil
@@ -323,103 +352,164 @@ describe('nvim_get_keymap', function()
       'set cpo+=B',
     }) do
       command(cmd)
-      eq({cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'n'),
-          cpomap('\\<C-A><C-A><lt>C-a>\\', '\\<C-B><C-B><lt>C-b>\\', 'n')},
-         get_keymap_noraw('n'))
-      eq({cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'x'),
-          cpomap('\\<C-A><C-A><lt>C-a>\\', '\\<C-B><C-B><lt>C-b>\\', 'x')},
-         get_keymap_noraw('x'))
-      eq({cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 's'),
-          cpomap('<lt>C-a><C-A><lt>C-a> ', '<lt>C-b><C-B><lt>C-b>', 's')},
-         get_keymap_noraw('s'))
-      eq({cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 'o'),
-          cpomap('<lt>C-a><C-A><lt>C-a> ', '<lt>C-b><C-B><lt>C-b>', 'o')},
-         get_keymap_noraw('o'))
+      eq({
+        cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'n'),
+        cpomap('\\<C-A><C-A><lt>C-a>\\', '\\<C-B><C-B><lt>C-b>\\', 'n'),
+      }, get_keymap_noraw('n'))
+      eq({
+        cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'x'),
+        cpomap('\\<C-A><C-A><lt>C-a>\\', '\\<C-B><C-B><lt>C-b>\\', 'x'),
+      }, get_keymap_noraw('x'))
+      eq({
+        cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 's'),
+        cpomap('<lt>C-a><C-A><lt>C-a> ', '<lt>C-b><C-B><lt>C-b>', 's'),
+      }, get_keymap_noraw('s'))
+      eq({
+        cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 'o'),
+        cpomap('<lt>C-a><C-A><lt>C-a> ', '<lt>C-b><C-B><lt>C-b>', 'o'),
+      }, get_keymap_noraw('o'))
     end
   end)
 
   it('always uses space for space and bar for bar', function()
     local space_table = {
-      lhs='|   |',
-      lhsraw='|   |',
-      rhs='|    |',
-      mode='n',
-      mode_bits=0x01,
-      abbr=0,
-      script=0,
-      silent=0,
-      expr=0,
-      sid=0,
-      scriptversion=1,
-      buffer=0,
-      nowait=0,
-      noremap=1,
-      lnum=0,
+      lhs = '|   |',
+      lhsraw = '|   |',
+      rhs = '|    |',
+      mode = 'n',
+      mode_bits = 0x01,
+      abbr = 0,
+      script = 0,
+      silent = 0,
+      expr = 0,
+      sid = 0,
+      scriptversion = 1,
+      buffer = 0,
+      nowait = 0,
+      noremap = 1,
+      lnum = 0,
     }
     command('nnoremap \\|<Char-0x20><Char-32><Space><Bar> \\|<Char-0x20><Char-32><Space> <Bar>')
-    eq({space_table}, meths.get_keymap('n'))
+    eq({ space_table }, api.nvim_get_keymap('n'))
   end)
 
   it('can handle lua mappings', function()
-    eq(0, exec_lua([[
+    eq(
+      0,
+      exec_lua([[
       GlobalCount = 0
       vim.api.nvim_set_keymap('n', 'asdf', '', {callback = function() GlobalCount = GlobalCount + 1 end })
       return GlobalCount
-    ]]))
+    ]])
+    )
 
     feed('asdf\n')
     eq(1, exec_lua([[return GlobalCount]]))
 
-    eq(2, exec_lua([[
+    eq(
+      2,
+      exec_lua([[
       vim.api.nvim_get_keymap('n')[1].callback()
       return GlobalCount
-    ]]))
+    ]])
+    )
 
     exec([[
       call nvim_get_keymap('n')[0].callback()
     ]])
     eq(3, exec_lua([[return GlobalCount]]))
 
-    local mapargs = meths.get_keymap('n')
+    local mapargs = api.nvim_get_keymap('n')
     mapargs[1].callback = nil
     eq({
-      lhs='asdf',
-      lhsraw='asdf',
-      script=0,
-      silent=0,
-      expr=0,
-      sid=sid_lua,
-      scriptversion=1,
-      buffer=0,
-      nowait=0,
-      mode='n',
-      mode_bits=0x01,
-      abbr=0,
-      noremap=0,
-      lnum=0,
+      lhs = 'asdf',
+      lhsraw = 'asdf',
+      script = 0,
+      silent = 0,
+      expr = 0,
+      sid = sid_lua,
+      scriptversion = 1,
+      buffer = 0,
+      nowait = 0,
+      mode = 'n',
+      mode_bits = 0x01,
+      abbr = 0,
+      noremap = 0,
+      lnum = 0,
     }, mapargs[1])
   end)
 
   it('can handle map descriptions', function()
-    meths.set_keymap('n', 'lhs', 'rhs', {desc="map description"})
+    api.nvim_set_keymap('n', 'lhs', 'rhs', { desc = 'map description' })
     eq({
-      lhs='lhs',
-      lhsraw='lhs',
-      rhs='rhs',
-      script=0,
-      silent=0,
-      expr=0,
-      sid=sid_api_client,
-      scriptversion=1,
-      buffer=0,
-      nowait=0,
-      mode='n',
-      mode_bits=0x01,
-      abbr=0,
-      noremap=0,
-      lnum=0,
-      desc='map description'
-    }, meths.get_keymap('n')[1])
+      lhs = 'lhs',
+      lhsraw = 'lhs',
+      rhs = 'rhs',
+      script = 0,
+      silent = 0,
+      expr = 0,
+      sid = sid_api_client,
+      scriptversion = 1,
+      buffer = 0,
+      nowait = 0,
+      mode = 'n',
+      mode_bits = 0x01,
+      abbr = 0,
+      noremap = 0,
+      lnum = 0,
+      desc = 'map description',
+    }, api.nvim_get_keymap('n')[1])
+  end)
+
+  it('can get abbreviations', function()
+    command('inoreabbr foo bar')
+    command('cnoreabbr <buffer> foo baz')
+
+    local mapargs_i = {
+      abbr = 1,
+      buffer = 0,
+      expr = 0,
+      lhs = 'foo',
+      lhsraw = 'foo',
+      lnum = 0,
+      mode = 'i',
+      mode_bits = 0x10,
+      noremap = 1,
+      nowait = 0,
+      rhs = 'bar',
+      script = 0,
+      scriptversion = 1,
+      sid = 0,
+      silent = 0,
+    }
+    local mapargs_c = {
+      abbr = 1,
+      buffer = 1,
+      expr = 0,
+      lhs = 'foo',
+      lhsraw = 'foo',
+      lnum = 0,
+      mode = 'c',
+      mode_bits = 0x08,
+      noremap = 1,
+      nowait = 0,
+      rhs = 'baz',
+      script = 0,
+      scriptversion = 1,
+      sid = 0,
+      silent = 0,
+    }
+
+    local curbuf = api.nvim_get_current_buf()
+
+    eq({ mapargs_i }, api.nvim_get_keymap('ia'))
+    eq({}, api.nvim_buf_get_keymap(curbuf, 'ia'))
+
+    eq({}, api.nvim_get_keymap('ca'))
+    eq({ mapargs_c }, api.nvim_buf_get_keymap(curbuf, 'ca'))
+
+    eq({ mapargs_i }, api.nvim_get_keymap('!a'))
+    eq({ mapargs_c }, api.nvim_buf_get_keymap(curbuf, '!a'))
   end)
 end)
 
@@ -472,7 +562,7 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
 
   -- Gets a maparg() dict from Nvim, if one exists.
   local function get_mapargs(mode, lhs)
-    local mapargs = funcs.maparg(lhs, normalize_mapmode(mode), mode:sub(-1) == 'a', true)
+    local mapargs = fn.maparg(lhs, normalize_mapmode(mode), mode:sub(-1) == 'a', true)
     -- drop "lhsraw" and "lhsrawalt" which are hard to check
     mapargs.lhsraw = nil
     mapargs.lhsrawalt = nil
@@ -481,238 +571,239 @@ describe('nvim_set_keymap, nvim_del_keymap', function()
 
   it('error on empty LHS', function()
     -- escape parentheses in lua string, else comparison fails erroneously
-    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, '', ''))
+    eq('Invalid (empty) LHS', pcall_err(api.nvim_set_keymap, '', '', 'rhs', {}))
+    eq('Invalid (empty) LHS', pcall_err(api.nvim_set_keymap, '', '', '', {}))
+    eq('Invalid (empty) LHS', pcall_err(api.nvim_del_keymap, '', ''))
   end)
 
   it('error if LHS longer than MAXMAPLEN', function()
     -- assume MAXMAPLEN of 50 chars, as declared in mapping_defs.h
     local MAXMAPLEN = 50
     local lhs = ''
-    for i=1,MAXMAPLEN do
-      lhs = lhs..(i % 10)
+    for i = 1, MAXMAPLEN do
+      lhs = lhs .. (i % 10)
     end
 
     -- exactly 50 chars should be fine
-    meths.set_keymap('', lhs, 'rhs', {})
+    api.nvim_set_keymap('', lhs, 'rhs', {})
 
     -- del_keymap should unmap successfully
-    meths.del_keymap('', lhs)
+    api.nvim_del_keymap('', lhs)
     eq({}, get_mapargs('', lhs))
 
     -- 51 chars should produce an error
-    lhs = lhs..'1'
-    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))
+    lhs = lhs .. '1'
+    eq(
+      'LHS exceeds maximum map length: ' .. lhs,
+      pcall_err(api.nvim_set_keymap, '', lhs, 'rhs', {})
+    )
+    eq('LHS exceeds maximum map length: ' .. lhs, pcall_err(api.nvim_del_keymap, '', lhs))
   end)
 
   it('does not throw errors when rhs is longer than MAXMAPLEN', function()
     local MAXMAPLEN = 50
     local rhs = ''
-    for i=1,MAXMAPLEN do
-      rhs = rhs..(i % 10)
+    for i = 1, MAXMAPLEN do
+      rhs = rhs .. (i % 10)
     end
-    rhs = rhs..'1'
-    meths.set_keymap('', 'lhs', rhs, {})
-    eq(generate_mapargs('', 'lhs', rhs),
-       get_mapargs('', 'lhs'))
+    rhs = rhs .. '1'
+    api.nvim_set_keymap('', 'lhs', rhs, {})
+    eq(generate_mapargs('', 'lhs', rhs), get_mapargs('', 'lhs'))
   end)
 
   it('error on invalid mode shortname', function()
-    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: "a"', pcall_err(meths.set_keymap, 'a', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "oa"', pcall_err(meths.set_keymap, 'oa', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "!o"', pcall_err(meths.set_keymap, '!o', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "!i"', pcall_err(meths.set_keymap, '!i', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "!!"', pcall_err(meths.set_keymap, '!!', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "map"', pcall_err(meths.set_keymap, 'map', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "vmap"', pcall_err(meths.set_keymap, 'vmap', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: "xnoremap"', pcall_err(meths.set_keymap, 'xnoremap', 'lhs', 'rhs', {}))
-    eq('Invalid mode shortname: " "', pcall_err(meths.del_keymap, ' ', 'lhs'))
-    eq('Invalid mode shortname: "m"', pcall_err(meths.del_keymap, 'm', 'lhs'))
-    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'))
-    eq('Invalid mode shortname: "a"', pcall_err(meths.del_keymap, 'a', 'lhs'))
-    eq('Invalid mode shortname: "oa"', pcall_err(meths.del_keymap, 'oa', 'lhs'))
-    eq('Invalid mode shortname: "!o"', pcall_err(meths.del_keymap, '!o', 'lhs'))
-    eq('Invalid mode shortname: "!i"', pcall_err(meths.del_keymap, '!i', 'lhs'))
-    eq('Invalid mode shortname: "!!"', pcall_err(meths.del_keymap, '!!', 'lhs'))
-    eq('Invalid mode shortname: "map"', pcall_err(meths.del_keymap, 'map', 'lhs'))
-    eq('Invalid mode shortname: "vmap"', pcall_err(meths.del_keymap, 'vmap', 'lhs'))
-    eq('Invalid mode shortname: "xnoremap"', pcall_err(meths.del_keymap, 'xnoremap', 'lhs'))
+    eq('Invalid mode shortname: " "', pcall_err(api.nvim_set_keymap, ' ', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "m"', pcall_err(api.nvim_set_keymap, 'm', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "?"', pcall_err(api.nvim_set_keymap, '?', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "y"', pcall_err(api.nvim_set_keymap, 'y', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "p"', pcall_err(api.nvim_set_keymap, 'p', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "a"', pcall_err(api.nvim_set_keymap, 'a', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "oa"', pcall_err(api.nvim_set_keymap, 'oa', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "!o"', pcall_err(api.nvim_set_keymap, '!o', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "!i"', pcall_err(api.nvim_set_keymap, '!i', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "!!"', pcall_err(api.nvim_set_keymap, '!!', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "map"', pcall_err(api.nvim_set_keymap, 'map', 'lhs', 'rhs', {}))
+    eq('Invalid mode shortname: "vmap"', pcall_err(api.nvim_set_keymap, 'vmap', 'lhs', 'rhs', {}))
+    eq(
+      'Invalid mode shortname: "xnoremap"',
+      pcall_err(api.nvim_set_keymap, 'xnoremap', 'lhs', 'rhs', {})
+    )
+    eq('Invalid mode shortname: " "', pcall_err(api.nvim_del_keymap, ' ', 'lhs'))
+    eq('Invalid mode shortname: "m"', pcall_err(api.nvim_del_keymap, 'm', 'lhs'))
+    eq('Invalid mode shortname: "?"', pcall_err(api.nvim_del_keymap, '?', 'lhs'))
+    eq('Invalid mode shortname: "y"', pcall_err(api.nvim_del_keymap, 'y', 'lhs'))
+    eq('Invalid mode shortname: "p"', pcall_err(api.nvim_del_keymap, 'p', 'lhs'))
+    eq('Invalid mode shortname: "a"', pcall_err(api.nvim_del_keymap, 'a', 'lhs'))
+    eq('Invalid mode shortname: "oa"', pcall_err(api.nvim_del_keymap, 'oa', 'lhs'))
+    eq('Invalid mode shortname: "!o"', pcall_err(api.nvim_del_keymap, '!o', 'lhs'))
+    eq('Invalid mode shortname: "!i"', pcall_err(api.nvim_del_keymap, '!i', 'lhs'))
+    eq('Invalid mode shortname: "!!"', pcall_err(api.nvim_del_keymap, '!!', 'lhs'))
+    eq('Invalid mode shortname: "map"', pcall_err(api.nvim_del_keymap, 'map', 'lhs'))
+    eq('Invalid mode shortname: "vmap"', pcall_err(api.nvim_del_keymap, 'vmap', 'lhs'))
+    eq('Invalid mode shortname: "xnoremap"', pcall_err(api.nvim_del_keymap, 'xnoremap', 'lhs'))
   end)
 
   it('error on invalid optnames', function()
-    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}))
+    eq(
+      "Invalid key: 'silentt'",
+      pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', { silentt = true })
+    )
+    eq("Invalid key: 'sidd'", pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', { sidd = false }))
+    eq(
+      "Invalid key: 'nowaiT'",
+      pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', { nowaiT = false })
+    )
   end)
 
   it('error on <buffer> option key', function()
-    eq("Invalid key: 'buffer'",
-      pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {buffer = true}))
+    eq(
+      "Invalid key: 'buffer'",
+      pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', { buffer = true })
+    )
   end)
 
   it('error when "replace_keycodes" is used without "expr"', function()
-    eq('"replace_keycodes" requires "expr"',
-      pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', {replace_keycodes = true}))
+    eq(
+      '"replace_keycodes" requires "expr"',
+      pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', { replace_keycodes = true })
+    )
   end)
 
-  local optnames = {'nowait', 'silent', 'script', 'expr', 'unique'}
+  local optnames = { 'nowait', 'silent', 'script', 'expr', 'unique' }
   for _, opt in ipairs(optnames) do
     -- note: need '%' to escape hyphens, which have special meaning in lua
-    it('throws an error when given non-boolean value for '..opt, function()
+    it('throws an error when given non-boolean value for ' .. opt, function()
       local opts = {}
       opts[opt] = 'fooo'
-      eq(opt..' is not a boolean',
-        pcall_err(meths.set_keymap, 'n', 'lhs', 'rhs', opts))
+      eq(opt .. ' is not a boolean', pcall_err(api.nvim_set_keymap, 'n', 'lhs', 'rhs', opts))
     end)
   end
 
   -- Perform tests of basic functionality
   it('sets ordinary mappings', function()
-    meths.set_keymap('n', 'lhs', 'rhs', {})
+    api.nvim_set_keymap('n', 'lhs', 'rhs', {})
     eq(generate_mapargs('n', 'lhs', 'rhs'), get_mapargs('n', 'lhs'))
 
-    meths.set_keymap('v', 'lhs', 'rhs', {})
+    api.nvim_set_keymap('v', 'lhs', 'rhs', {})
     eq(generate_mapargs('v', 'lhs', 'rhs'), get_mapargs('v', 'lhs'))
   end)
 
   it('does not throw when LHS or RHS have leading/trailing whitespace', function()
-    meths.set_keymap('n', '   lhs', 'rhs', {})
-    eq(generate_mapargs('n', '<Space><Space><Space>lhs', 'rhs'),
-       get_mapargs('n', '   lhs'))
+    api.nvim_set_keymap('n', '   lhs', 'rhs', {})
+    eq(generate_mapargs('n', '<Space><Space><Space>lhs', 'rhs'), get_mapargs('n', '   lhs'))
 
-    meths.set_keymap('n', 'lhs    ', 'rhs', {})
-    eq(generate_mapargs('n', 'lhs<Space><Space><Space><Space>', 'rhs'),
-       get_mapargs('n', 'lhs    '))
+    api.nvim_set_keymap('n', 'lhs    ', 'rhs', {})
+    eq(generate_mapargs('n', 'lhs<Space><Space><Space><Space>', 'rhs'), get_mapargs('n', 'lhs    '))
 
-    meths.set_keymap('v', ' lhs  ', '\trhs\t\f', {})
-    eq(generate_mapargs('v', '<Space>lhs<Space><Space>', '\trhs\t\f'),
-       get_mapargs('v', ' lhs  '))
+    api.nvim_set_keymap('v', ' lhs  ', '\trhs\t\f', {})
+    eq(generate_mapargs('v', '<Space>lhs<Space><Space>', '\trhs\t\f'), get_mapargs('v', ' lhs  '))
   end)
 
   it('can set noremap mappings', function()
-    meths.set_keymap('x', 'lhs', 'rhs', {noremap = true})
-    eq(generate_mapargs('x', 'lhs', 'rhs', {noremap = true}),
-       get_mapargs('x', 'lhs'))
+    api.nvim_set_keymap('x', 'lhs', 'rhs', { noremap = true })
+    eq(generate_mapargs('x', 'lhs', 'rhs', { noremap = true }), get_mapargs('x', 'lhs'))
 
-    meths.set_keymap('t', 'lhs', 'rhs', {noremap = true})
-    eq(generate_mapargs('t', 'lhs', 'rhs', {noremap = true}),
-       get_mapargs('t', 'lhs'))
+    api.nvim_set_keymap('t', 'lhs', 'rhs', { noremap = true })
+    eq(generate_mapargs('t', 'lhs', 'rhs', { noremap = true }), get_mapargs('t', 'lhs'))
   end)
 
   it('can unmap mappings', function()
-    meths.set_keymap('v', 'lhs', 'rhs', {})
-    meths.del_keymap('v', 'lhs')
+    api.nvim_set_keymap('v', 'lhs', 'rhs', {})
+    api.nvim_del_keymap('v', 'lhs')
     eq({}, get_mapargs('v', 'lhs'))
 
-    meths.set_keymap('t', 'lhs', 'rhs', {noremap = true})
-    meths.del_keymap('t', 'lhs')
+    api.nvim_set_keymap('t', 'lhs', 'rhs', { noremap = true })
+    api.nvim_del_keymap('t', 'lhs')
     eq({}, get_mapargs('t', 'lhs'))
   end)
 
   -- Test some edge cases
   it('"!" and empty string are synonyms for mapmode-nvo', function()
-    local nvo_shortnames = {'', '!'}
+    local nvo_shortnames = { '', '!' }
     for _, name in ipairs(nvo_shortnames) do
-      meths.set_keymap(name, 'lhs', 'rhs', {})
-      meths.del_keymap(name, 'lhs')
+      api.nvim_set_keymap(name, 'lhs', 'rhs', {})
+      api.nvim_del_keymap(name, 'lhs')
       eq({}, get_mapargs(name, 'lhs'))
     end
   end)
 
-  local special_chars = {'<C-U>', '<S-Left>', '<F12><F2><Tab>', '<Space><Tab>'}
+  local special_chars = { '<C-U>', '<S-Left>', '<F12><F2><Tab>', '<Space><Tab>' }
   for _, lhs in ipairs(special_chars) do
     for _, rhs in ipairs(special_chars) do
       local mapmode = '!'
-      it('can set mappings with special characters, lhs: '..lhs..', rhs: '..rhs,
-          function()
-        meths.set_keymap(mapmode, lhs, rhs, {})
+      it('can set mappings with special characters, lhs: ' .. lhs .. ', rhs: ' .. rhs, function()
+        api.nvim_set_keymap(mapmode, lhs, rhs, {})
         eq(generate_mapargs(mapmode, lhs, rhs), get_mapargs(mapmode, lhs))
       end)
     end
   end
 
   it('can set mappings containing literal keycodes', function()
-    meths.set_keymap('n', '\n\r\n', 'rhs', {})
+    api.nvim_set_keymap('n', '\n\r\n', 'rhs', {})
     local expected = generate_mapargs('n', '<NL><CR><NL>', 'rhs')
     eq(expected, get_mapargs('n', '<NL><CR><NL>'))
   end)
 
   it('can set mappings whose RHS is a <Nop>', function()
-    meths.set_keymap('i', 'lhs', '<Nop>', {})
+    api.nvim_set_keymap('i', 'lhs', '<Nop>', {})
     command('normal ilhs')
-    eq({''}, curbufmeths.get_lines(0, -1, 0))  -- imap to <Nop> does nothing
-    eq(generate_mapargs('i', 'lhs', '<Nop>', {}),
-       get_mapargs('i', 'lhs'))
+    eq({ '' }, api.nvim_buf_get_lines(0, 0, -1, 0)) -- imap to <Nop> does nothing
+    eq(generate_mapargs('i', 'lhs', '<Nop>', {}), get_mapargs('i', 'lhs'))
 
     -- also test for case insensitivity
-    meths.set_keymap('i', 'lhs', '<nOp>', {})
+    api.nvim_set_keymap('i', 'lhs', '<nOp>', {})
     command('normal ilhs')
-    eq({''}, curbufmeths.get_lines(0, -1, 0))
+    eq({ '' }, api.nvim_buf_get_lines(0, 0, -1, 0))
     -- note: RHS in returned mapargs() dict reflects the original RHS
     -- provided by the user
-    eq(generate_mapargs('i', 'lhs', '<nOp>', {}),
-       get_mapargs('i', 'lhs'))
+    eq(generate_mapargs('i', 'lhs', '<nOp>', {}), get_mapargs('i', 'lhs'))
 
-    meths.set_keymap('i', 'lhs', '<NOP>', {})
+    api.nvim_set_keymap('i', 'lhs', '<NOP>', {})
     command('normal ilhs')
-    eq({''}, curbufmeths.get_lines(0, -1, 0))
-    eq(generate_mapargs('i', 'lhs', '<NOP>', {}),
-       get_mapargs('i', 'lhs'))
+    eq({ '' }, api.nvim_buf_get_lines(0, 0, -1, 0))
+    eq(generate_mapargs('i', 'lhs', '<NOP>', {}), get_mapargs('i', 'lhs'))
 
     -- a single ^V in RHS is also <Nop> (see :h map-empty-rhs)
-    meths.set_keymap('i', 'lhs', '\022', {})
+    api.nvim_set_keymap('i', 'lhs', '\022', {})
     command('normal ilhs')
-    eq({''}, curbufmeths.get_lines(0, -1, 0))
-    eq(generate_mapargs('i', 'lhs', '\022', {}),
-       get_mapargs('i', 'lhs'))
+    eq({ '' }, api.nvim_buf_get_lines(0, 0, -1, 0))
+    eq(generate_mapargs('i', 'lhs', '\022', {}), get_mapargs('i', 'lhs'))
   end)
 
   it('treats an empty RHS in a mapping like a <Nop>', function()
-    meths.set_keymap('i', 'lhs', '', {})
+    api.nvim_set_keymap('i', 'lhs', '', {})
     command('normal ilhs')
-    eq({''}, curbufmeths.get_lines(0, -1, 0))
-    eq(generate_mapargs('i', 'lhs', '', {}),
-       get_mapargs('i', 'lhs'))
+    eq({ '' }, api.nvim_buf_get_lines(0, 0, -1, 0))
+    eq(generate_mapargs('i', 'lhs', '', {}), get_mapargs('i', 'lhs'))
   end)
 
   it('can set and unset <M-">', function()
     -- Taken from the legacy test: test_mapping.vim. Exposes a bug