6 files changed, 224 insertions, 29 deletions

diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua
index c924988d06..0eefa25a13 100644
--- a/test/functional/api/buffer_spec.lua
+++ b/test/functional/api/buffer_spec.lua
@@ -1,8 +1,9 @@
 -- Sanity checks for buffer_* API calls via msgpack-rpc
 local helpers = require('test.functional.helpers')
-local clear, nvim, buffer, curbuf, curwin, eq, ok =
-  helpers.clear, helpers.nvim, helpers.buffer, helpers.curbuf, helpers.curwin,
-  helpers.eq, helpers.ok
+local clear, nvim, buffer = helpers.clear, helpers.nvim, helpers.buffer
+local curbuf, curwin, eq = helpers.curbuf, helpers.curwin, helpers.eq
+local curbufmeths, ok = helpers.curbufmeths, helpers.ok
+local funcs = helpers.funcs
 
 describe('buffer_* functions', function()
   before_each(clear)
@@ -35,10 +36,11 @@ describe('buffer_* functions', function()
       eq('', curbuf('get_line', 0))
     end)
 
-    it('get_line: out-of-bounds returns empty string', function()
+    it('get_line: out-of-bounds is an error', function()
       curbuf('set_line', 0, 'line1.a')
-      eq('', curbuf('get_line', 1))
-      eq('', curbuf('get_line', -2))
+      eq(1, curbuf('line_count')) -- sanity
+      eq(false, pcall(curbuf, 'get_line', 1))
+      eq(false, pcall(curbuf, 'get_line', -2))
     end)
 
     it('set_line, del_line: out-of-bounds is an error', function()
@@ -68,14 +70,16 @@ describe('buffer_* functions', function()
       eq({}, curbuf('get_line_slice', -4, -5, true, true))
     end)
 
-    it('set_line_slice: out-of-bounds is an error', function()
+    it('set_line_slice: out-of-bounds extends past end', function()
       curbuf('set_line_slice', 0, 0, true, true, {'a', 'b', 'c'})
       eq({'a', 'b', 'c'}, curbuf('get_line_slice', 0, 2, true, true)) --sanity
 
       eq({'c'}, curbuf('get_line_slice', -1, 4, true, true))
       eq({'a', 'b', 'c'}, curbuf('get_line_slice', 0, 5, true, true))
-      eq(false, pcall(curbuf, 'set_line_slice', 4, 5, true, true, {'d'}))
-      eq(false, pcall(curbuf, 'set_line_slice', -4, -5, true, true, {'d'}))
+      curbuf('set_line_slice', 4, 5, true, true, {'d'})
+      eq({'a', 'b', 'c', 'd'}, curbuf('get_line_slice', 0, 5, true, true))
+      curbuf('set_line_slice', -4, -5, true, true, {'e'})
+      eq({'e', 'a', 'b', 'c', 'd'}, curbuf('get_line_slice', 0, 5, true, true))
     end)
 
     it('works', function()
@@ -101,11 +105,144 @@ describe('buffer_* functions', function()
     end)
   end)
 
-  describe('{get,set}_var', function()
+  describe('{get,set}_lines', function()
+    local get_lines, set_lines = curbufmeths.get_lines, curbufmeths.set_lines
+    local line_count = curbufmeths.line_count
+
+    it('has correct line_count when inserting and deleting', function()
+      eq(1, line_count())
+      set_lines(-1, -1, true, {'line'})
+      eq(2, line_count())
+      set_lines(-1, -1, true, {'line'})
+      eq(3, line_count())
+      set_lines(-2, -1, true, {})
+      eq(2, line_count())
+      set_lines(-2, -1, true, {})
+      set_lines(-2, -1, true, {})
+      -- There's always at least one line
+      eq(1, line_count())
+    end)
+
+    it('can get, set and delete a single line', function()
+      eq({''}, get_lines(0, 1, true))
+      set_lines(0, 1, true, {'line1'})
+      eq({'line1'}, get_lines(0, 1, true))
+      set_lines(0, 1, true, {'line2'})
+      eq({'line2'}, get_lines(0, 1, true))
+      set_lines(0, 1, true, {})
+      eq({''}, get_lines(0, 1, true))
+    end)
+
+    it('can get a single line with strict indexing', function()
+      set_lines(0, 1, true, {'line1.a'})
+      eq(1, line_count()) -- sanity
+      eq(false, pcall(get_lines, 1, 2, true))
+      eq(false, pcall(get_lines, -3, -2, true))
+    end)
+
+    it('can get a single line with non-strict indexing', function()
+      set_lines(0, 1, true, {'line1.a'})
+      eq(1, line_count()) -- sanity
+      eq({}, get_lines(1, 2, false))
+      eq({}, get_lines(-3, -2, false))
+    end)
+
+    it('can set and delete a single line with strict indexing', function()
+      set_lines(0, 1, true, {'line1.a'})
+      eq(false, pcall(set_lines, 1, 2, true, {'line1.b'}))
+      eq(false, pcall(set_lines, -3, -2, true, {'line1.c'}))
+      eq({'line1.a'}, get_lines(0, -1, true))
+      eq(false, pcall(set_lines, 1, 2, true, {}))
+      eq(false, pcall(set_lines, -3, -2, true, {}))
+      eq({'line1.a'}, get_lines(0, -1, true))
+    end)
+
+    it('can set and delete a single line with non-strict indexing', function()
+      set_lines(0, 1, true, {'line1.a'})
+      set_lines(1, 2, false, {'line1.b'})
+      set_lines(-4, -3, false, {'line1.c'})
+      eq({'line1.c', 'line1.a', 'line1.b'}, get_lines(0, -1, true))
+      set_lines(3, 4, false, {})
+      set_lines(-5, -4, false, {})
+      eq({'line1.c', 'line1.a', 'line1.b'}, get_lines(0, -1, true))
+    end)
+
+    it('can handle NULs', function()
+      set_lines(0, 1, true, {'ab\0cd'})
+      eq({'ab\0cd'}, get_lines(0, -1, true))
+    end)
+
+    it('works with multiple lines', function()
+      eq({''}, get_lines(0, -1, true))
+      -- Replace buffer
+      for _, mode in pairs({false, true}) do
+        set_lines(0, -1, mode, {'a', 'b', 'c'})
+        eq({'a', 'b', 'c'}, get_lines(0, -1, mode))
+        eq({'b', 'c'}, get_lines(1, -1, mode))
+        eq({'b'}, get_lines(1, 2, mode))
+        eq({}, get_lines(1, 1, mode))
+        eq({'a', 'b'}, get_lines(0, -2, mode))
+        eq({'b'}, get_lines(1, -2, mode))
+        eq({'b', 'c'}, get_lines(-3, -1, mode))
+        set_lines(1, 2, mode, {'a', 'b', 'c'})
+        eq({'a', 'a', 'b', 'c', 'c'}, get_lines(0, -1, mode))
+        set_lines(-2, -1, mode, {'a', 'b', 'c'})
+        eq({'a', 'a', 'b', 'c', 'a', 'b', 'c'},
+          get_lines(0, -1, mode))
+        set_lines(0, -4, mode, {})
+        eq({'a', 'b', 'c'}, get_lines(0, -1, mode))
+        set_lines(0, -1, mode, {})
+        eq({''}, get_lines(0, -1, mode))
+      end
+    end)
+
+    it('can get line ranges with non-strict indexing', function()
+      set_lines(0, -1, true, {'a', 'b', 'c'})
+      eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity
+
+      eq({}, get_lines(3, 4, false))
+      eq({}, get_lines(3, 10, false))
+      eq({}, get_lines(-5, -5, false))
+      eq({}, get_lines(3, -1, false))
+      eq({}, get_lines(-3, -4, false))
+    end)
+
+    it('can get line ranges with strict indexing', function()
+      set_lines(0, -1, true, {'a', 'b', 'c'})
+      eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity
+
+      eq(false, pcall(get_lines, 3, 4, true))
+      eq(false, pcall(get_lines, 3, 10, true))
+      eq(false, pcall(get_lines, -5, -5, true))
+      -- empty or inverted ranges are not errors
+      eq({}, get_lines(3, -1, true))
+      eq({}, get_lines(-3, -4, true))
+    end)
+
+    it('set_line_slice: out-of-bounds can extend past end', function()
+      set_lines(0, -1, true, {'a', 'b', 'c'})
+      eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity
+
+      eq({'c'}, get_lines(-2, 5, false))
+      eq({'a', 'b', 'c'}, get_lines(0, 6, false))
+      eq(false, pcall(set_lines, 4, 6, true, {'d'}))
+      set_lines(4, 6, false, {'d'})
+      eq({'a', 'b', 'c', 'd'}, get_lines(0, -1, true))
+      eq(false, pcall(set_lines, -6, -6, true, {'e'}))
+      set_lines(-6, -6, false, {'e'})
+      eq({'e', 'a', 'b', 'c', 'd'}, get_lines(0, -1, true))
+    end)
+
+  end)
+
+  describe('{get,set,del}_var', function()
     it('works', function()
       curbuf('set_var', 'lua', {1, 2, {['3'] = 1}})
       eq({1, 2, {['3'] = 1}}, curbuf('get_var', 'lua'))
       eq({1, 2, {['3'] = 1}}, nvim('eval', 'b:lua'))
+      eq(1, funcs.exists('b:lua'))
+      curbufmeths.del_var('lua')
+      eq(0, funcs.exists('b:lua'))
     end)
   end)
 
diff --git a/test/functional/api/menu_spec.lua b/test/functional/api/menu_spec.lua
index 34d23ca098..5b414fb559 100644
--- a/test/functional/api/menu_spec.lua
+++ b/test/functional/api/menu_spec.lua
@@ -19,7 +19,7 @@ describe("update_menu notification", function()
     screen:detach()
   end)
 
-  function expect_sent(expected)
+  local function expect_sent(expected)
     screen:wait(function()
       if screen.update_menu ~= expected then
         if expected then
diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 4c7122a549..1b33275803 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -32,6 +32,26 @@ describe('server -> client', function()
     end)
   end)
 
+  describe('empty string handling in arrays', function()
+    -- Because the msgpack encoding for an empty string was interpreted as an
+    -- error, msgpack arrays with an empty string looked like
+    -- [..., '', 0, ..., 0] after the conversion, regardless of the array
+    -- elements following the empty string.
+    it('works', function()
+      local function on_setup()
+        eq({1, 2, '', 3, 'asdf'}, eval('rpcrequest('..cid..', "nstring")'))
+        stop()
+      end
+
+      local function on_request()
+        -- No need to evaluate the args, we are only interested in
+        -- a response that contains an array with an empty string.
+        return {1, 2, '', 3, 'asdf'}
+      end
+      run(on_request, nil, on_setup)
+    end)
+  end)
+
   describe('recursive call', function()
     it('works', function()
       local function on_setup()
@@ -95,13 +115,13 @@ describe('server -> client', function()
         eq('notified!', eval('rpcrequest('..cid..', "notify")'))
       end
 
-      local function on_request(method, args)
+      local function on_request(method)
         eq('notify', method)
         eq(1, eval('rpcnotify('..cid..', "notification")'))
         return 'notified!'
       end
 
-      local function on_notification(method, args)
+      local function on_notification(method)
         eq('notification', method)
         if notified == expected then
           stop()
@@ -145,8 +165,8 @@ describe('server -> client', function()
 
       eq('SOME TEXT', eval("rpcrequest(vim, 'buffer_get_line', "..buf..", 0)"))
 
-      -- Call get_line_slice(buf, range [0,0], includes start, includes end)
-      eq({'SOME TEXT'}, eval("rpcrequest(vim, 'buffer_get_line_slice', "..buf..", 0, 0, 1, 1)"))
+      -- Call get_lines(buf, range [0,0], strict_indexing)
+      eq({'SOME TEXT'}, eval("rpcrequest(vim, 'buffer_get_lines', "..buf..", 0, 1, 1)"))
     end)
 
     it('returns an error if the request failed', function()
diff --git a/test/functional/api/tabpage_spec.lua b/test/functional/api/tabpage_spec.lua
index 9937e0c72e..c782107714 100644
--- a/test/functional/api/tabpage_spec.lua
+++ b/test/functional/api/tabpage_spec.lua
@@ -3,6 +3,8 @@ local helpers = require('test.functional.helpers')
 local clear, nvim, tabpage, curtab, eq, ok =
   helpers.clear, helpers.nvim, helpers.tabpage, helpers.curtab, helpers.eq,
   helpers.ok
+local curtabmeths = helpers.curtabmeths
+local funcs = helpers.funcs
 
 describe('tabpage_* functions', function()
   before_each(clear)
@@ -21,11 +23,14 @@ describe('tabpage_* functions', function()
     end)
   end)
 
-  describe('{get,set}_var', function()
+  describe('{get,set,del}_var', function()
     it('works', function()
       curtab('set_var', 'lua', {1, 2, {['3'] = 1}})
       eq({1, 2, {['3'] = 1}}, curtab('get_var', 'lua'))
       eq({1, 2, {['3'] = 1}}, nvim('eval', 't:lua'))
+      eq(1, funcs.exists('t:lua'))
+      curtabmeths.del_var('lua')
+      eq(0, funcs.exists('t:lua'))
     end)
   end)
 
diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index eb4804f141..20de6d0072 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -1,9 +1,12 @@
 -- Sanity checks for vim_* API calls via msgpack-rpc
 local helpers = require('test.functional.helpers')
 local Screen = require('test.functional.ui.screen')
+local NIL = helpers.NIL
 local clear, nvim, eq, neq = helpers.clear, helpers.nvim, helpers.eq, helpers.neq
 local ok, nvim_async, feed = helpers.ok, helpers.nvim_async, helpers.feed
-
+local os_name = helpers.os_name
+local meths = helpers.meths
+local funcs = helpers.funcs
 
 describe('vim_* functions', function()
   before_each(clear)
@@ -17,7 +20,11 @@ describe('vim_* functions', function()
       nvim('command', 'w')
       local f = io.open(fname)
       ok(f ~= nil)
-      eq('testing\napi\n', f:read('*a'))
+      if os_name() == 'windows' then
+        eq('testing\r\napi\r\n', f:read('*a'))
+      else
+        eq('testing\napi\n', f:read('*a'))
+      end
       f:close()
       os.remove(fname)
     end)
@@ -66,20 +73,31 @@ describe('vim_* functions', function()
     end)
   end)
 
-  describe('{get,set}_var', function()
+  describe('{get,set,del}_var', function()
     it('works', function()
       nvim('set_var', 'lua', {1, 2, {['3'] = 1}})
       eq({1, 2, {['3'] = 1}}, nvim('get_var', 'lua'))
       eq({1, 2, {['3'] = 1}}, nvim('eval', 'g:lua'))
+      eq(1, funcs.exists('g:lua'))
+      meths.del_var('lua')
+      eq(0, funcs.exists('g:lua'))
     end)
 
     it('set_var returns the old value', function()
       local val1 = {1, 2, {['3'] = 1}}
       local val2 = {4, 7}
-      eq(nil, nvim('set_var', 'lua', val1))
+      eq(NIL, nvim('set_var', 'lua', val1))
       eq(val1, nvim('set_var', 'lua', val2))
     end)
 
+    it('del_var returns the old value', function()
+      local val1 = {1, 2, {['3'] = 1}}
+      local val2 = {4, 7}
+      eq(NIL, meths.set_var('lua', val1))
+      eq(val1, meths.set_var('lua', val2))
+      eq(val2, meths.del_var('lua'))
+    end)
+
     it('truncates values with NULs in them', function()
       nvim('set_var', 'xxx', 'ab\0cd')
       eq('ab', nvim('get_var', 'xxx'))
@@ -140,15 +158,23 @@ describe('vim_* functions', function()
 
   describe('replace_termcodes', function()
     it('escapes K_SPECIAL as K_SPECIAL KS_SPECIAL KE_FILLER', function()
-      eq(helpers.nvim('replace_termcodes', '\128', true, true, true), '\128\254X')
+      eq('\128\254X', helpers.nvim('replace_termcodes', '\128', true, true, true))
     end)
 
-    it('leaves non K_SPECIAL string unchanged', function()
-      eq(helpers.nvim('replace_termcodes', 'abc', true, true, true), 'abc')
+    it('leaves non-K_SPECIAL string unchanged', function()
+      eq('abc', helpers.nvim('replace_termcodes', 'abc', true, true, true))
     end)
 
     it('converts <expressions>', function()
-      eq(helpers.nvim('replace_termcodes', '<Leader>', true, true, true), '\\')
+      eq('\\', helpers.nvim('replace_termcodes', '<Leader>', true, true, true))
+    end)
+
+    it('converts <LeftMouse> to K_SPECIAL KS_EXTRA KE_LEFTMOUSE', function()
+      -- K_SPECIAL KS_EXTRA KE_LEFTMOUSE
+      -- 0x80      0xfd     0x2c
+      -- 128       253      44
+      eq('\128\253\44', helpers.nvim('replace_termcodes',
+                                     '<LeftMouse>', true, true, true))
     end)
   end)
 
@@ -180,6 +206,8 @@ describe('vim_* functions', function()
   end)
 
   describe('err_write', function()
+    local screen
+
     before_each(function()
       clear()
       screen = Screen.new(40, 8)
diff --git a/test/functional/api/window_spec.lua b/test/functional/api/window_spec.lua
index 456252522d..92a33b4cdb 100644
--- a/test/functional/api/window_spec.lua
+++ b/test/functional/api/window_spec.lua
@@ -1,10 +1,12 @@
 -- Sanity checks for window_* API calls via msgpack-rpc
 local helpers = require('test.functional.helpers')
-local clear, nvim, buffer, curbuf, curbuf_contents, window, curwin, eq, neq,
-  ok, feed, rawfeed, insert, eval = helpers.clear, helpers.nvim, helpers.buffer, helpers.curbuf,
+local clear, nvim, curbuf, curbuf_contents, window, curwin, eq, neq,
+  ok, feed, insert, eval = helpers.clear, helpers.nvim, helpers.curbuf,
   helpers.curbuf_contents, helpers.window, helpers.curwin, helpers.eq,
-  helpers.neq, helpers.ok, helpers.feed, helpers.rawfeed, helpers.insert, helpers.eval
+  helpers.neq, helpers.ok, helpers.feed, helpers.insert, helpers.eval
 local wait = helpers.wait
+local curwinmeths = helpers.curwinmeths
+local funcs = helpers.funcs
 
 -- check if str is visible at the beginning of some line
 local function is_visible(str)
@@ -54,7 +56,7 @@ describe('window_* functions', function()
       insert("prologue")
       feed('100o<esc>')
       insert("epilogue")
-      win = curwin()
+      local win = curwin()
       feed('gg')
       wait() -- let nvim process the 'gg' command
 
@@ -126,11 +128,14 @@ describe('window_* functions', function()
     end)
   end)
 
-  describe('{get,set}_var', function()
+  describe('{get,set,del}_var', function()
     it('works', function()
       curwin('set_var', 'lua', {1, 2, {['3'] = 1}})
       eq({1, 2, {['3'] = 1}}, curwin('get_var', 'lua'))
       eq({1, 2, {['3'] = 1}}, nvim('eval', 'w:lua'))
+      eq(1, funcs.exists('w:lua'))
+      curwinmeths.del_var('lua')
+      eq(0, funcs.exists('w:lua'))
     end)
   end)