From ba2f615cd40d5d809d1a141c7b098e3bd22ff7bb Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sat, 16 Jul 2016 02:26:04 +0300
Subject: functests: Test for error conditions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

During testing found the following bugs:

1. msgpack-gen.lua script is completely unprepared for Float values either in
   return type or in arguments. Specifically:

   1. At the time of writing relevant code FLOAT_OBJ did not exist as well as
      FLOATING_OBJ, but it would be used by msgpack-gen.lua should return type
      be Float. I added FLOATING_OBJ macros later because did not know that
      msgpack-gen.lua uses these _OBJ macros, otherwise it would be FLOAT_OBJ.
   2. msgpack-gen.lua should use .data.floating in place of .data.float. But it
      did not expect that .data subattribute may have name different from
      lowercased type name.

2. vim_replace_termcodes returned its argument as-is if it receives an empty
   string (as well as _vim_id*() functions did). But if something in returned
   argument lives in an allocated memory such action will cause double free:
   once when freeing arguments, then when freeing return value. It did not cause
   problems yet because msgpack bindings return empty string as {NULL, 0} and
   nothing was actually allocated.
3. New code in msgpack-gen.lua popped arguments in reversed order, making lua
   bindings’ signatures be different from API ones.
---
 test/functional/api/vim_spec.lua | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 3348368a36..24ed0afe67 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -219,6 +219,17 @@ describe('api', function()
       eq('\128\253\44', helpers.nvim('replace_termcodes',
                                      '<LeftMouse>', true, true, true))
     end)
+
+    it('does not crash when transforming an empty string', function()
+      -- Actually does not test anything, because current code will use NULL for
+      -- an empty string.
+      --
+      -- Problem here is that if String argument has .data in allocated memory
+      -- then `return str` in vim_replace_termcodes body will make Neovim free
+      -- `str.data` twice: once when freeing arguments, then when freeing return
+      -- value.
+      eq('', meths.replace_termcodes('', true, true, true))
+    end)
   end)
 
   describe('nvim_feedkeys', function()
-- 
cgit 


From eb0e94f71b1f44cebf7ae5c1bcff348264af6cef Mon Sep 17 00:00:00 2001
From: Jakob Schnitzer <mail@jakobschnitzer.de>
Date: Thu, 30 Mar 2017 22:03:52 +0200
Subject: api: {get,set}_option should {get,set} global value of local options
 (#6405)

- nvim_get_option should return the global default of a local option.
- nvim_set_option should set the global default of a local option.
---
 test/functional/api/vim_spec.lua | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 3348368a36..8f9f155110 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -153,6 +153,28 @@ describe('api', function()
       nvim('set_option', 'equalalways', false)
       ok(not nvim('get_option', 'equalalways'))
     end)
+
+    it('works to get global value of local options', function()
+      eq(false, nvim('get_option', 'lisp'))
+      eq(8, nvim('get_option', 'shiftwidth'))
+    end)
+
+    it('works to set global value of local options', function()
+      nvim('set_option', 'lisp', true)
+      eq(true, nvim('get_option', 'lisp'))
+      eq(false, helpers.curbuf('get_option', 'lisp'))
+      eq(nil, nvim('command_output', 'setglobal lisp?'):match('nolisp'))
+      eq('nolisp', nvim('command_output', 'setlocal lisp?'):match('nolisp'))
+      nvim('set_option', 'shiftwidth', 20)
+      eq('20', nvim('command_output', 'setglobal shiftwidth?'):match('%d+'))
+      eq('8', nvim('command_output', 'setlocal shiftwidth?'):match('%d+'))
+    end)
+
+    it('most window-local options have no global value', function()
+      local status, err = pcall(nvim, 'get_option', 'foldcolumn')
+      eq(false, status)
+      ok(err:match('Invalid option name') ~= nil)
+    end)
   end)
 
   describe('nvim_{get,set}_current_buf, nvim_list_bufs', function()
-- 
cgit 


From 65fb622000af8e3dbb65480e1581758ecf4ba3e2 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 9 Apr 2017 00:12:26 +0300
Subject: functests: Replace execute with either command or feed_command

Hope this will make people using feed_command less likely: this hides bugs.
Already found at least two:

1. msgpackparse() will show internal error: hash_add() in case of duplicate
   keys, though it will still work correctly. Currently silenced.
2. ttimeoutlen was spelled incorrectly, resulting in option not being set when
   expected. Test was still functioning somehow though. Currently fixed.
---
 test/functional/api/buffer_spec.lua               | 6 +++---
 test/functional/api/server_notifications_spec.lua | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua
index 552e3a8564..c3002618b0 100644
--- a/test/functional/api/buffer_spec.lua
+++ b/test/functional/api/buffer_spec.lua
@@ -5,7 +5,7 @@ local curbufmeths, ok = helpers.curbufmeths, helpers.ok
 local funcs = helpers.funcs
 local request = helpers.request
 local exc_exec = helpers.exc_exec
-local execute = helpers.execute
+local feed_command = helpers.feed_command
 local insert = helpers.insert
 local NIL = helpers.NIL
 local meth_pcall = helpers.meth_pcall
@@ -246,7 +246,7 @@ describe('api/buf', function()
     end)
 
     it("set_line on alternate buffer does not access invalid line (E315)", function()
-      execute('set hidden')
+      feed_command('set hidden')
       insert('Initial file')
       command('enew')
       insert([[
@@ -257,7 +257,7 @@ describe('api/buf', function()
       The
       Other
       Buffer]])
-      execute('$')
+      feed_command('$')
       local retval = exc_exec("call nvim_buf_set_lines(1, 0, 1, v:false, ['test'])")
       eq(0, retval)
     end)
diff --git a/test/functional/api/server_notifications_spec.lua b/test/functional/api/server_notifications_spec.lua
index 78639d7ed7..9d7cfb9b78 100644
--- a/test/functional/api/server_notifications_spec.lua
+++ b/test/functional/api/server_notifications_spec.lua
@@ -1,6 +1,6 @@
 local helpers = require('test.functional.helpers')(after_each)
-local eq, clear, eval, execute, nvim, next_message =
-  helpers.eq, helpers.clear, helpers.eval, helpers.execute, helpers.nvim,
+local eq, clear, eval, command, nvim, next_message =
+  helpers.eq, helpers.clear, helpers.eval, helpers.command, helpers.nvim,
   helpers.next_message
 local meths = helpers.meths
 
@@ -16,8 +16,8 @@ describe('notify', function()
     it('sends the notification/args to the corresponding channel', function()
       eval('rpcnotify('..channel..', "test-event", 1, 2, 3)')
       eq({'notification', 'test-event', {1, 2, 3}}, next_message())
-      execute('au FileType lua call rpcnotify('..channel..', "lua!")')
-      execute('set filetype=lua')
+      command('au FileType lua call rpcnotify('..channel..', "lua!")')
+      command('set filetype=lua')
       eq({'notification', 'lua!', {}}, next_message())
     end)
   end)
-- 
cgit 


From 69d1003bf79b7466d2fea45f94aeddbedd246049 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 9 Apr 2017 01:55:19 +0300
Subject: functests: Fix some tests which are failing locally for unrelated
 reasons

---
 test/functional/api/server_requests_spec.lua | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 76a335a8f4..658077b112 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -1,6 +1,8 @@
 -- Test server -> client RPC scenarios. Note: unlike `rpcnotify`, to evaluate
 -- `rpcrequest` calls we need the client event loop to be running.
 local helpers = require('test.functional.helpers')(after_each)
+local Paths = require('test.config.paths')
+
 local clear, nvim, eval = helpers.clear, helpers.nvim, helpers.eval
 local eq, neq, run, stop = helpers.eq, helpers.neq, helpers.run, helpers.stop
 local nvim_prog, command, funcs = helpers.nvim_prog, helpers.command, helpers.funcs
@@ -200,7 +202,7 @@ describe('server -> client', function()
         \ 'rpc': v:true
         \ }
       ]])
-      local lua_prog = arg[-1]
+      local lua_prog = Paths.test_lua_prg
       meths.set_var("args", {lua_prog, 'test/functional/api/rpc_fixture.lua'})
       jobid = eval("jobstart(g:args, g:job_opts)")
       neq(0, 'jobid')
-- 
cgit 


From add76592d9a690d12e266da1f788e588bb42b919 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Tue, 11 Apr 2017 02:24:37 +0300
Subject: functests: Test for “string cannot contain newline” set_lines error
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Should make me able to determine whether they are lua bindings that contain
a bug or set_lines.
---
 test/functional/api/buffer_spec.lua | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua
index c3002618b0..2e3b570571 100644
--- a/test/functional/api/buffer_spec.lua
+++ b/test/functional/api/buffer_spec.lua
@@ -10,6 +10,7 @@ local insert = helpers.insert
 local NIL = helpers.NIL
 local meth_pcall = helpers.meth_pcall
 local command = helpers.command
+local bufmeths = helpers.bufmeths
 
 describe('api/buf', function()
   before_each(clear)
@@ -121,6 +122,15 @@ describe('api/buf', function()
     local get_lines, set_lines = curbufmeths.get_lines, curbufmeths.set_lines
     local line_count = curbufmeths.line_count
 
+    it('fails correctly when input is not valid', function()
+      eq(1, curbufmeths.get_number())
+      local err, emsg = pcall(bufmeths.set_lines, 1, 1, 2, false, {'b\na'})
+      eq(false, err)
+      local exp_emsg = 'string cannot contain newlines'
+      -- Expected {filename}:{lnum}: {exp_emsg}
+      eq(': ' .. exp_emsg, emsg:sub(-#exp_emsg - 2))
+    end)
+
     it('has correct line_count when inserting and deleting', function()
       eq(1, line_count())
       set_lines(-1, -1, true, {'line'})
-- 
cgit 


From 45240538742d6276ab25abe0d8b02550e1c68179 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Fri, 21 Apr 2017 14:58:52 +0200
Subject: test: api: Do not truncate errors <1 MB.

---
 test/functional/api/vim_spec.lua | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 8f9f155110..60f30dcfe6 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -412,7 +412,7 @@ describe('api', function()
       eq(5, meths.get_var('avar'))
     end)
 
-    it('throws error on malformated arguments', function()
+    it('throws error on malformed arguments', function()
       local req = {
         {'nvim_set_var', {'avar', 1}},
         {'nvim_set_var'},
@@ -452,6 +452,13 @@ describe('api', function()
     ok(err:match('Invalid option name') ~= nil)
   end)
 
+  it('does not truncate error message <1 MB #5984', function()
+    local very_long_name = 'A'..('x'):rep(10000)..'Z'
+    local status, err = pcall(nvim, 'get_option', very_long_name)
+    eq(false, status)
+    eq(very_long_name, err:match('Ax+Z?'))
+  end)
+
   it("doesn't leak memory on incorrect argument types", function()
     local status, err = pcall(nvim, 'set_current_dir',{'not', 'a', 'dir'})
     eq(false, status)
-- 
cgit 


From 086c354a0aad2769042dc91bf5bad021109f56e4 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 23 Apr 2017 22:30:08 +0200
Subject: api: Do not translate error messages.

Also re-word some error messages:
- "Key does not exist: %s"
- "Invalid channel: %<PRIu64>"
- "Request array size must be 4 (request) or 3 (notification)"
- "String cannot contain newlines"

References #6150
---
 test/functional/api/buffer_spec.lua  | 2 +-
 test/functional/api/tabpage_spec.lua | 2 +-
 test/functional/api/vim_spec.lua     | 4 ++--
 test/functional/api/window_spec.lua  | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua
index c3002618b0..9699ea8f85 100644
--- a/test/functional/api/buffer_spec.lua
+++ b/test/functional/api/buffer_spec.lua
@@ -271,7 +271,7 @@ describe('api/buf', function()
       eq(1, funcs.exists('b:lua'))
       curbufmeths.del_var('lua')
       eq(0, funcs.exists('b:lua'))
-      eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curbufmeths.del_var, 'lua'))
+      eq({false, 'Key does not exist: lua'}, meth_pcall(curbufmeths.del_var, 'lua'))
       curbufmeths.set_var('lua', 1)
       command('lockvar b:lua')
       eq({false, 'Key is locked: lua'}, meth_pcall(curbufmeths.del_var, 'lua'))
diff --git a/test/functional/api/tabpage_spec.lua b/test/functional/api/tabpage_spec.lua
index d7ef53a88f..260a91a80c 100644
--- a/test/functional/api/tabpage_spec.lua
+++ b/test/functional/api/tabpage_spec.lua
@@ -34,7 +34,7 @@ describe('api/tabpage', function()
       eq(1, funcs.exists('t:lua'))
       curtabmeths.del_var('lua')
       eq(0, funcs.exists('t:lua'))
-      eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curtabmeths.del_var, 'lua'))
+      eq({false, 'Key does not exist: lua'}, meth_pcall(curtabmeths.del_var, 'lua'))
       curtabmeths.set_var('lua', 1)
       command('lockvar t:lua')
       eq({false, 'Key is locked: lua'}, meth_pcall(curtabmeths.del_var, 'lua'))
diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 60f30dcfe6..5b173f3196 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -119,7 +119,7 @@ describe('api', function()
       eq(1, funcs.exists('g:lua'))
       meths.del_var('lua')
       eq(0, funcs.exists('g:lua'))
-      eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(meths.del_var, 'lua'))
+      eq({false, 'Key does not exist: lua'}, meth_pcall(meths.del_var, 'lua'))
       meths.set_var('lua', 1)
       command('lockvar lua')
       eq({false, 'Key is locked: lua'}, meth_pcall(meths.del_var, 'lua'))
@@ -439,7 +439,7 @@ describe('api', function()
       }
       status, err = pcall(meths.call_atomic, req)
       eq(false, status)
-      ok(err:match('args must be Array') ~= nil)
+      ok(err:match('Args must be Array') ~= nil)
       -- call before was done, but not after
       eq(1, meths.get_var('avar'))
       eq({''}, meths.buf_get_lines(0, 0, -1, true))
diff --git a/test/functional/api/window_spec.lua b/test/functional/api/window_spec.lua
index deffc68994..6882f50a3e 100644
--- a/test/functional/api/window_spec.lua
+++ b/test/functional/api/window_spec.lua
@@ -139,7 +139,7 @@ describe('api/win', function()
       eq(1, funcs.exists('w:lua'))
       curwinmeths.del_var('lua')
       eq(0, funcs.exists('w:lua'))
-      eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curwinmeths.del_var, 'lua'))
+      eq({false, 'Key does not exist: lua'}, meth_pcall(curwinmeths.del_var, 'lua'))
       curwinmeths.set_var('lua', 1)
       command('lockvar w:lua')
       eq({false, 'Key is locked: lua'}, meth_pcall(curwinmeths.del_var, 'lua'))
-- 
cgit 


From 3ea10077534cb1dcb1597ffcf85e601fa0c0e27b Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 13 Mar 2017 15:02:37 +0100
Subject: api: nvim_get_mode()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Asynchronous API functions are served immediately, which means pending
input could change the state of Nvim shortly after an async API function
result is returned.

nvim_get_mode() is different:
  - If RPCs are known to be blocked, it responds immediately (without
    flushing the input/event queue)
  - else it is handled just-in-time before waiting for input, after
    pending input was processed. This makes the result more reliable
    (but not perfect).

Internally this is handled as a special case, but _semantically_ nothing
has changed: API users never know when input flushes, so this internal
special-case doesn't violate that. As far as API users are concerned,
nvim_get_mode() is just another asynchronous API function.

In all cases nvim_get_mode() never blocks for more than the time it
takes to flush the input/event queue (~µs).

Note: This doesn't address #6166; nvim_get_mode() will provoke #6166 if
e.g. `d` is operator-pending.

Closes #6159
---
 test/functional/api/vim_spec.lua | 106 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 105 insertions(+), 1 deletion(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 5b173f3196..d06dd4c487 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -9,6 +9,7 @@ local funcs = helpers.funcs
 local request = helpers.request
 local meth_pcall = helpers.meth_pcall
 local command = helpers.command
+local wait = helpers.wait
 
 describe('api', function()
   before_each(clear)
@@ -221,6 +222,109 @@ describe('api', function()
     end)
   end)
 
+  local function appendfile(fname, text)
+    local file = io.open(fname, 'a')
+    file:write(text)
+    file:flush()
+    file:close()
+  end
+
+  describe('nvim_get_mode', function()
+    it("during normal-mode `g` returns blocking=true", function()
+      nvim("input", "o")                -- add a line
+      eq({mode='i', blocking=false}, nvim("get_mode"))
+      nvim("input", [[<C-\><C-N>]])
+      eq(2, nvim("eval", "line('.')"))
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+
+      nvim("input", "g")
+      eq({mode='n', blocking=true}, nvim("get_mode"))
+
+      nvim("input", "k")                -- complete the operator
+      eq(1, nvim("eval", "line('.')"))  -- verify the completed operator
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+    end)
+
+    it("returns the correct result multiple consecutive times", function()
+      for _ = 1,5 do
+        eq({mode='n', blocking=false}, nvim("get_mode"))
+      end
+      nvim("input", "g")
+      for _ = 1,4 do
+        eq({mode='n', blocking=true}, nvim("get_mode"))
+      end
+      nvim("input", "g")
+      for _ = 1,7 do
+        eq({mode='n', blocking=false}, nvim("get_mode"))
+      end
+    end)
+
+    it("during normal-mode CTRL-W, returns blocking=true", function()
+      nvim("input", "<C-W>")
+      eq({mode='n', blocking=true}, nvim("get_mode"))
+
+      nvim("input", "s")                  -- complete the operator
+      eq(2, nvim("eval", "winnr('$')"))   -- verify the completed operator
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+    end)
+
+    it("during press-enter prompt returns blocking=true", function()
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+      command("echom 'msg1'")
+      command("echom 'msg2'")
+      command("echom 'msg3'")
+      command("echom 'msg4'")
+      command("echom 'msg5'")
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+      nvim("input", ":messages<CR>")
+      eq({mode='r', blocking=true}, nvim("get_mode"))
+    end)
+
+    it("during getchar() returns blocking=false", function()
+      nvim("input", ":let g:test_input = nr2char(getchar())<CR>")
+      -- Events are enabled during getchar(), RPC calls are *not* blocked. #5384
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+      eq(0, nvim("eval", "exists('g:test_input')"))
+      nvim("input", "J")
+      eq("J", nvim("eval", "g:test_input"))
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+    end)
+
+    -- TODO: bug #6247#issuecomment-286403810
+    it("batched with input", function()
+      eq({mode='n', blocking=false}, nvim("get_mode"))
+      command("echom 'msg1'")
+      command("echom 'msg2'")
+      command("echom 'msg3'")
+      command("echom 'msg4'")
+      command("echom 'msg5'")
+
+      local req = {
+        {'nvim_get_mode', {}},
+        {'nvim_input',    {':messages<CR>'}},
+        {'nvim_get_mode', {}},
+        {'nvim_eval',     {'1'}},
+      }
+      eq({{{mode='n', blocking=false},
+          13,
+          {mode='n', blocking=false},  -- TODO: should be blocked=true
+          1},
+        NIL}, meths.call_atomic(req))
+      eq({mode='r', blocking=true}, nvim("get_mode"))
+    end)
+    -- TODO: bug #6166
+    it("during insert-mode map-pending, returns blocking=true #6166", function()
+      command("inoremap xx foo")
+      nvim("input", "ix")
+      eq({mode='i', blocking=true}, nvim("get_mode"))
+    end)
+    -- TODO: bug #6166
+    it("during normal-mode gU, returns blocking=false #6166", function()
+      nvim("input", "gu")
+      eq({mode='no', blocking=false}, nvim("get_mode"))
+    end)
+  end)
+
   describe('nvim_replace_termcodes', function()
     it('escapes K_SPECIAL as K_SPECIAL KS_SPECIAL KE_FILLER', function()
       eq('\128\254X', helpers.nvim('replace_termcodes', '\128', true, true, true))
@@ -459,7 +563,7 @@ describe('api', function()
     eq(very_long_name, err:match('Ax+Z?'))
   end)
 
-  it("doesn't leak memory on incorrect argument types", function()
+  it("does not leak memory on incorrect argument types", function()
     local status, err = pcall(nvim, 'set_current_dir',{'not', 'a', 'dir'})
     eq(false, status)
     ok(err:match(': Wrong type for argument 1, expecting String') ~= nil)
-- 
cgit 


From acfd2a2a29ae852ecc965ca888eb5049400bf39d Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Tue, 14 Mar 2017 00:44:03 +0100
Subject: input.c: Process only safe events before blocking.

Introduce multiqueue_process_priority() to process only events at or
above a certain priority.
---
 test/functional/api/vim_spec.lua | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index d06dd4c487..7c79d8832f 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -9,7 +9,6 @@ local funcs = helpers.funcs
 local request = helpers.request
 local meth_pcall = helpers.meth_pcall
 local command = helpers.command
-local wait = helpers.wait
 
 describe('api', function()
   before_each(clear)
@@ -222,13 +221,6 @@ describe('api', function()
     end)
   end)
 
-  local function appendfile(fname, text)
-    local file = io.open(fname, 'a')
-    file:write(text)
-    file:flush()
-    file:close()
-  end
-
   describe('nvim_get_mode', function()
     it("during normal-mode `g` returns blocking=true", function()
       nvim("input", "o")                -- add a line
-- 
cgit 


From 5b6d598ca8301682d931539ecd6da6a9fabae569 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Mon, 8 May 2017 21:06:23 +0300
Subject: functests: Fix tests

---
 test/functional/api/window_spec.lua | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/window_spec.lua b/test/functional/api/window_spec.lua
index 6882f50a3e..8a65d3f71e 100644
--- a/test/functional/api/window_spec.lua
+++ b/test/functional/api/window_spec.lua
@@ -9,6 +9,7 @@ local funcs = helpers.funcs
 local request = helpers.request
 local NIL = helpers.NIL
 local meth_pcall = helpers.meth_pcall
+local meths = helpers.meths
 local command = helpers.command
 
 -- check if str is visible at the beginning of some line
@@ -55,6 +56,12 @@ describe('api/win', function()
       eq('typing\n  some dumb text', curbuf_contents())
     end)
 
+    it('does not leak memory when using invalid window ID with invalid pos',
+    function()
+      eq({false, 'Invalid window id'},
+         meth_pcall(meths.win_set_cursor, 1, {"b\na"}))
+    end)
+
     it('updates the screen, and also when the window is unfocused', function()
       insert("prologue")
       feed('100o<esc>')
-- 
cgit 


From f424189093ab23fb727a996d317ff19d4d3f0b63 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Tue, 9 May 2017 08:55:04 +0200
Subject: api: execute lua directly from the remote api

---
 test/functional/api/vim_spec.lua | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 282ecbfd87..61ec6ea829 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -81,6 +81,36 @@ describe('api', function()
     end)
   end)
 
+  describe('nvim_execute_lua', function()
+    it('works', function()
+      meths.execute_lua('vim.api.nvim_set_var("test", 3)', {})
+      eq(3, meths.get_var('test'))
+
+      eq(17, meths.execute_lua('a, b = ...\nreturn a + b', {10,7}))
+
+      eq(NIL, meths.execute_lua('function xx(a,b)\nreturn a..b\nend',{}))
+      eq("xy", meths.execute_lua('return xx(...)', {'x','y'}))
+    end)
+
+    it('reports errors', function()
+      eq({false, 'Error loading lua: [string "<nvim>"]:1: '..
+                 "'=' expected near '+'"},
+         meth_pcall(meths.execute_lua, 'a+*b', {}))
+
+      eq({false, 'Error loading lua: [string "<nvim>"]:1: '..
+                 "unexpected symbol near '1'"},
+         meth_pcall(meths.execute_lua, '1+2', {}))
+
+      eq({false, 'Error loading lua: [string "<nvim>"]:1: '..
+                 "unexpected symbol"},
+         meth_pcall(meths.execute_lua, 'aa=bb\0', {}))
+
+      eq({false, 'Error executing lua: [string "<nvim>"]:1: '..
+                 "attempt to call global 'bork' (a nil value)"},
+         meth_pcall(meths.execute_lua, 'bork()', {}))
+    end)
+  end)
+
   describe('nvim_input', function()
     it("VimL error: does NOT fail, updates v:errmsg", function()
       local status, _ = pcall(nvim, "input", ":call bogus_fn()<CR>")
-- 
cgit 


From bdd73fc07ff8bcf9502f9c6a980a278b9e7b8f27 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sat, 20 May 2017 22:20:21 +0200
Subject: api/nvim_replace_termcodes: Document keycodes behavior

---
 test/functional/api/vim_spec.lua | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 61ec6ea829..161682b973 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -368,6 +368,11 @@ describe('api', function()
                                      '<LeftMouse>', true, true, true))
     end)
 
+    it('converts keycodes', function()
+      eq('\nx\27x\rx<x', helpers.nvim('replace_termcodes',
+         '<NL>x<Esc>x<CR>x<lt>x', true, true, true))
+    end)
+
     it('does not crash when transforming an empty string', function()
       -- Actually does not test anything, because current code will use NULL for
       -- an empty string.
-- 
cgit 


From a5a5c83608e6d4455ac40e8786fd16eaf817c608 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Tue, 23 May 2017 00:16:23 +0300
Subject: api/vim: Fix nvim_list_runtimepaths

It used to

1. Always omit last component in runtimepath.
2. Always omit trailing empty item and leave uninitialized memory in place of
   it.
---
 test/functional/api/vim_spec.lua | 40 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 5 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 161682b973..c531d4af46 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -327,11 +327,11 @@ describe('api', function()
         {'nvim_get_mode', {}},
         {'nvim_eval',     {'1'}},
       }
-      eq({{{mode='n', blocking=false},
-          13,
-          {mode='n', blocking=false},  -- TODO: should be blocked=true
-          1},
-        NIL}, meths.call_atomic(req))
+      eq({ { {mode='n', blocking=false},
+             13,
+             {mode='n', blocking=false},  -- TODO: should be blocked=true
+             1 },
+           NIL}, meths.call_atomic(req))
       eq({mode='r', blocking=true}, nvim("get_mode"))
     end)
     -- TODO: bug #6166
@@ -588,6 +588,36 @@ describe('api', function()
     end)
   end)
 
+  describe('list_runtime_paths', function()
+    it('returns nothing with empty &runtimepath', function()
+      meths.set_option('runtimepath', '')
+      eq({}, meths.list_runtime_paths())
+    end)
+    it('returns single runtimepath', function()
+      meths.set_option('runtimepath', 'a')
+      eq({'a'}, meths.list_runtime_paths())
+    end)
+    it('returns two runtimepaths', function()
+      meths.set_option('runtimepath', 'a,b')
+      eq({'a', 'b'}, meths.list_runtime_paths())
+    end)
+    it('returns empty strings when appropriate', function()
+      meths.set_option('runtimepath', 'a,,b')
+      eq({'a', '', 'b'}, meths.list_runtime_paths())
+      meths.set_option('runtimepath', ',a,b')
+      eq({'', 'a', 'b'}, meths.list_runtime_paths())
+      meths.set_option('runtimepath', 'a,b,')
+      eq({'a', 'b', ''}, meths.list_runtime_paths())
+    end)
+    it('truncates too long paths', function()
+      local long_path = ('/a'):rep(8192)
+      meths.set_option('runtimepath', long_path)
+      local paths_list = meths.list_runtime_paths()
+      neq({long_path}, paths_list)
+      eq({long_path:sub(1, #(paths_list[1]))}, paths_list)
+    end)
+  end)
+
   it('can throw exceptions', function()
     local status, err = pcall(nvim, 'get_option', 'invalid-option')
     eq(false, status)
-- 
cgit 


From 45626de63f2b8057c13df0466406c43f04d6a1e6 Mon Sep 17 00:00:00 2001
From: TJ DeVries <timothydvrs1234@gmail.com>
Date: Thu, 25 May 2017 05:41:53 -0500
Subject: get_keymap API (#6236)

* Add api function get keymap

nvim_get_keymap(mode)
nvim_buf_get_keymap(buffer, mode)
---
 test/functional/api/keymap_spec.lua | 246 ++++++++++++++++++++++++++++++++++++
 1 file changed, 246 insertions(+)
 create mode 100644 test/functional/api/keymap_spec.lua

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
new file mode 100644
index 0000000000..833e0d2f3c
--- /dev/null
+++ b/test/functional/api/keymap_spec.lua
@@ -0,0 +1,246 @@
+
+local helpers = require('test.functional.helpers')(after_each)
+local clear = helpers.clear
+local command = helpers.command
+local curbufmeths = helpers.curbufmeths
+local eq = helpers.eq
+local funcs = helpers.funcs
+local meths = helpers.meths
+local source = helpers.source
+
+local function local_copy(t)
+  local copy = {}
+  for k,v in pairs(t) do
+    copy[k] = v
+  end
+  return copy
+end
+
+describe('get_keymap', function()
+  before_each(clear)
+
+  -- Basic mapping and table to be used to describe results
+  local foo_bar_string = 'nnoremap foo bar'
+  local foo_bar_map_table = {
+      lhs='foo',
+      silent=0,
+      rhs='bar',
+      expr=0,
+      sid=0,
+      buffer=0,
+      nowait=0,
+      mode='n',
+      noremap=1,
+    }
+
+  it('returns empty list when no map', function()
+    eq({}, meths.get_keymap('n'))
+  end)
+
+  it('returns list of all applicable mappings', function()
+    command(foo_bar_string)
+    -- Only one mapping available
+    -- 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')
+    )
+
+    -- Add another mapping
+    command('nnoremap foo_longer bar_longer')
+    local foolong_bar_map_table = local_copy(foo_bar_map_table)
+    foolong_bar_map_table['lhs'] = 'foo_longer'
+    foolong_bar_map_table['rhs'] = 'bar_longer'
+
+    eq({foolong_bar_map_table, foo_bar_map_table},
+      meths.get_keymap('n')
+    )
+
+    -- Remove a mapping
+    command('unmap foo_longer')
+    eq({foo_bar_map_table},
+      meths.get_keymap('n')
+    )
+  end)
+
+  it('works for other modes', function()
+    -- Add two mappings, one in insert and one normal
+    -- We'll only check the insert mode one
+    command('nnoremap not_going to_check')
+
+    command('inoremap foo bar')
+    -- The table will be the same except for the mode
+    local insert_table = local_copy(foo_bar_map_table)
+    insert_table['mode'] = 'i'
+
+    eq({insert_table}, meths.get_keymap('i'))
+  end)
+
+  it('considers scope', function()
+    -- change the map slightly
+    command('nnoremap foo_longer bar_longer')
+    local foolong_bar_map_table = local_copy(foo_bar_map_table)
+    foolong_bar_map_table['lhs'] = 'foo_longer'
+    foolong_bar_map_table['rhs'] = 'bar_longer'
+
+    local buffer_table = local_copy(foo_bar_map_table)
+    buffer_table['buffer'] = 1
+
+    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'))
+  end)
+
+  it('considers scope for overlapping maps', function()
+    command('nnoremap foo bar')
+
+    local buffer_table = local_copy(foo_bar_map_table)
+    buffer_table['buffer'] = 1
+
+    command('nnoremap <buffer> foo bar')
+
+    eq({foo_bar_map_table}, meths.get_keymap('n'))
+    eq({buffer_table}, curbufmeths.get_keymap('n'))
+  end)
+
+  it('can retrieve mapping for different buffers', function()
+    local original_buffer = curbufmeths.get_number()
+    -- Place something in each of the buffers to make sure they stick around
+    -- and set hidden so we can leave them
+    command('set hidden')
+    command('new')
+    command('normal! ihello 2')
+    command('new')
+    command('normal! ihello 3')
+
+    local final_buffer = curbufmeths.get_number()
+
+    command('nnoremap <buffer> foo bar')
+    -- Final buffer will have buffer mappings
+    local buffer_table = local_copy(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'))
+
+    command('buffer ' .. original_buffer)
+    eq(original_buffer, curbufmeths.get_number())
+    -- 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'))
+  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 make_new_windows(number_of_windows)
+      if new_windows == nil then
+        return nil
+      end
+
+      for _=1,number_of_windows do
+        command('new')
+      end
+    end
+
+    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)
+    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)
+
+    -- 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')
+
+        local result = curbufmeths.get_keymap(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'}
+  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)
+    global_and_buffer_test(mode_list[mode], 'expr', '<expr>', 1, 1, 0, 0)
+  end
+
+  -- noremap will now be 2 if script was used, which is not the same as maparg()
+  global_and_buffer_test('nmap', 'noremap', '<script>', 2, 2, 0, 0)
+  global_and_buffer_test('nnoremap', 'noremap', '<script>', 2, 2, 1, 1)
+
+  -- buffer will return the buffer ID, which is not the same as maparg()
+  -- Three of these tests won't run
+  global_and_buffer_test('nnoremap', 'buffer', '<buffer>', nil, 3, nil, nil, 2)
+
+  it('returns script numbers for global maps', function()
+    source([[
+      function! s:maparg_test_function() abort
+        return 'testing'
+      endfunction
+
+      nnoremap fizz :call <SID>maparg_test_function()<CR>
+    ]])
+    local sid_result = meths.get_keymap('n')[1]['sid']
+    eq(1, sid_result)
+    eq('testing', meths.call_function('<SNR>' .. sid_result .. '_maparg_test_function', {}))
+  end)
+
+  it('returns script numbers for buffer maps', function()
+    source([[
+      function! s:maparg_test_function() abort
+        return 'testing'
+      endfunction
+
+      nnoremap <buffer> fizz :call <SID>maparg_test_function()<CR>
+    ]])
+    local sid_result = curbufmeths.get_keymap('n')[1]['sid']
+    eq(1, sid_result)
+    eq('testing', meths.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'])
+  end)
+end)
-- 
cgit 


From 6a7593875827374c15484dd4eecd31a88f8c6f77 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Wed, 26 Apr 2017 13:10:21 +0200
Subject: channels: implement sockopen() to connect to socket

Helped-By: oni-link <knil.ino@gmail.com>
---
 test/functional/api/server_requests_spec.lua | 57 ++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 658077b112..b325139d12 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -9,6 +9,8 @@ local nvim_prog, command, funcs = helpers.nvim_prog, helpers.command, helpers.fu
 local source, next_message = helpers.source, helpers.next_message
 local ok = helpers.ok
 local meths = helpers.meths
+local spawn, nvim_argv = helpers.spawn, helpers.nvim_argv
+local set_session = helpers.set_session
 
 describe('server -> client', function()
   local cid
@@ -225,4 +227,59 @@ describe('server -> client', function()
     end)
   end)
 
+  describe('when connecting to another nvim instance', function()
+    local function connect_test(server, mode, address)
+      local serverpid = funcs.getpid()
+      local client = spawn(nvim_argv)
+      set_session(client, true)
+      local clientpid = funcs.getpid()
+      neq(serverpid, clientpid)
+      local id = funcs.sockconnect(mode, address, {rpc=true})
+      ok(id > 0)
+
+      funcs.rpcrequest(id, 'nvim_set_current_line', 'hello')
+      local client_id = funcs.rpcrequest(id, 'nvim_get_api_info')[1]
+
+      set_session(server, true)
+      eq(serverpid, funcs.getpid())
+      eq('hello', meths.get_current_line())
+
+      -- method calls work both ways
+      funcs.rpcrequest(client_id, 'nvim_set_current_line', 'howdy!')
+      eq(id, funcs.rpcrequest(client_id, 'nvim_get_api_info')[1])
+
+      set_session(client, true)
+      eq(clientpid, funcs.getpid())
+      eq('howdy!', meths.get_current_line())
+
+      server:close()
+      client:close()
+    end
+
+    it('over a named pipe', function()
+      local server = spawn(nvim_argv)
+      set_session(server)
+      local address = funcs.serverlist()[1]
+      local first = string.sub(address,1,1)
+      ok(first == '/' or first == '\\')
+      connect_test(server, 'pipe', address)
+    end)
+
+    it('to an ip adress', function()
+      local server = spawn(nvim_argv)
+      set_session(server)
+      local address = funcs.serverstart("127.0.0.1:")
+      eq('127.0.0.1:', string.sub(address,1,10))
+      connect_test(server, 'tcp', address)
+    end)
+
+    it('to a hostname', function()
+      local server = spawn(nvim_argv)
+      set_session(server)
+      local address = funcs.serverstart("localhost:")
+      eq('localhost:', string.sub(address,1,10))
+      connect_test(server, 'tcp', address)
+    end)
+  end)
+
 end)
-- 
cgit 


From 5a151555c8dce70bbf235e7f6d5bd1ced5e7c46c Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 6 May 2017 09:31:36 +0200
Subject: sockets: don't deadlock when connecting to own pipe address

---
 test/functional/api/server_requests_spec.lua | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index b325139d12..cf15062325 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -282,4 +282,20 @@ describe('server -> client', function()
     end)
   end)
 
+  describe('when connecting to its own pipe adress', function()
+    it('it does not deadlock', function()
+      local address = funcs.serverlist()[1]
+      local first = string.sub(address,1,1)
+      ok(first == '/' or first == '\\')
+      local serverpid = funcs.getpid()
+
+      local id = funcs.sockconnect('pipe', address, {rpc=true})
+
+      funcs.rpcrequest(id, 'nvim_set_current_line', 'hello')
+      eq('hello', meths.get_current_line())
+      eq(serverpid, funcs.rpcrequest(id, "nvim_eval", "getpid()"))
+
+      eq(id, funcs.rpcrequest(id, 'nvim_get_api_info')[1])
+    end)
+  end)
 end)
-- 
cgit 


From ca4633bfe4d0f58bd5fb7343d282fafb71f3a3ee Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 2 Jul 2017 00:30:00 +0200
Subject: ci/quickbuild: XXX: disable server_requests test (#6851)

Temporarily disable this test which hangs quickbuild.

From #6905: The hang occurs when calling nvim_set_current_line.

References #6594 5a151555c8dce70bbf235e7f6d5bd1ced5e7c46c
---
 test/functional/api/server_requests_spec.lua | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index cf15062325..6a32f979ea 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -282,8 +282,13 @@ describe('server -> client', function()
     end)
   end)
 
-  describe('when connecting to its own pipe adress', function()
-    it('it does not deadlock', function()
+  describe('connecting to its own pipe address', function()
+    it('does not deadlock', function()
+      if not os.getenv("TRAVIS") and helpers.os_name() == "osx" then
+        -- It does, in fact, deadlock on QuickBuild. #6851
+        pending("deadlocks on QuickBuild", function() end)
+        return
+      end
       local address = funcs.serverlist()[1]
       local first = string.sub(address,1,1)
       ok(first == '/' or first == '\\')
-- 
cgit 


From 4b8bdd953e2b7928af80e8b97118d52f99f0d95a Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 2 Jul 2017 19:21:21 +0300
Subject: functests: Remove local_copy function

---
 test/functional/api/keymap_spec.lua | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index 833e0d2f3c..7d6445f49c 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -1,5 +1,6 @@
-
 local helpers = require('test.functional.helpers')(after_each)
+local global_helpers = require('test.helpers')
+
 local clear = helpers.clear
 local command = helpers.command
 local curbufmeths = helpers.curbufmeths
@@ -8,13 +9,7 @@ local funcs = helpers.funcs
 local meths = helpers.meths
 local source = helpers.source
 
-local function local_copy(t)
-  local copy = {}
-  for k,v in pairs(t) do
-    copy[k] = v
-  end
-  return copy
-end
+local shallowcopy = global_helpers.shallowcopy
 
 describe('get_keymap', function()
   before_each(clear)
@@ -50,7 +45,7 @@ describe('get_keymap', function()
 
     -- Add another mapping
     command('nnoremap foo_longer bar_longer')
-    local foolong_bar_map_table = local_copy(foo_bar_map_table)
+    local foolong_bar_map_table = shallowcopy(foo_bar_map_table)
     foolong_bar_map_table['lhs'] = 'foo_longer'
     foolong_bar_map_table['rhs'] = 'bar_longer'
 
@@ -72,7 +67,7 @@ describe('get_keymap', function()
 
     command('inoremap foo bar')
     -- The table will be the same except for the mode
-    local insert_table = local_copy(foo_bar_map_table)
+    local insert_table = shallowcopy(foo_bar_map_table)
     insert_table['mode'] = 'i'
 
     eq({insert_table}, meths.get_keymap('i'))
@@ -81,11 +76,11 @@ describe('get_keymap', function()
   it('considers scope', function()
     -- change the map slightly
     command('nnoremap foo_longer bar_longer')
-    local foolong_bar_map_table = local_copy(foo_bar_map_table)
+    local foolong_bar_map_table = shallowcopy(foo_bar_map_table)
     foolong_bar_map_table['lhs'] = 'foo_longer'
     foolong_bar_map_table['rhs'] = 'bar_longer'
 
-    local buffer_table = local_copy(foo_bar_map_table)
+    local buffer_table = shallowcopy(foo_bar_map_table)
     buffer_table['buffer'] = 1
 
     command('nnoremap <buffer> foo bar')
@@ -98,7 +93,7 @@ describe('get_keymap', function()
   it('considers scope for overlapping maps', function()
     command('nnoremap foo bar')
 
-    local buffer_table = local_copy(foo_bar_map_table)
+    local buffer_table = shallowcopy(foo_bar_map_table)
     buffer_table['buffer'] = 1
 
     command('nnoremap <buffer> foo bar')
@@ -121,7 +116,7 @@ describe('get_keymap', function()
 
     command('nnoremap <buffer> foo bar')
     -- Final buffer will have buffer mappings
-    local buffer_table = local_copy(foo_bar_map_table)
+    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'))
-- 
cgit 


From a1fee487ba5199ff672a87c5830732c224fa59eb Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 2 Jul 2017 19:28:44 +0300
Subject: functests: Add tests for new behaviour

Apparently it is not working yet.
---
 test/functional/api/keymap_spec.lua | 72 +++++++++++++++++++++++++++++++------
 1 file changed, 62 insertions(+), 10 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index 7d6445f49c..b7858888c4 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -17,16 +17,16 @@ describe('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',
-      silent=0,
-      rhs='bar',
-      expr=0,
-      sid=0,
-      buffer=0,
-      nowait=0,
-      mode='n',
-      noremap=1,
-    }
+    lhs='foo',
+    silent=0,
+    rhs='bar',
+    expr=0,
+    sid=0,
+    buffer=0,
+    nowait=0,
+    mode='n',
+    noremap=1,
+  }
 
   it('returns empty list when no map', function()
     eq({}, meths.get_keymap('n'))
@@ -238,4 +238,56 @@ describe('get_keymap', function()
     eq('<F12>', meths.get_keymap('n')[1]['lhs'])
     eq(':let g:maparg_test_var = 1<CR>', meths.get_keymap('n')[1]['rhs'])
   end)
+
+  it('works correctly despite various &cpo settings', function()
+    local cpo_table = {
+      silent=0,
+      expr=0,
+      sid=0,
+      buffer=0,
+      nowait=0,
+      noremap=1,
+    }
+    local function cpomap(lhs, rhs, mode)
+      local ret = shallowcopy(cpo_table)
+      ret.lhs = lhs
+      ret.rhs = rhs
+      ret.mode = mode
+      return ret
+    end
+
+    command('set cpo-=< cpo+=B')
+    command('nnoremap \\<C-a> \\<C-b>')
+    command('nnoremap <special> \\<C-c> \\<C-d>')
+
+    command('set cpo+=B<')
+    command('xnoremap \\<C-a> \\<C-b>')
+    command('xnoremap <special> \\<C-c> \\<C-d>')
+
+    command('set cpo-=B<')
+    command('snoremap \\<C-a> \\<C-b>')
+    command('snoremap <special> \\<C-c> \\<C-d>')
+
+    command('set cpo-=B cpo+=<')
+    command('onoremap \\<C-a> \\<C-b>')
+    command('onoremap <special> \\<C-c> \\<C-d>')
+
+    for _, cmd in ipairs({
+      'set cpo-=B cpo+=<',
+      'set cpo-=B<',
+      'set cpo+=B<',
+      'set cpo-=< cpo+=B',
+    }) do
+      command(cmd)
+      eq({cpomap('\\<C-C>', '\\<C-D>', 'n'), cpomap('\\<C-A>', '\\<C-B>', 'n')},
+         meths.get_keymap('n'))
+      -- FIXME
+      -- eq({cpomap('\\<C-C>', '\\<C-D>', 'x'), cpomap('\\<LT>C-A>', '\\<LT>C-B>', 'x')},
+         -- meths.get_keymap('x'))
+      -- eq({cpomap('<LT>C-C>', '<LT>C-D>', 's'), cpomap('<LT>C-A>', '<LT>C-B>', 's')},
+         -- meths.get_keymap('x'))
+      -- eq({cpomap('<LT>C-C>', '<LT>C-D>', 'o'), cpomap('<LT>C-A>', '<LT>C-B>', 'o')},
+         -- meths.get_keymap('x'))
+    end
+  end)
 end)
-- 
cgit 


From 24f0056ca5cb392f1e1bf38d648a6037acf1f1ef Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 2 Jul 2017 19:37:21 +0300
Subject: message: Add support for replacing `<` to str2special

---
 test/functional/api/keymap_spec.lua | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index b7858888c4..fc3ab2d179 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -281,13 +281,12 @@ describe('get_keymap', function()
       command(cmd)
       eq({cpomap('\\<C-C>', '\\<C-D>', 'n'), cpomap('\\<C-A>', '\\<C-B>', 'n')},
          meths.get_keymap('n'))
-      -- FIXME
-      -- eq({cpomap('\\<C-C>', '\\<C-D>', 'x'), cpomap('\\<LT>C-A>', '\\<LT>C-B>', 'x')},
-         -- meths.get_keymap('x'))
-      -- eq({cpomap('<LT>C-C>', '<LT>C-D>', 's'), cpomap('<LT>C-A>', '<LT>C-B>', 's')},
-         -- meths.get_keymap('x'))
-      -- eq({cpomap('<LT>C-C>', '<LT>C-D>', 'o'), cpomap('<LT>C-A>', '<LT>C-B>', 'o')},
-         -- meths.get_keymap('x'))
+      eq({cpomap('\\<C-C>', '\\<C-D>', 'x'), cpomap('\\<lt>C-a>', '\\<lt>C-b>', 'x')},
+         meths.get_keymap('x'))
+      eq({cpomap('<lt>C-c>', '<lt>C-d>', 's'), cpomap('<lt>C-a>', '<lt>C-b>', 's')},
+         meths.get_keymap('s'))
+      eq({cpomap('<lt>C-c>', '<lt>C-d>', 'o'), cpomap('<lt>C-a>', '<lt>C-b>', 'o')},
+         meths.get_keymap('o'))
     end
   end)
 end)
-- 
cgit 


From 5fe5d712aae512c62083754bc364030848d67987 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 2 Jul 2017 19:49:40 +0300
Subject: functests: Use more extensive testing

Fixes #6937
---
 test/functional/api/keymap_spec.lua | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index fc3ab2d179..f1c4d7bdf3 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -257,20 +257,20 @@ describe('get_keymap', function()
     end
 
     command('set cpo-=< cpo+=B')
-    command('nnoremap \\<C-a> \\<C-b>')
-    command('nnoremap <special> \\<C-c> \\<C-d>')
+    command('nnoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
+    command('nnoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
     command('set cpo+=B<')
-    command('xnoremap \\<C-a> \\<C-b>')
-    command('xnoremap <special> \\<C-c> \\<C-d>')
+    command('xnoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
+    command('xnoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
     command('set cpo-=B<')
-    command('snoremap \\<C-a> \\<C-b>')
-    command('snoremap <special> \\<C-c> \\<C-d>')
+    command('snoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
+    command('snoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
     command('set cpo-=B cpo+=<')
-    command('onoremap \\<C-a> \\<C-b>')
-    command('onoremap <special> \\<C-c> \\<C-d>')
+    command('onoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
+    command('onoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
     for _, cmd in ipairs({
       'set cpo-=B cpo+=<',
@@ -279,13 +279,17 @@ describe('get_keymap', function()
       'set cpo-=< cpo+=B',
     }) do
       command(cmd)
-      eq({cpomap('\\<C-C>', '\\<C-D>', 'n'), cpomap('\\<C-A>', '\\<C-B>', 'n')},
+      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')},
          meths.get_keymap('n'))
-      eq({cpomap('\\<C-C>', '\\<C-D>', 'x'), cpomap('\\<lt>C-a>', '\\<lt>C-b>', 'x')},
+      eq({cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'x'),
+          cpomap('\\<lt>C-a><lt>C-a><lt>LT>C-a>\\', '\\<lt>C-b><lt>C-b><lt>LT>C-b>\\', 'x')},
          meths.get_keymap('x'))
-      eq({cpomap('<lt>C-c>', '<lt>C-d>', 's'), cpomap('<lt>C-a>', '<lt>C-b>', 's')},
+      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')},
          meths.get_keymap('s'))
-      eq({cpomap('<lt>C-c>', '<lt>C-d>', 'o'), cpomap('<lt>C-a>', '<lt>C-b>', 'o')},
+      eq({cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 'o'),
+          cpomap('<lt>C-a><lt>C-a><lt>LT>C-a> ', '<lt>C-b><lt>C-b><lt>LT>C-b>', 'o')},
          meths.get_keymap('o'))
     end
   end)
-- 
cgit 


From d5916a823a37a1c0fb1d3d2f52db7cad4107b924 Mon Sep 17 00:00:00 2001
From: ZyX <kp-pav@yandex.ru>
Date: Sun, 2 Jul 2017 20:08:00 +0300
Subject: functests: Test how spaces appear in get_keymap output

---
 test/functional/api/keymap_spec.lua | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index f1c4d7bdf3..aa556b563d 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -293,4 +293,20 @@ describe('get_keymap', function()
          meths.get_keymap('o'))
     end
   end)
+
+  it('always uses space for space and bar for bar', function()
+    local space_table = {
+      lhs='|   |',
+      rhs='|    |',
+      mode='n',
+      silent=0,
+      expr=0,
+      sid=0,
+      buffer=0,
+      nowait=0,
+      noremap=1,
+    }
+    command('nnoremap \\|<Char-0x20><Char-32><Space><Bar> \\|<Char-0x20><Char-32><Space> <Bar>')
+    eq({space_table}, meths.get_keymap('n'))
+  end)
 end)
-- 
cgit 


From 0ea7e45bc1d1881f505da2b77e0b3e4eb56f12fe Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 2 Jul 2017 13:21:38 +0200
Subject: 'cpoptions': remove "<" flag; ignore <special>

Closes #6937 "nvim_get_keymap output is unreliable"
---
 test/functional/api/keymap_spec.lua | 18 ++++++++----------
 test/functional/api/vim_spec.lua    | 13 +++++++++----
 2 files changed, 17 insertions(+), 14 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/keymap_spec.lua b/test/functional/api/keymap_spec.lua
index aa556b563d..3a10f9c60f 100644
--- a/test/functional/api/keymap_spec.lua
+++ b/test/functional/api/keymap_spec.lua
@@ -256,40 +256,38 @@ describe('get_keymap', function()
       return ret
     end
 
-    command('set cpo-=< cpo+=B')
+    command('set cpo+=B')
     command('nnoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
     command('nnoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
-    command('set cpo+=B<')
+    command('set cpo+=B')
     command('xnoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
     command('xnoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
-    command('set cpo-=B<')
+    command('set cpo-=B')
     command('snoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
     command('snoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
-    command('set cpo-=B cpo+=<')
+    command('set cpo-=B')
     command('onoremap \\<C-a><C-a><LT>C-a>\\  \\<C-b><C-b><LT>C-b>\\')
     command('onoremap <special> \\<C-c><C-c><LT>C-c>\\  \\<C-d><C-d><LT>C-d>\\')
 
     for _, cmd in ipairs({
-      'set cpo-=B cpo+=<',
-      'set cpo-=B<',
-      'set cpo+=B<',
-      'set cpo-=< cpo+=B',
+      'set cpo-=B',
+      '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')},
          meths.get_keymap('n'))
       eq({cpomap('\\<C-C><C-C><lt>C-c>\\', '\\<C-D><C-D><lt>C-d>\\', 'x'),
-          cpomap('\\<lt>C-a><lt>C-a><lt>LT>C-a>\\', '\\<lt>C-b><lt>C-b><lt>LT>C-b>\\', 'x')},
+          cpomap('\\<C-A><C-A><lt>C-a>\\', '\\<C-B><C-B><lt>C-b>\\', 'x')},
          meths.get_keymap('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')},
          meths.get_keymap('s'))
       eq({cpomap('<lt>C-c><C-C><lt>C-c> ', '<lt>C-d><C-D><lt>C-d>', 'o'),
-          cpomap('<lt>C-a><lt>C-a><lt>LT>C-a> ', '<lt>C-b><lt>C-b><lt>LT>C-b>', 'o')},
+          cpomap('<lt>C-a><C-A><lt>C-a> ', '<lt>C-b><C-B><lt>C-b>', 'o')},
          meths.get_keymap('o'))
     end
   end)
diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index c531d4af46..e59b5d712d 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -373,6 +373,11 @@ describe('api', function()
          '<NL>x<Esc>x<CR>x<lt>x', true, true, true))
     end)
 
+    it('does not convert keycodes if special=false', function()
+      eq('<NL>x<Esc>x<CR>x<lt>x', helpers.nvim('replace_termcodes',
+         '<NL>x<Esc>x<CR>x<lt>x', true, true, false))
+    end)
+
     it('does not crash when transforming an empty string', function()
       -- Actually does not test anything, because current code will use NULL for
       -- an empty string.
@@ -391,13 +396,13 @@ describe('api', function()
         -- notice the special char(…) \xe2\80\xa6
         nvim('feedkeys', ':let x1="…"\n', '', true)
 
-        -- Both replace_termcodes and feedkeys escape \x80
+        -- Both nvim_replace_termcodes and nvim_feedkeys escape \x80
         local inp = helpers.nvim('replace_termcodes', ':let x2="…"<CR>', true, true, true)
-        nvim('feedkeys', inp, '', true)
+        nvim('feedkeys', inp, '', true)   -- escape_csi=true
 
-        -- Disabling CSI escaping in feedkeys
+        -- nvim_feedkeys with CSI escaping disabled
         inp = helpers.nvim('replace_termcodes', ':let x3="…"<CR>', true, true, true)
-        nvim('feedkeys', inp, '', false)
+        nvim('feedkeys', inp, '', false)  -- escape_csi=false
 
         helpers.stop()
       end
-- 
cgit 


From af993da4351d579aa24de08d806c8c1b90813106 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Thu, 27 Jul 2017 01:08:50 +0200
Subject: rpc: close channel if stream was closed

f_jobstop()/f_rpcstop() .. process_stop() .. process_close_in(proc)
closes the write-stream of a RPC channel. But there might be
a pending RPC notification on the queue, which may get processed just
before the channel is closed.

To handle that case, check the Stream.closed in
channel.c:receive_msgpack().

Before this change, the above scenario could trigger
this assert(!stream->closed) in wstream_write():

    0x00007f96e1cd3428 in __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:54
    0x00007f96e1cd502a in __GI_abort () at abort.c:89
    0x00007f96e1ccbbd7 in __assert_fail_base (fmt=<optimized out>, assertion=assertion@entry=0x768f9b "!stream->closed",
    file=file@entry=0x768f70 "../src/nvim/event/wstream.c", line=line@entry=77,
    function=function@entry=0x768fb0 <__PRETTY_FUNCTION__.13735> "wstream_write") at assert.c:92
    0x00007f96e1ccbc82 in __GI___assert_fail (assertion=0x768f9b "!stream->closed", file=0x768f70 "../src/nvim/event/wstream.c", line=77,
    function=0x768fb0 <__PRETTY_FUNCTION__.13735> "wstream_write") at assert.c:101
    0x00000000004d2c1f in wstream_write (stream=0x7f96e0a35078, buffer=0x7f96e09f9b40) at ../src/nvim/event/wstream.c:77
    0x00000000005857b2 in channel_write (channel=0x7f96e0ae5800, buffer=0x7f96e09f9b40) at ../src/nvim/msgpack_rpc/channel.c:551
    0x000000000058567d in on_request_event (argv=0x7ffed792efa0) at ../src/nvim/msgpack_rpc/channel.c:523
    0x00000000005854c8 in handle_request (channel=0x7f96e0ae5800, request=0x7ffed792f1b8) at ../src/nvim/msgpack_rpc/channel.c:503
    0x00000000005850cb in parse_msgpack (channel=0x7f96e0ae5800) at ../src/nvim/msgpack_rpc/channel.c:423
    0x0000000000584f90 in receive_msgpack (stream=0x7f96e0a35218, rbuf=0x7f96e0d1d4c0, c=22, data=0x7f96e0ae5800, eof=false)
    at ../src/nvim/msgpack_rpc/channel.c:389
    0x00000000004d0b20 in read_event (argv=0x7ffed792f4a8) at ../src/nvim/event/rstream.c:190
    0x00000000004ce462 in multiqueue_process_events (this=0x7f96e18172d0) at ../src/nvim/event/multiqueue.c:150
    0x000000000059b630 in nv_event (cap=0x7ffed792f620) at ../src/nvim/normal.c:7908
    0x000000000058be69 in normal_execute (state=0x7ffed792f580, key=-25341) at ../src/nvim/normal.c:1137
    0x0000000000652463 in state_enter (s=0x7ffed792f580) at ../src/nvim/state.c:61
    0x000000000058a1fe in normal_enter (cmdwin=false, noexmode=false) at ../src/nvim/normal.c:467
    0x00000000005500c2 in main (argc=2, argv=0x7ffed792f8d8) at ../src/nvim/main.c:554

Alternative approach suggested by bfredl is to use close_cb of the
process. My unsuccessful attempt is below. (It seems close_cb is queued
too late, which is the similar problem addressed by this commit):

    commit 75fc12c6ab15711bdb7b18c6d42ec9d157f5145e
    Author: Justin M. Keyes <justinkz@gmail.com>
    Date:   Fri Aug 18 01:30:41 2017 +0200

        rpc: use Stream's close_cb instead of explicit check in receive_msgpack()

    diff --git a/src/nvim/event/process.c b/src/nvim/event/process.c
    index 8371d3cd482e..e52da23cdc40 100644
    --- a/src/nvim/event/process.c
    +++ b/src/nvim/event/process.c
    @@ -416,6 +416,10 @@ static void on_process_exit(Process *proc)
     static void on_process_stream_close(Stream *stream, void *data)
     {
       Process *proc = data;
    +  ILOG("on_process_stream_close");
    +  if (proc->stream_close_cb != NULL) {
    +    proc->stream_close_cb(stream, proc->stream_close_data);
    +  }
       decref(proc);
     }

    diff --git a/src/nvim/event/process.h b/src/nvim/event/process.h
    index 5c00e8e7ecd5..34a8d54f6f8c 100644
    --- a/src/nvim/event/process.h
    +++ b/src/nvim/event/process.h
    @@ -26,6 +26,11 @@ struct process {
       Stream *in, *out, *err;
       process_exit_cb cb;
       internal_process_cb internal_exit_cb, internal_close_cb;
    +
    +  // Called when any of the process streams (in/out/err) closes.
    +  stream_close_cb stream_close_cb;
    +  void *stream_close_data;
    +
       bool closed, detach;
       MultiQueue *events;
     };
    @@ -50,6 +55,8 @@ static inline Process process_init(Loop *loop, ProcessType type, void *data)
         .closed = false,
         .internal_close_cb = NULL,
         .internal_exit_cb = NULL,
    +    .stream_close_cb = NULL,
    +    .stream_close_data = NULL,
         .detach = false
       };
     }
    diff --git a/src/nvim/event/stream.c b/src/nvim/event/stream.c
    index 7c865bfe1e8c..c8720d1e45d9 100644
    --- a/src/nvim/event/stream.c
    +++ b/src/nvim/event/stream.c
    @@ -95,7 +95,11 @@ void stream_close(Stream *stream, stream_close_cb on_stream_close, void *data)
     void stream_close_handle(Stream *stream)
       FUNC_ATTR_NONNULL_ALL
     {
    +  ILOG("stream=%d", stream);
    +  // LOG_CALLSTACK();
       if (stream->uvstream) {
    +    // problem:  this schedules on the queue, but channel.c:receive_msgpack may
    +    // be processed before close_cb is called by libuv.
         uv_close((uv_handle_t *)stream->uvstream, close_cb);
       } else {
         uv_close((uv_handle_t *)&stream->uv.idle, close_cb);
    @@ -105,6 +109,7 @@ void stream_close_handle(Stream *stream)
     static void close_cb(uv_handle_t *handle)
     {
       Stream *stream = handle->data;
    +  ILOG(">>>>>>>>>>>>>>>>>>>>>>> stream=%p stream->internal_close_cb=%p", stream, stream->internal_close_cb);
       if (stream->buffer) {
         rbuffer_free(stream->buffer);
       }
    diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
    index 782eabe04e4a..dc2b794e366a 100644
    --- a/src/nvim/msgpack_rpc/channel.c
    +++ b/src/nvim/msgpack_rpc/channel.c
    @@ -128,6 +128,8 @@ uint64_t channel_from_process(Process *proc, uint64_t id, char *source)
                                           source);
       incref(channel);  // process channels are only closed by the exit_cb
       channel->data.proc = proc;
    +  channel->data.proc->stream_close_cb = close_cb2;
    +  channel->data.proc->stream_close_data = channel;

       wstream_init(proc->in, 0);
       rstream_init(proc->out, 0);
    @@ -387,17 +389,6 @@ static void receive_msgpack(Stream *stream, RBuffer *rbuf, size_t c,
         goto end;
       }

    -  if ((chan_wstream(channel) != NULL && chan_wstream(channel)->closed)
    -      || (chan_rstream(channel) != NULL && chan_rstream(channel)->closed)) {
    -    char buf[256];
    -    snprintf(buf, sizeof(buf),
    -             "ch %" PRIu64 ": stream closed unexpectedly. "
    -             "closing channel",
    -             channel->id);
    -    call_set_error(channel, buf, WARN_LOG_LEVEL);
    -    goto end;
    -  }
    -
       size_t count = rbuffer_size(rbuf);
       DLOG("ch %" PRIu64 ": parsing %u bytes from msgpack Stream: %p",
            channel->id, count, stream);
    @@ -571,23 +562,6 @@ static Stream *chan_wstream(Channel *chan)
       abort();
     }

    -/// Returns the Stream that a Channel reads from.
    -static Stream *chan_rstream(Channel *chan)
    -{
    -  switch (chan->type) {
    -    case kChannelTypeSocket:
    -      return &chan->data.stream;
    -    case kChannelTypeProc:
    -      return chan->data.proc->out;
    -    case kChannelTypeStdio:
    -      return &chan->data.std.in;
    -    case kChannelTypeInternal:
    -      return NULL;
    -  }
    -  abort();
    -}
    -
    -
     static bool channel_write(Channel *channel, WBuffer *buffer)
     {
       bool success = false;
    @@ -799,6 +773,12 @@ static void close_cb(Stream *stream, void *data)
       decref(data);
     }

    +static void close_cb2(Stream *stream, void *data)
    +{
    +  ILOG("close_cb2");
    +  close_channel(data);
    +}
    +
     /// @param source description of source function, rplugin name, TCP addr, etc
     static Channel *register_channel(ChannelType type, uint64_t id,
                                      MultiQueue *events, char *source)
---
 test/functional/api/server_requests_spec.lua | 30 +++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 6a32f979ea..9f245d913b 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -20,6 +20,22 @@ describe('server -> client', function()
     cid = nvim('get_api_info')[1]
   end)
 
+  it('handles unexpected closed stream while preparing RPC response', function()
+    source([[
+      let g:_nvim_args = [v:progpath, '--embed', '-n', '-u', 'NONE', '-i', 'NONE', ]
+      let ch1 = jobstart(g:_nvim_args, {'rpc': v:true})
+      let child1_ch = rpcrequest(ch1, "nvim_get_api_info")[0]
+      call rpcnotify(ch1, 'nvim_eval', 'rpcrequest('.child1_ch.', "nvim_get_api_info")')
+
+      let ch2 = jobstart(g:_nvim_args, {'rpc': v:true})
+      let child2_ch = rpcrequest(ch2, "nvim_get_api_info")[0]
+      call rpcnotify(ch2, 'nvim_eval', 'rpcrequest('.child2_ch.', "nvim_get_api_info")')
+
+      call jobstop(ch1)
+    ]])
+    eq(2, eval("1+1"))  -- Still alive?
+  end)
+
   describe('simple call', function()
     it('works', function()
       local function on_setup()
@@ -141,7 +157,7 @@ describe('server -> client', function()
     end)
   end)
 
-  describe('when the client is a recursive vim instance', function()
+  describe('recursive (child) nvim client', function()
     if os.getenv("TRAVIS") and helpers.os_name() == "osx" then
       -- XXX: Hangs Travis macOS since e9061117a5b8f195c3f26a5cb94e18ddd7752d86.
       pending("[Hangs on Travis macOS. #5002]", function() end)
@@ -155,7 +171,7 @@ describe('server -> client', function()
 
     after_each(function() command('call rpcstop(vim)') end)
 
-    it('can send/recieve notifications and make requests', function()
+    it('can send/receive notifications and make requests', function()
       nvim('command', "call rpcnotify(vim, 'vim_set_current_line', 'SOME TEXT')")
 
       -- Wait for the notification to complete.
@@ -188,7 +204,7 @@ describe('server -> client', function()
     end)
   end)
 
-  describe('when using jobstart', function()
+  describe('jobstart()', function()
     local jobid
     before_each(function()
       local channel = nvim('get_api_info')[1]
@@ -227,7 +243,7 @@ describe('server -> client', function()
     end)
   end)
 
-  describe('when connecting to another nvim instance', function()
+  describe('connecting to another (peer) nvim', function()
     local function connect_test(server, mode, address)
       local serverpid = funcs.getpid()
       local client = spawn(nvim_argv)
@@ -256,7 +272,7 @@ describe('server -> client', function()
       client:close()
     end
 
-    it('over a named pipe', function()
+    it('via named pipe', function()
       local server = spawn(nvim_argv)
       set_session(server)
       local address = funcs.serverlist()[1]
@@ -265,7 +281,7 @@ describe('server -> client', function()
       connect_test(server, 'pipe', address)
     end)
 
-    it('to an ip adress', function()
+    it('via ip address', function()
       local server = spawn(nvim_argv)
       set_session(server)
       local address = funcs.serverstart("127.0.0.1:")
@@ -273,7 +289,7 @@ describe('server -> client', function()
       connect_test(server, 'tcp', address)
     end)
 
-    it('to a hostname', function()
+    it('via hostname', function()
       local server = spawn(nvim_argv)
       set_session(server)
       local address = funcs.serverstart("localhost:")
-- 
cgit 


From 541dde36e3302314e2646415dbfd2b79a6c2a1fc Mon Sep 17 00:00:00 2001
From: Matthew Malcomson <hardenedapple@gmail.com>
Date: Sat, 2 Sep 2017 14:12:32 +0100
Subject: eventloop: K_EVENT should not finish operator

normal_finish_command() and normal_prepare() assume that any pending
operator needs to be finished after any subsequent key.

Set `finish_op = false` in nv_event() to indicate that the pending
operator shouldn't be finished in normal_execute().

This is how nv_visual() indicates that 'v' or 'V' in operator-pending
mode should not finish the current pending operator.

fixes #5398
fixes #6166 (partially; mappings are still interrupted)
---
 test/functional/api/vim_spec.lua | 62 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 59 insertions(+), 3 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index e59b5d712d..5566c6d8e4 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -329,24 +329,80 @@ describe('api', function()
       }
       eq({ { {mode='n', blocking=false},
              13,
-             {mode='n', blocking=false},  -- TODO: should be blocked=true
+             {mode='n', blocking=false},  -- TODO: should be blocked=true ?
              1 },
            NIL}, meths.call_atomic(req))
       eq({mode='r', blocking=true}, nvim("get_mode"))
     end)
-    -- TODO: bug #6166
     it("during insert-mode map-pending, returns blocking=true #6166", function()
       command("inoremap xx foo")
       nvim("input", "ix")
       eq({mode='i', blocking=true}, nvim("get_mode"))
     end)
-    -- TODO: bug #6166
     it("during normal-mode gU, returns blocking=false #6166", function()
       nvim("input", "gu")
       eq({mode='no', blocking=false}, nvim("get_mode"))
     end)
   end)
 
+  describe('RPC (K_EVENT) #6166', function()
+    it('does not complete/interrupt normal-mode operator', function()
+      helpers.insert([[
+        FIRST LINE
+        SECOND LINE]])
+      nvim('input', 'gg')
+      nvim('input', 'gu')
+      -- Make any non-async RPC request.
+      nvim('get_current_buf')
+      -- Buffer should not change.
+      helpers.expect([[
+        FIRST LINE
+        SECOND LINE]])
+      -- Now send input to complete the operator.
+      nvim("input", "j")
+      helpers.expect([[
+      first line
+      second line]])
+    end)
+    -- TODO: bug #6166
+    pending('does not complete/interrupt normal-mode mapping', function()
+      command("nnoremap dd :let g:foo='it worked...'<CR>")
+      helpers.insert([[
+        FIRST LINE
+        SECOND LINE]])
+      nvim('input', 'gg')
+      nvim('input', 'd')
+      helpers.expect([[
+        FIRST LINE
+        SECOND LINE]])
+      -- Make any non-async RPC request. (expect() does RPC, but be explicit)
+      nvim('get_current_buf')
+      -- Send input to complete the mapping.
+      nvim('input', 'd')
+      helpers.expect([[
+        FIRST LINE
+        SECOND LINE]])
+      eq('it worked...', eval('g:foo'))
+    end)
+    it('does not complete/interrupt insert-mode mapping', function()
+      command("inoremap xx foo")
+      helpers.insert([[
+        FIRST LINE
+        SECOND LINE]])
+      nvim('input', 'ix')
+      helpers.expect([[
+        FIRST LINE
+        SECOND LINxE]])
+      -- Make any non-async RPC request. (expect() does RPC, but be explicit)
+      nvim('get_current_buf')
+      -- Send input to complete the mapping.
+      nvim('input', 'x')
+      helpers.expect([[
+        FIRST LINE
+        SECOND LINxxE]])  -- TODO: should be "SECOND LINfooE" #6166
+    end)
+  end)
+
   describe('nvim_replace_termcodes', function()
     it('escapes K_SPECIAL as K_SPECIAL KS_SPECIAL KE_FILLER', function()
       eq('\128\254X', helpers.nvim('replace_termcodes', '\128', true, true, true))
-- 
cgit 


From 3922237b1442deed48d1be32a7967e9eb6a19151 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 4 Sep 2017 08:46:10 +0200
Subject: test: lint

---
 test/functional/api/vim_spec.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 5566c6d8e4..252a380378 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -382,7 +382,7 @@ describe('api', function()
       helpers.expect([[
         FIRST LINE
         SECOND LINE]])
-      eq('it worked...', eval('g:foo'))
+      eq('it worked...', helpers.eval('g:foo'))
     end)
     it('does not complete/interrupt insert-mode mapping', function()
       command("inoremap xx foo")
-- 
cgit 


From ce852bab04c63262ce8545c01a4ff4fc827148a1 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 4 Sep 2017 22:45:14 +0200
Subject: eventloop: K_EVENT does not finish mapping

The "mapping" tests added in 541dde36e330 were flawed:
- Unlike op-pending mode, RPCs are _blocked_ during map-pending. So
  a synchronous RPC like nvim_get_current_buf() waits until
  'timeoutlen', then the mapping is canceled.
- helpers.expect() also performs a blocking RPC, so again that must not
  intervene the two nvim_input() calls.

closes #6166
---
 test/functional/api/vim_spec.lua | 34 ++++++++++++++--------------------
 1 file changed, 14 insertions(+), 20 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index 252a380378..a4b643589a 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -346,37 +346,33 @@ describe('api', function()
   end)
 
   describe('RPC (K_EVENT) #6166', function()
-    it('does not complete/interrupt normal-mode operator', function()
+    it('does not complete ("interrupt") normal-mode operator-pending', function()
       helpers.insert([[
         FIRST LINE
         SECOND LINE]])
       nvim('input', 'gg')
       nvim('input', 'gu')
-      -- Make any non-async RPC request.
+      -- Make any RPC request (can be non-async: op-pending does not block).
       nvim('get_current_buf')
       -- Buffer should not change.
       helpers.expect([[
         FIRST LINE
         SECOND LINE]])
       -- Now send input to complete the operator.
-      nvim("input", "j")
+      nvim('input', 'j')
       helpers.expect([[
-      first line
-      second line]])
+        first line
+        second line]])
     end)
-    -- TODO: bug #6166
-    pending('does not complete/interrupt normal-mode mapping', function()
+    it('does not complete ("interrupt") normal-mode map-pending', function()
       command("nnoremap dd :let g:foo='it worked...'<CR>")
       helpers.insert([[
         FIRST LINE
         SECOND LINE]])
       nvim('input', 'gg')
       nvim('input', 'd')
-      helpers.expect([[
-        FIRST LINE
-        SECOND LINE]])
-      -- Make any non-async RPC request. (expect() does RPC, but be explicit)
-      nvim('get_current_buf')
+      -- Make any RPC request (must be async, because map-pending blocks).
+      nvim('get_api_info')
       -- Send input to complete the mapping.
       nvim('input', 'd')
       helpers.expect([[
@@ -384,22 +380,20 @@ describe('api', function()
         SECOND LINE]])
       eq('it worked...', helpers.eval('g:foo'))
     end)
-    it('does not complete/interrupt insert-mode mapping', function()
-      command("inoremap xx foo")
+    it('does not complete ("interrupt") insert-mode map-pending', function()
+      command('inoremap xx foo')
+      command('set timeoutlen=9999')
       helpers.insert([[
         FIRST LINE
         SECOND LINE]])
       nvim('input', 'ix')
-      helpers.expect([[
-        FIRST LINE
-        SECOND LINxE]])
-      -- Make any non-async RPC request. (expect() does RPC, but be explicit)
-      nvim('get_current_buf')
+      -- Make any RPC request (must be async, because map-pending blocks).
+      nvim('get_api_info')
       -- Send input to complete the mapping.
       nvim('input', 'x')
       helpers.expect([[
         FIRST LINE
-        SECOND LINxxE]])  -- TODO: should be "SECOND LINfooE" #6166
+        SECOND LINfooE]])
     end)
   end)
 
-- 
cgit 


From 9d6bac3219a0cc1647b560b0d28b0a3fce9dc96a Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sat, 16 Sep 2017 12:17:59 +0200
Subject: test: more coverage for RPC + op-pending #3732

---
 test/functional/api/vim_spec.lua | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index a4b643589a..b849304d45 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -364,6 +364,24 @@ describe('api', function()
         first line
         second line]])
     end)
+
+    it('does not complete ("interrupt") `d` #3732', function()
+      local screen = Screen.new(20, 4)
+      screen:attach()
+      command('set listchars=eol:$')
+      command('set list')
+      feed('ia<cr>b<cr>c<cr><Esc>kkk')
+      feed('d')
+      -- Make any RPC request (can be non-async: op-pending does not block).
+      nvim('get_current_buf')
+      screen:expect([[
+       ^a$                  |
+       b$                  |
+       c$                  |
+                           |
+      ]])
+    end)
+
     it('does not complete ("interrupt") normal-mode map-pending', function()
       command("nnoremap dd :let g:foo='it worked...'<CR>")
       helpers.insert([[
-- 
cgit 


From ba7277cfb4e2556f246446d06b53f3427f28130f Mon Sep 17 00:00:00 2001
From: Matthieu Coudron <mattator@gmail.com>
Date: Wed, 26 Jul 2017 23:28:26 +0200
Subject: Adds nvim_get_hl_by_name/by_id

...in order to retrieve highlights.

Added test/functional/api/highlight_spec.lua
HL_NORMAL is not really a good name, since it's more like an empty attribute than the normal's one.
If one pays attention, syn_cterm_attr2entry is never called with attr=0 because it's always special cased before.
I suggest in subsequent PRs we remove the ATTR_OFF and just insert an EMPTY ATTR/RESET_ATTR/UNINITIALIZED for id 0.
---
 test/functional/api/highlight_spec.lua | 54 ++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 test/functional/api/highlight_spec.lua

(limited to 'test/functional/api')

diff --git a/test/functional/api/highlight_spec.lua b/test/functional/api/highlight_spec.lua
new file mode 100644
index 0000000000..1aacfaed03
--- /dev/null
+++ b/test/functional/api/highlight_spec.lua
@@ -0,0 +1,54 @@
+
+local helpers = require('test.functional.helpers')(after_each)
+local clear, nvim = helpers.clear, helpers.nvim
+local Screen = require('test.functional.ui.screen')
+local eq, eval = helpers.eq, helpers.eval
+local command = helpers.command
+local ok = helpers.ok
+local meths = helpers.meths
+
+
+describe('highlight api', function()
+
+  before_each(function()
+    clear('--cmd', 'set termguicolors')
+  end)
+
+  it("nvim_get_hl_by_id", function()
+    local expected_hl = { background = Screen.colors.Yellow,
+                          foreground = Screen.colors.Red,
+                          special = Screen.colors.Blue
+                        }
+
+    command('hi NewHighlight guifg=red guibg=yellow guisp=blue')
+
+    local hl_id = eval("hlID('NewHighlight')")
+    eq(expected_hl, nvim("get_hl_by_id", hl_id))
+
+    -- assume there is no hl with 30000
+    local err, emsg = pcall(meths.get_hl_by_id, 30000)
+    eq(false, err)
+    ok(string.find(emsg, 'Invalid highlight id') ~= nil)
+  end)
+
+  it("nvim_get_hl_by_name", function()
+    local expected_hl = { background = Screen.colors.Yellow,
+                          foreground = Screen.colors.Red }
+
+    -- test "Normal" hl defaults
+    eq({}, nvim("get_hl_by_name", 'Normal'))
+
+    command('hi NewHighlight guifg=red guibg=yellow')
+    eq(expected_hl, nvim("get_hl_by_name", 'NewHighlight'))
+
+    command('hi Normal guifg=red guibg=yellow')
+    eq(expected_hl, nvim("get_hl_by_name", 'Normal'))
+    local err, emsg = pcall(meths.get_hl_by_name , 'unknown_highlight')
+    eq(false, err)
+    ok(string.find(emsg, 'Invalid highlight name') ~= nil)
+  end)
+
+
+
+end)
+
-- 
cgit 


From e3a2cca3878f44252eccdc1918cc8854145de860 Mon Sep 17 00:00:00 2001
From: Matthieu Coudron <mattator@gmail.com>
Date: Sun, 27 Aug 2017 00:33:36 +0200
Subject: Increased test coverage for RGB and cterm

---
 test/functional/api/highlight_spec.lua | 42 +++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 18 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/highlight_spec.lua b/test/functional/api/highlight_spec.lua
index 1aacfaed03..a5d3871d13 100644
--- a/test/functional/api/highlight_spec.lua
+++ b/test/functional/api/highlight_spec.lua
@@ -8,47 +8,53 @@ local ok = helpers.ok
 local meths = helpers.meths
 
 
-describe('highlight api', function()
+describe('highlight api',function()
+  local expected_rgb = { background = Screen.colors.Yellow,
+                          foreground = Screen.colors.Red,
+                          special = Screen.colors.Blue,
+                          bold = true,
+                        }
+
+  local expected_cterm = { background = 10,
+                          underline = true,
+                        }
 
   before_each(function()
-    clear('--cmd', 'set termguicolors')
+    clear()
+    command("hi NewHighlight cterm=underline ctermbg=green guifg=red guibg=yellow guisp=blue gui=bold")
   end)
 
   it("nvim_get_hl_by_id", function()
-    local expected_hl = { background = Screen.colors.Yellow,
-                          foreground = Screen.colors.Red,
-                          special = Screen.colors.Blue
-                        }
+    local hl_id = eval("hlID('NewHighlight')")
 
-    command('hi NewHighlight guifg=red guibg=yellow guisp=blue')
+    eq(expected_cterm, nvim("get_hl_by_id", hl_id))
 
-    local hl_id = eval("hlID('NewHighlight')")
-    eq(expected_hl, nvim("get_hl_by_id", hl_id))
+    command('set termguicolors')
+    hl_id = eval("hlID('NewHighlight')")
+    eq(expected_rgb, nvim("get_hl_by_id", hl_id))
 
-    -- assume there is no hl with 30000
+    -- assume there is no hl with id 30000
     local err, emsg = pcall(meths.get_hl_by_id, 30000)
     eq(false, err)
     ok(string.find(emsg, 'Invalid highlight id') ~= nil)
   end)
 
   it("nvim_get_hl_by_name", function()
-    local expected_hl = { background = Screen.colors.Yellow,
+    local expected_normal = { background = Screen.colors.Yellow,
                           foreground = Screen.colors.Red }
 
     -- test "Normal" hl defaults
     eq({}, nvim("get_hl_by_name", 'Normal'))
 
-    command('hi NewHighlight guifg=red guibg=yellow')
-    eq(expected_hl, nvim("get_hl_by_name", 'NewHighlight'))
+    eq(expected_cterm, nvim("get_hl_by_name", 'NewHighlight'))
+    command('set termguicolors')
+    eq(expected_rgb, nvim("get_hl_by_name", 'NewHighlight'))
 
     command('hi Normal guifg=red guibg=yellow')
-    eq(expected_hl, nvim("get_hl_by_name", 'Normal'))
+    eq(expected_normal, nvim("get_hl_by_name", 'Normal'))
+
     local err, emsg = pcall(meths.get_hl_by_name , 'unknown_highlight')
     eq(false, err)
     ok(string.find(emsg, 'Invalid highlight name') ~= nil)
   end)
-
-
-
 end)
-
-- 
cgit 


From 3a006486397d611234abd9b429bce0b44d6b7747 Mon Sep 17 00:00:00 2001
From: Matthieu Coudron <mattator@gmail.com>
Date: Sun, 3 Sep 2017 05:25:57 +0200
Subject: Changed prototypes to accept a boolean "rgb"

---
 test/functional/api/highlight_spec.lua | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/highlight_spec.lua b/test/functional/api/highlight_spec.lua
index a5d3871d13..4082b0daf9 100644
--- a/test/functional/api/highlight_spec.lua
+++ b/test/functional/api/highlight_spec.lua
@@ -27,14 +27,13 @@ describe('highlight api',function()
   it("nvim_get_hl_by_id", function()
     local hl_id = eval("hlID('NewHighlight')")
 
-    eq(expected_cterm, nvim("get_hl_by_id", hl_id))
+    eq(expected_cterm, nvim("get_hl_by_id", hl_id, false))
 
-    command('set termguicolors')
     hl_id = eval("hlID('NewHighlight')")
-    eq(expected_rgb, nvim("get_hl_by_id", hl_id))
+    eq(expected_rgb, nvim("get_hl_by_id", hl_id, true))
 
-    -- assume there is no hl with id 30000
-    local err, emsg = pcall(meths.get_hl_by_id, 30000)
+    -- assume there is no hl with id = 30000
+    local err, emsg = pcall(meths.get_hl_by_id, 30000, false)
     eq(false, err)
     ok(string.find(emsg, 'Invalid highlight id') ~= nil)
   end)
@@ -44,16 +43,15 @@ describe('highlight api',function()
                           foreground = Screen.colors.Red }
 
     -- test "Normal" hl defaults
-    eq({}, nvim("get_hl_by_name", 'Normal'))
+    eq({}, nvim("get_hl_by_name", 'Normal', true))
 
-    eq(expected_cterm, nvim("get_hl_by_name", 'NewHighlight'))
-    command('set termguicolors')
-    eq(expected_rgb, nvim("get_hl_by_name", 'NewHighlight'))
+    eq(expected_cterm, nvim("get_hl_by_name", 'NewHighlight', false))
+    eq(expected_rgb, nvim("get_hl_by_name", 'NewHighlight', true))
 
     command('hi Normal guifg=red guibg=yellow')
-    eq(expected_normal, nvim("get_hl_by_name", 'Normal'))
+    eq(expected_normal, nvim("get_hl_by_name", 'Normal', true))
 
-    local err, emsg = pcall(meths.get_hl_by_name , 'unknown_highlight')
+    local err, emsg = pcall(meths.get_hl_by_name , 'unknown_highlight', false)
     eq(false, err)
     ok(string.find(emsg, 'Invalid highlight name') ~= nil)
   end)
-- 
cgit 


From 52517321d1859c31fef14aa75d784615693fcecb Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 8 Oct 2017 20:23:11 +0200
Subject: test: nvim_get_hl_by_name/by_id #7082

- test all properties
- test failure modes
---
 test/functional/api/highlight_spec.lua | 77 +++++++++++++++++++++++++++-------
 1 file changed, 62 insertions(+), 15 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/highlight_spec.lua b/test/functional/api/highlight_spec.lua
index c482128a31..2297a0760f 100644
--- a/test/functional/api/highlight_spec.lua
+++ b/test/functional/api/highlight_spec.lua
@@ -6,15 +6,26 @@ local command = helpers.command
 local meths = helpers.meths
 
 describe('highlight api',function()
-  local expected_rgb = { background = Screen.colors.Yellow,
-                         foreground = Screen.colors.Red,
-                         special = Screen.colors.Blue,
-                         bold = true,
-                       }
-
-  local expected_cterm = { background = 10,
-                           underline = true,
-                         }
+  local expected_rgb = {
+    background = Screen.colors.Yellow,
+    foreground = Screen.colors.Red,
+    special = Screen.colors.Blue,
+    bold = true,
+  }
+  local expected_cterm = {
+    background = 10,
+    underline = true,
+  }
+  local expected_rgb2 = {
+    background = Screen.colors.Yellow,
+    foreground = Screen.colors.Red,
+    special = Screen.colors.Blue,
+    bold = true,
+    italic = true,
+    reverse = true,
+    undercurl = true,
+    underline = true,
+  }
 
   before_each(function()
     clear()
@@ -26,31 +37,67 @@ describe('highlight api',function()
     eq(expected_cterm, nvim("get_hl_by_id", hl_id, false))
 
     hl_id = eval("hlID('NewHighlight')")
+    -- Test valid id.
     eq(expected_rgb, nvim("get_hl_by_id", hl_id, true))
 
-    local expected_error = 'Invalid highlight id'
-    -- Assume there is no hl id 30000.
+    -- Test invalid id.
     local err, emsg = pcall(meths.get_hl_by_id, 30000, false)
     eq(false, err)
-    eq(expected_error, string.match(emsg, expected_error))
+    eq('Invalid highlight id: 30000', string.match(emsg, 'Invalid.*'))
+
+    -- Test all highlight properties.
+    command('hi NewHighlight gui=underline,bold,undercurl,italic,reverse')
+    eq(expected_rgb2, nvim("get_hl_by_id", hl_id, true))
+
+    -- Test nil argument.
+    err, emsg = pcall(meths.get_hl_by_id, { nil }, false)
+    eq(false, err)
+    eq('Wrong type for argument 1, expecting Integer',
+       string.match(emsg, 'Wrong.*'))
+
+    -- Test 0 argument.
+    err, emsg = pcall(meths.get_hl_by_id, 0, false)
+    eq(false, err)
+    eq('Invalid highlight id: 0',
+       string.match(emsg, 'Invalid.*'))
+
+    -- Test -1 argument.
+    err, emsg = pcall(meths.get_hl_by_id, -1, false)
+    eq(false, err)
+    eq('Invalid highlight id: -1',
+       string.match(emsg, 'Invalid.*'))
   end)
 
   it("nvim_get_hl_by_name", function()
     local expected_normal = { background = Screen.colors.Yellow,
                               foreground = Screen.colors.Red }
 
-    -- Test "Normal" hl defaults.
+    -- Test `Normal` default values.
     eq({}, nvim("get_hl_by_name", 'Normal', true))
 
     eq(expected_cterm, nvim("get_hl_by_name", 'NewHighlight', false))
     eq(expected_rgb, nvim("get_hl_by_name", 'NewHighlight', true))
 
+    -- Test `Normal` modified values.
     command('hi Normal guifg=red guibg=yellow')
     eq(expected_normal, nvim("get_hl_by_name", 'Normal', true))
 
-    local expected_error = 'Invalid highlight name'
+    -- Test invalid name.
     local err, emsg = pcall(meths.get_hl_by_name , 'unknown_highlight', false)
     eq(false, err)
-    eq(expected_error, string.match(emsg, expected_error))
+    eq('Invalid highlight name: unknown_highlight',
+       string.match(emsg, 'Invalid.*'))
+
+    -- Test nil argument.
+    err, emsg = pcall(meths.get_hl_by_name , { nil }, false)
+    eq(false, err)
+    eq('Wrong type for argument 1, expecting String',
+       string.match(emsg, 'Wrong.*'))
+
+    -- Test empty string argument.
+    err, emsg = pcall(meths.get_hl_by_name , '', false)
+    eq(false, err)
+    eq('Invalid highlight name: ',
+       string.match(emsg, 'Invalid.*'))
   end)
 end)
-- 
cgit 


From 2a3bcd1ff883429a3dd17e7ae5ddc1396abbad17 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sun, 29 Oct 2017 03:06:53 +0100
Subject: rpc: Don't delay notifications when request is pending (#6544)

With the old behavior, if a GUI makes a blocking request that requires user
interaction (like nvim_input()), it would not get any screen updates.

The client, not nvim, should decide how to handle notifications during a
pending request. If an rplugin wants to avoid async calls while a sync call is
busy, it likely wants to avoid processing async calls while another async call
also is handled as well.

This may break the expectation of some existing rplugins. For compatibility,
remote/define.vim reimplements the old behavior. Clients can opt-out by
specifying `sync=urgent`.

- Legacy hosts should be updated to use `sync=urgent`. They could add a flag
  indicating which async methods are always safe to call and which must wait
  until the main loop returns.
- New hosts can expose the full asyncness, they don't need to offer both
  behaviors.

ref #6532
ref #1398 d83868fe9071af1b4866594eac12f7aa0fa71b53
---
 test/functional/api/server_requests_spec.lua | 61 +++++++++++++++++++---------
 1 file changed, 42 insertions(+), 19 deletions(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 9f245d913b..4380e52b8b 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -109,7 +109,28 @@ describe('server -> client', function()
   end)
 
   describe('requests and notifications interleaved', function()
-    -- This tests that the following scenario won't happen:
+    it('does not delay notifications during pending request', function()
+      local received = false
+      local function on_setup()
+        eq("retval", funcs.rpcrequest(cid, "doit"))
+        stop()
+      end
+      local function on_request(method)
+        if method == "doit" then
+          funcs.rpcnotify(cid, "headsup")
+          eq(true,received)
+          return "retval"
+        end
+      end
+      local function on_notification(method)
+        if method == "headsup" then
+          received = true
+        end
+      end
+      run(on_request, on_notification, on_setup)
+    end)
+
+    -- This tests the following scenario:
     --
     -- server->client [request     ] (1)
     -- client->server [request     ] (2) triggered by (1)
@@ -124,36 +145,38 @@ describe('server -> client', function()
     -- only deals with one server->client request at a time. (In other words,
     -- the client cannot send a response to a request that is not at the top
     -- of nvim's request stack).
-    --
-    -- But above scenario shoudn't happen by the way notifications are dealt in
-    -- Nvim: they are only sent after there are no pending server->client
-    -- request(the request stack fully unwinds). So (3) is only sent after the
-    -- client returns (6).
-    it('works', function()
-      local expected = 300
-      local notified = 0
+    pending('will close connection if not properly synchronized', function()
       local function on_setup()
         eq('notified!', eval('rpcrequest('..cid..', "notify")'))
       end
 
       local function on_request(method)
-        eq('notify', method)
-        eq(1, eval('rpcnotify('..cid..', "notification")'))
-        return 'notified!'
+        if method == "notify" then
+          eq(1, eval('rpcnotify('..cid..', "notification")'))
+          return 'notified!'
+        elseif method == "nested" then
+          -- do some busywork, so the first request will return
+          -- before this one
+          for _ = 1, 5 do
+            eq(2, eval("1+1"))
+          end
+          eq(1, eval('rpcnotify('..cid..', "nested_done")'))
+          return 'done!'
+        end
       end
 
       local function on_notification(method)
-        eq('notification', method)
-        if notified == expected then
-          stop()
-          return
+        if method == "notification" then
+          eq('done!', eval('rpcrequest('..cid..', "nested")'))
+        elseif method == "nested_done" then
+          -- this should never have been sent
+          ok(false)
         end
-        notified = notified + 1
-        eq('notified!', eval('rpcrequest('..cid..', "notify")'))
       end
 
       run(on_request, on_notification, on_setup)
-      eq(expected, notified)
+      -- ignore disconnect failure, otherwise detected by after_each
+      clear()
     end)
   end)
 
-- 
cgit 


From a39c8b7ce30ddeed4329c28c42b1b699103dccab Mon Sep 17 00:00:00 2001
From: James McCoy <jamessan@jamessan.com>
Date: Thu, 2 Nov 2017 05:45:38 -0400
Subject: test: server_spec: Tolerate missing protocol (#7478)

Travis disabled IPv6:

[ RUN      ] serverstart(), serverstop() parses endpoints correctly: FAIL
...build/neovim/neovim/test/functional/eval/server_spec.lua:83: Expected objects to be the same.
Passed in:
(table) {
  [1] = '127.0.0.1:12345' }
Expected:
(table) {
  [1] = '127.0.0.1:12345'
 *[2] = '::1:12345' }

Change all tests to ensure a server was actually started before
expecting it to be returned from serverlist().
---
 test/functional/api/server_requests_spec.lua | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index 4380e52b8b..a2a198ca83 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -304,14 +304,30 @@ describe('server -> client', function()
       connect_test(server, 'pipe', address)
     end)
 
-    it('via ip address', function()
+    it('via ipv4 address', function()
       local server = spawn(nvim_argv)
       set_session(server)
       local address = funcs.serverstart("127.0.0.1:")
+      if #address == 0 then
+        pending('no ipv4 stack', function() end)
+        return
+      end
       eq('127.0.0.1:', string.sub(address,1,10))
       connect_test(server, 'tcp', address)
     end)
 
+    it('via ipv6 address', function()
+      local server = spawn(nvim_argv)
+      set_session(server)
+      local address = funcs.serverstart('::1:')
+      if #address == 0 then
+        pending('no ipv6 stack', function() end)
+        return
+      end
+      eq('::1:', string.sub(address,1,4))
+      connect_test(server, 'tcp', address)
+    end)
+
     it('via hostname', function()
       local server = spawn(nvim_argv)
       set_session(server)
-- 
cgit 


From 91b856cccec89d5a29c280441f4a6aa7c8393268 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 10 Jun 2017 15:25:23 +0200
Subject: channels: tests

---
 test/functional/api/server_requests_spec.lua | 1 +
 1 file changed, 1 insertion(+)

(limited to 'test/functional/api')

diff --git a/test/functional/api/server_requests_spec.lua b/test/functional/api/server_requests_spec.lua
index a2a198ca83..37ac532d18 100644
--- a/test/functional/api/server_requests_spec.lua
+++ b/test/functional/api/server_requests_spec.lua
@@ -262,6 +262,7 @@ describe('server -> client', function()
       eq("done!",funcs.rpcrequest(jobid, "write_stderr", "fluff\n"))
       eq({'notification', 'stderr', {0, {'fluff', ''}}}, next_message())
       funcs.rpcrequest(jobid, "exit")
+      eq({'notification', 'stderr', {0, {''}}}, next_message())
       eq({'notification', 'exit', {0, 0}}, next_message())
     end)
   end)
-- 
cgit