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

30 files changed, 4864 insertions, 2185 deletions

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index 56969150bd..741ed0cf6e 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -145,10 +145,10 @@ describe('luaeval(vim.api.…)', function()
     eq(true, fn.luaeval('vim.api.nvim__id(vim.api.nvim__id)(true)'))
     eq(
       42,
-      exec_lua [[
-      local f = vim.api.nvim__id({42, vim.api.nvim__id})
-      return f[2](f[1])
-    ]]
+      exec_lua(function()
+        local f = vim.api.nvim__id({ 42, vim.api.nvim__id })
+        return f[2](f[1])
+      end)
     )
   end)
 
@@ -224,42 +224,39 @@ describe('luaeval(vim.api.…)', function()
   end)
 
   it('correctly converts dictionaries with type_idx to API objects', function()
-    eq(
-      4,
-      eval([[type(luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))]])
-    )
+    eq(4, eval([[type(luaeval('vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary})'))]]))
 
-    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary})'))
 
     eq(
       { v = { 42 } },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { foo = 2 },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+        'vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       { v = 10 },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { v = {} },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2}})'
       )
     )
 
-    -- If API requests dictionary, then empty table will be the one. This is not
+    -- If API requests dict, then empty table will be the one. This is not
     -- the case normally because empty table is an empty array.
-    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({})'))
-    eq(4, eval([[type(luaeval('vim.api.nvim__id_dictionary({})'))]]))
+    eq({}, fn.luaeval('vim.api.nvim__id_dict({})'))
+    eq(4, eval([[type(luaeval('vim.api.nvim__id_dict({})'))]]))
   end)
 
   it('converts booleans in positional args', function()
@@ -365,12 +362,12 @@ describe('luaeval(vim.api.…)', function()
 
     eq(
       [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'dct': Expected Lua table]],
-      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_dictionary(1)")]]))
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_dict(1)")]]))
     )
     eq(
       [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'dct': Expected Dict-like Lua table]],
       remove_trace(
-        exc_exec([[call luaeval("vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.array})")]])
+        exc_exec([[call luaeval("vim.api.nvim__id_dict({[vim.type_idx]=vim.types.array})")]])
       )
     )
 
diff --git a/test/functional/lua/buffer_updates_spec.lua b/test/functional/lua/buffer_updates_spec.lua
index d4af7e4732..f277868b1c 100644
--- a/test/functional/lua/buffer_updates_spec.lua
+++ b/test/functional/lua/buffer_updates_spec.lua
@@ -27,30 +27,35 @@ local origlines = {
 
 before_each(function()
   clear()
-  exec_lua [[
-    local evname = ...
+  exec_lua(function()
     local events = {}
 
-    function test_register(bufnr, evname, id, changedtick, utf_sizes, preview)
+    function _G.test_register(bufnr, evname, id, changedtick, utf_sizes, preview)
       local function callback(...)
-        table.insert(events, {id, ...})
-        if test_unreg == id then
+        table.insert(events, { id, ... })
+        if _G.test_unreg == id then
           return true
         end
       end
-      local opts = {[evname]=callback, on_detach=callback, on_reload=callback, utf_sizes=utf_sizes, preview=preview}
+      local opts = {
+        [evname] = callback,
+        on_detach = callback,
+        on_reload = callback,
+        utf_sizes = utf_sizes,
+        preview = preview,
+      }
       if changedtick then
         opts.on_changedtick = callback
       end
       vim.api.nvim_buf_attach(bufnr, false, opts)
     end
 
-    function get_events()
+    function _G.get_events()
       local ret_events = events
       events = {}
       return ret_events
     end
-  ]]
+  end)
 end)
 
 describe('lua buffer event callbacks: on_lines', function()
@@ -257,13 +262,13 @@ describe('lua buffer event callbacks: on_lines', function()
 
   it('has valid cursor position while shifting', function()
     api.nvim_buf_set_lines(0, 0, -1, true, { 'line1' })
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function()
           vim.api.nvim_set_var('listener_cursor_line', vim.api.nvim_win_get_cursor(0)[1])
         end,
       })
-    ]])
+    end)
     feed('>>')
     eq(1, api.nvim_get_var('listener_cursor_line'))
   end)
@@ -277,19 +282,19 @@ describe('lua buffer event callbacks: on_lines', function()
   end)
 
   it('does not SEGFAULT when accessing window buffer info in on_detach #14998', function()
-    local code = [[
+    local code = function()
       local buf = vim.api.nvim_create_buf(false, false)
 
-      vim.cmd"split"
+      vim.cmd 'split'
       vim.api.nvim_win_set_buf(0, buf)
 
       vim.api.nvim_buf_attach(buf, false, {
-        on_detach = function(_, buf)
+        on_detach = function(_, buf0)
           vim.fn.tabpagebuflist()
-          vim.fn.win_findbuf(buf)
-        end
+          vim.fn.win_findbuf(buf0)
+        end,
       })
-    ]]
+    end
 
     exec_lua(code)
     command('q!')
@@ -302,13 +307,13 @@ describe('lua buffer event callbacks: on_lines', function()
 
   it('#12718 lnume', function()
     api.nvim_buf_set_lines(0, 0, -1, true, { '1', '2', '3' })
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function(...)
           vim.api.nvim_set_var('linesev', { ... })
         end,
       })
-    ]])
+    end)
     feed('1G0')
     feed('y<C-v>2j')
     feed('G0')
@@ -326,13 +331,13 @@ describe('lua buffer event callbacks: on_lines', function()
   end)
 
   it('nvim_buf_call() from callback does not cause wrong Normal mode CTRL-A #16729', function()
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
-        on_lines = function(...)
+        on_lines = function()
           vim.api.nvim_buf_call(0, function() end)
         end,
       })
-    ]])
+    end)
     feed('itest123<Esc><C-A>')
     eq('test124', api.nvim_get_current_line())
   end)
@@ -342,19 +347,19 @@ describe('lua buffer event callbacks: on_lines', function()
     screen:attach()
 
     api.nvim_buf_set_lines(0, 0, -1, true, { 'aaa', 'bbb', 'ccc' })
-    exec_lua([[
+    exec_lua(function()
       local ns = vim.api.nvim_create_namespace('')
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function(_, _, _, row, _, end_row)
           vim.api.nvim_buf_clear_namespace(0, ns, row, end_row)
           for i = row, end_row - 1 do
-            local id = vim.api.nvim_buf_set_extmark(0, ns, i, 0, {
-              virt_text = {{ 'NEW' .. tostring(i), 'WarningMsg' }},
+            vim.api.nvim_buf_set_extmark(0, ns, i, 0, {
+              virt_text = { { 'NEW' .. tostring(i), 'WarningMsg' } },
             })
           end
         end,
       })
-    ]])
+    end)
 
     feed('o')
     screen:expect({
@@ -379,6 +384,25 @@ describe('lua buffer event callbacks: on_lines', function()
       ]],
     })
   end)
+
+  it('line lengths are correct when pressing TAB with folding #29119', function()
+    api.nvim_buf_set_lines(0, 0, -1, true, { 'a', 'b' })
+
+    exec_lua(function()
+      _G.res = {}
+      vim.o.foldmethod = 'indent'
+      vim.o.softtabstop = -1
+      vim.api.nvim_buf_attach(0, false, {
+        on_lines = function(_, bufnr, _, row, _, end_row)
+          local lines = vim.api.nvim_buf_get_lines(bufnr, row, end_row, true)
+          table.insert(_G.res, lines)
+        end,
+      })
+    end)
+
+    feed('i<Tab>')
+    eq({ '\ta' }, exec_lua('return _G.res[#_G.res]'))
+  end)
 end)
 
 describe('lua: nvim_buf_attach on_bytes', function()
diff --git a/test/functional/lua/command_line_completion_spec.lua b/test/functional/lua/command_line_completion_spec.lua
index 2ba432133b..f8786a45bb 100644
--- a/test/functional/lua/command_line_completion_spec.lua
+++ b/test/functional/lua/command_line_completion_spec.lua
@@ -5,12 +5,14 @@ local clear = n.clear
 local eq = t.eq
 local exec_lua = n.exec_lua
 
+--- @return { [1]: string[], [2]: integer }
 local get_completions = function(input, env)
-  return exec_lua('return {vim._expand_pat(...)}', input, env)
+  return exec_lua('return { vim._expand_pat(...) }', input, env)
 end
 
+--- @return { [1]: string[], [2]: integer }
 local get_compl_parts = function(parts)
-  return exec_lua('return {vim._expand_pat_get_parts(...)}', parts)
+  return exec_lua('return { vim._expand_pat_get_parts(...) }', parts)
 end
 
 before_each(clear)
@@ -123,6 +125,171 @@ describe('nlua_expand_pat', function()
     )
   end)
 
+  describe('should complete vim.fn', function()
+    it('correctly works for simple completion', function()
+      local actual = get_completions('vim.fn.did')
+      local expected = {
+        { 'did_filetype' },
+        #'vim.fn.',
+      }
+      eq(expected, actual)
+    end)
+    it('should not suggest items with #', function()
+      exec_lua [[
+        -- ensure remote#host#... functions exist
+        vim.cmd [=[
+          runtime! autoload/remote/host.vim
+        ]=]
+        -- make a dummy call to ensure vim.fn contains an entry: remote#host#...
+        vim.fn['remote#host#IsRunning']('python3')
+      ]]
+      local actual = get_completions('vim.fn.remo')
+      local expected = {
+        { 'remove' }, -- there should be no completion "remote#host#..."
+        #'vim.fn.',
+      }
+      eq(expected, actual)
+    end)
+  end)
+
+  describe('should complete for variable accessors for', function()
+    it('vim.v', function()
+      local actual = get_completions('vim.v.t_')
+      local expected = {
+        { 't_blob', 't_bool', 't_dict', 't_float', 't_func', 't_list', 't_number', 't_string' },
+        #'vim.v.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.g', function()
+      exec_lua [[
+        vim.cmd [=[
+          let g:nlua_foo = 'completion'
+          let g:nlua_foo_bar = 'completion'
+          let g:nlua_foo#bar = 'nocompletion'  " should be excluded from lua completion
+        ]=]
+      ]]
+      local actual = get_completions('vim.g.nlua')
+      local expected = {
+        { 'nlua_foo', 'nlua_foo_bar' },
+        #'vim.g.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.b', function()
+      exec_lua [[
+        vim.b.nlua_foo_buf = 'bar'
+        vim.b.some_other_vars = 'bar'
+      ]]
+      local actual = get_completions('vim.b.nlua')
+      local expected = {
+        { 'nlua_foo_buf' },
+        #'vim.b.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.w', function()
+      exec_lua [[
+        vim.w.nlua_win_var = 42
+      ]]
+      local actual = get_completions('vim.w.nlua')
+      local expected = {
+        { 'nlua_win_var' },
+        #'vim.w.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.t', function()
+      exec_lua [[
+        vim.t.nlua_tab_var = 42
+      ]]
+      local actual = get_completions('vim.t.')
+      local expected = {
+        { 'nlua_tab_var' },
+        #'vim.t.',
+      }
+      eq(expected, actual)
+    end)
+  end)
+
+  describe('should complete for option accessors for', function()
+    -- for { vim.o, vim.go, vim.opt, vim.opt_local, vim.opt_global }
+    local test_opt = function(accessor)
+      do
+        local actual = get_completions(accessor .. '.file')
+        local expected = {
+          'fileencoding',
+          'fileencodings',
+          'fileformat',
+          'fileformats',
+          'fileignorecase',
+          'filetype',
+        }
+        eq({ expected, #accessor + 1 }, actual, accessor .. '.file')
+      end
+      do
+        local actual = get_completions(accessor .. '.winh')
+        local expected = {
+          'winheight',
+          'winhighlight',
+        }
+        eq({ expected, #accessor + 1 }, actual, accessor .. '.winh')
+      end
+    end
+
+    test_opt('vim.o')
+    test_opt('vim.go')
+    test_opt('vim.opt')
+    test_opt('vim.opt_local')
+    test_opt('vim.opt_global')
+
+    it('vim.o, suggesting all the known options', function()
+      local completions = get_completions('vim.o.')[1] ---@type string[]
+      eq(
+        exec_lua [[
+        return vim.tbl_count(vim.api.nvim_get_all_options_info())
+      ]],
+        #completions
+      )
+    end)
+
+    it('vim.bo', function()
+      do
+        local actual = get_completions('vim.bo.file')
+        local compls = {
+          -- should contain buffer options only
+          'fileencoding',
+          'fileformat',
+          'filetype',
+        }
+        eq({ compls, #'vim.bo.' }, actual)
+      end
+      do
+        local actual = get_completions('vim.bo.winh')
+        local compls = {}
+        eq({ compls, #'vim.bo.' }, actual)
+      end
+    end)
+
+    it('vim.wo', function()
+      do
+        local actual = get_completions('vim.wo.file')
+        local compls = {}
+        eq({ compls, #'vim.wo.' }, actual)
+      end
+      do
+        local actual = get_completions('vim.wo.winh')
+        -- should contain window options only
+        local compls = { 'winhighlight' }
+        eq({ compls, #'vim.wo.' }, actual)
+      end
+    end)
+  end)
+
   it('should return everything if the input is of length 0', function()
     eq({ { 'other', 'vim' }, 0 }, get_completions('', { vim = true, other = true }))
   end)
diff --git a/test/functional/lua/commands_spec.lua b/test/functional/lua/commands_spec.lua
index 57b084d3d6..456ee13da2 100644
--- a/test/functional/lua/commands_spec.lua
+++ b/test/functional/lua/commands_spec.lua
@@ -178,13 +178,15 @@ describe(':lua', function()
     eq('hello', exec_capture(':lua = x()'))
     exec_lua('x = {a = 1, b = 2}')
     eq('{\n  a = 1,\n  b = 2\n}', exec_capture(':lua  =x'))
-    exec_lua([[function x(success)
-      if success then
-        return true, "Return value"
-      else
-        return false, nil, "Error message"
+    exec_lua(function()
+      function _G.x(success)
+        if success then
+          return true, 'Return value'
+        else
+          return false, nil, 'Error message'
+        end
       end
-    end]])
+    end)
     eq(
       dedent [[
       true
diff --git a/test/functional/lua/deprecated_spec.lua b/test/functional/lua/deprecated_spec.lua
new file mode 100644
index 0000000000..fee34336cc
--- /dev/null
+++ b/test/functional/lua/deprecated_spec.lua
@@ -0,0 +1,22 @@
+local t = require('test.testutil')
+local n = require('test.functional.testnvim')()
+
+local clear = n.clear
+local exec_lua = n.exec_lua
+local eq = t.eq
+
+describe('deprecated lua code', function()
+  before_each(clear)
+
+  describe('vim.treesitter.get_parser()', function()
+    it('returns nil for versions >= 0.12', function()
+      local result = exec_lua(function()
+        if vim.version.ge(vim.version(), '0.12') then
+          return vim.treesitter.get_parser(0, 'borklang')
+        end
+        return nil
+      end)
+      eq(nil, result)
+    end)
+  end)
+end)
diff --git a/test/functional/lua/diagnostic_spec.lua b/test/functional/lua/diagnostic_spec.lua
index 05082bc132..4ae1146703 100644
--- a/test/functional/lua/diagnostic_spec.lua
+++ b/test/functional/lua/diagnostic_spec.lua
@@ -1,7 +1,6 @@
 local t = require('test.testutil')
 local n = require('test.functional.testnvim')()
 
-local NIL = vim.NIL
 local command = n.command
 local clear = n.clear
 local exec_lua = n.exec_lua
@@ -15,10 +14,10 @@ describe('vim.diagnostic', function()
   before_each(function()
     clear()
 
-    exec_lua [[
+    exec_lua(function()
       require('vim.diagnostic')
 
-      function make_diagnostic(msg, lnum, col, end_lnum, end_col, severity, source, code)
+      local function make_diagnostic(msg, lnum, col, end_lnum, end_col, severity, source, code)
         return {
           lnum = lnum,
           col = col,
@@ -31,54 +30,97 @@ describe('vim.diagnostic', function()
         }
       end
 
-      function make_error(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.ERROR, source, code)
+      function _G.make_error(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.ERROR,
+          source,
+          code
+        )
       end
 
-      function make_warning(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.WARN, source, code)
+      function _G.make_warning(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.WARN,
+          source,
+          code
+        )
       end
 
-      function make_info(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.INFO, source, code)
+      function _G.make_info(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.INFO,
+          source,
+          code
+        )
       end
 
-      function make_hint(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.HINT, source, code)
+      function _G.make_hint(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.HINT,
+          source,
+          code
+        )
       end
 
-      function count_diagnostics(bufnr, severity, namespace)
-        return #vim.diagnostic.get(bufnr, {severity = severity, namespace = namespace})
+      function _G.count_diagnostics(bufnr, severity, namespace)
+        return #vim.diagnostic.get(bufnr, { severity = severity, namespace = namespace })
       end
 
-      function count_extmarks(bufnr, namespace)
+      function _G.count_extmarks(bufnr, namespace)
         local ns = vim.diagnostic.get_namespace(namespace)
         local extmarks = 0
         if ns.user_data.virt_text_ns then
-          extmarks = extmarks + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {})
+          extmarks = extmarks
+            + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {})
         end
         if ns.user_data.underline_ns then
-          extmarks = extmarks + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {})
+          extmarks = extmarks
+            + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {})
         end
         return extmarks
       end
 
-      function get_virt_text_extmarks(ns)
-        local ns = vim.diagnostic.get_namespace(ns)
+      function _G.get_virt_text_extmarks(ns)
+        ns = vim.diagnostic.get_namespace(ns)
         local virt_text_ns = ns.user_data.virt_text_ns
-        return vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, virt_text_ns, 0, -1, {details = true})
+        return vim.api.nvim_buf_get_extmarks(
+          _G.diagnostic_bufnr,
+          virt_text_ns,
+          0,
+          -1,
+          { details = true }
+        )
       end
-    ]]
-
-    exec_lua([[
-      diagnostic_ns = vim.api.nvim_create_namespace("diagnostic_spec")
-      other_ns = vim.api.nvim_create_namespace("other_namespace")
-      diagnostic_bufnr = vim.api.nvim_create_buf(true, false)
-      local lines = {"1st line of text", "2nd line of text", "wow", "cool", "more", "lines"}
-      vim.fn.bufload(diagnostic_bufnr)
-      vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, 1, false, lines)
-      return diagnostic_bufnr
-    ]])
+    end)
+
+    exec_lua(function()
+      _G.diagnostic_ns = vim.api.nvim_create_namespace('diagnostic_spec')
+      _G.other_ns = vim.api.nvim_create_namespace('other_namespace')
+      _G.diagnostic_bufnr = vim.api.nvim_create_buf(true, false)
+      local lines = { '1st line of text', '2nd line of text', 'wow', 'cool', 'more', 'lines' }
+      vim.fn.bufload(_G.diagnostic_bufnr)
+      vim.api.nvim_buf_set_lines(_G.diagnostic_bufnr, 0, 1, false, lines)
+    end)
   end)
 
   it('creates highlight groups', function()
@@ -115,27 +157,28 @@ describe('vim.diagnostic', function()
   end)
 
   it('retrieves diagnostics from all buffers and namespaces', function()
-    local result = exec_lua [[
+    local result = exec_lua(function()
       local other_bufnr = vim.api.nvim_create_buf(true, false)
-      local lines = vim.api.nvim_buf_get_lines(diagnostic_bufnr, 0, -1, true)
+      local lines = vim.api.nvim_buf_get_lines(_G.diagnostic_bufnr, 0, -1, true)
       vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
 
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
+      vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+        _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+        _G.make_error('Diagnostic #2', 2, 1, 2, 1),
       })
-      vim.diagnostic.set(other_ns, other_bufnr, {
-        make_error('Diagnostic #3', 3, 1, 3, 1),
+      vim.diagnostic.set(_G.other_ns, other_bufnr, {
+        _G.make_error('Diagnostic #3', 3, 1, 3, 1),
       })
       return vim.diagnostic.get()
-    ]]
+    end)
     eq(3, #result)
     eq(
       2,
-      exec_lua(
-        [[return #vim.tbl_filter(function(d) return d.bufnr == diagnostic_bufnr end, ...)]],
-        result
-      )
+      exec_lua(function()
+        return #vim.tbl_filter(function(d)
+          return d.bufnr == _G.diagnostic_bufnr
+        end, result)
+      end)
     )
     eq('Diagnostic #1', result[1].message)
   end)
@@ -143,155 +186,171 @@ describe('vim.diagnostic', function()
   it('removes diagnostics from the cache when a buffer is removed', function()
     eq(
       2,
-      exec_lua [[
-      vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-      local other_bufnr = vim.fn.bufadd('test | test')
-      local lines = vim.api.nvim_buf_get_lines(diagnostic_bufnr, 0, -1, true)
-      vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
-      vim.cmd('bunload! ' .. other_bufnr)
-
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
-      })
-      vim.diagnostic.set(diagnostic_ns, other_bufnr, {
-        make_error('Diagnostic #3', 3, 1, 3, 1),
-      })
-      vim.api.nvim_set_current_buf(other_bufnr)
-      vim.opt_local.buflisted = true
-      vim.cmd('bwipeout!')
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        local other_bufnr = vim.fn.bufadd('test | test')
+        local lines = vim.api.nvim_buf_get_lines(_G.diagnostic_bufnr, 0, -1, true)
+        vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
+        vim.cmd('bunload! ' .. other_bufnr)
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          _G.make_error('Diagnostic #2', 2, 1, 2, 1),
+        })
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, {
+          _G.make_error('Diagnostic #3', 3, 1, 3, 1),
+        })
+        vim.api.nvim_set_current_buf(other_bufnr)
+        vim.opt_local.buflisted = true
+        vim.cmd('bwipeout!')
+        return #vim.diagnostic.get()
+      end)
     )
     eq(
       2,
-      exec_lua [[
-      vim.api.nvim_set_current_buf(diagnostic_bufnr)
-      vim.opt_local.buflisted = false
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+        vim.opt_local.buflisted = false
+        return #vim.diagnostic.get()
+      end)
     )
     eq(
       0,
-      exec_lua [[
-      vim.cmd('bwipeout!')
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.cmd('bwipeout!')
+        return #vim.diagnostic.get()
+      end)
     )
   end)
 
   it('removes diagnostic from stale cache on reset', function()
-    local diagnostics = exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
+    local diagnostics = exec_lua(function()
+      vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+        _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+        _G.make_error('Diagnostic #2', 2, 1, 2, 1),
       })
-      local other_bufnr = vim.fn.bufadd('test | test')
-      vim.cmd('noautocmd bwipeout! ' .. diagnostic_bufnr)
-      return vim.diagnostic.get(diagnostic_bufnr)
-    ]]
+      vim.fn.bufadd('test | test')
+      vim.cmd('noautocmd bwipeout! ' .. _G.diagnostic_bufnr)
+      return vim.diagnostic.get(_G.diagnostic_bufnr)
+    end)
     eq(2, #diagnostics)
-    diagnostics = exec_lua [[
+    diagnostics = exec_lua(function()
       vim.diagnostic.reset()
       return vim.diagnostic.get()
-    ]]
+    end)
     eq(0, #diagnostics)
   end)
 
   it('always returns a copy of diagnostic tables', function()
-    local result = exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
+    local result = exec_lua(function()
+      vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+        _G.make_error('Diagnostic #1', 1, 1, 1, 1),
       })
       local diag = vim.diagnostic.get()
       diag[1].col = 10000
       return vim.diagnostic.get()[1].col == 10000
-    ]]
+    end)
     eq(false, result)
   end)
 
   it('resolves buffer number 0 to the current buffer', function()
     eq(
       2,
-      exec_lua [[
-      vim.api.nvim_set_current_buf(diagnostic_bufnr)
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
-      })
-      return #vim.diagnostic.get(0)
-    ]]
+      exec_lua(function()
+        vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          _G.make_error('Diagnostic #2', 2, 1, 2, 1),
+        })
+        return #vim.diagnostic.get(0)
+      end)
     )
   end)
 
   it('saves and count a single error', function()
     eq(
       1,
-      exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-      })
-      return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)
-    ]]
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+        })
+        return _G.count_diagnostics(
+          _G.diagnostic_bufnr,
+          vim.diagnostic.severity.ERROR,
+          _G.diagnostic_ns
+        )
+      end)
     )
   end)
 
   it('saves and count multiple errors', function()
     eq(
       2,
-      exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
-      })
-      return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)
-    ]]
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          _G.make_error('Diagnostic #2', 2, 1, 2, 1),
+        })
+        return _G.count_diagnostics(
+          _G.diagnostic_bufnr,
+          vim.diagnostic.severity.ERROR,
+          _G.diagnostic_ns
+        )
+      end)
     )
   end)
 
   it('saves and count from multiple namespaces', function()
     eq(
       { 1, 1, 2 },
-      exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic From Server 1', 1, 1, 1, 1),
-      })
-      vim.diagnostic.set(other_ns, diagnostic_bufnr, {
-        make_error('Diagnostic From Server 2', 1, 1, 1, 1),
-      })
-      return {
-        -- First namespace
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-        -- Second namespace
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, other_ns),
-        -- All namespaces
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR),
-      }
-    ]]
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic From Server 1', 1, 1, 1, 1),
+        })
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic From Server 2', 1, 1, 1, 1),
+        })
+        return {
+          -- First namespace
+          _G.count_diagnostics(
+            _G.diagnostic_bufnr,
+            vim.diagnostic.severity.ERROR,
+            _G.diagnostic_ns
+          ),
+          -- Second namespace
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.ERROR, _G.other_ns),
+          -- All namespaces
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.ERROR),
+        }
+      end)
     )
   end)
 
   it('saves and count from multiple namespaces with respect to severity', function()
     eq(
       { 3, 0, 3 },
-      exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
-        make_error('Diagnostic From Server 1:2', 2, 2, 2, 2),
-        make_error('Diagnostic From Server 1:3', 2, 3, 3, 2),
-      })
-      vim.diagnostic.set(other_ns, diagnostic_bufnr, {
-        make_warning('Warning From Server 2', 3, 3, 3, 3),
-      })
-      return {
-        -- Namespace 1
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-        -- Namespace 2
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, other_ns),
-        -- All namespaces
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR),
-      }
-    ]]
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
+          _G.make_error('Diagnostic From Server 1:2', 2, 2, 2, 2),
+          _G.make_error('Diagnostic From Server 1:3', 2, 3, 3, 2),
+        })
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, {
+          _G.make_warning('Warning From Server 2', 3, 3, 3, 3),
+        })
+        return {
+          -- Namespace 1
+          _G.count_diagnostics(
+            _G.diagnostic_bufnr,
+            vim.diagnostic.severity.ERROR,
+            _G.diagnostic_ns
+          ),
+          -- Namespace 2
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.ERROR, _G.other_ns),
+          -- All namespaces
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.ERROR),
+        }
+      end)
     )
   end)
 
@@ -304,160 +363,190 @@ describe('vim.diagnostic', function()
     local all_highlights = { 1, 1, 2, 4, 2 }
     eq(
       all_highlights,
-      exec_lua [[
-      local ns_1_diags = {
-        make_error("Error 1", 1, 1, 1, 5),
-        make_warning("Warning on Server 1", 2, 1, 2, 3),
-      }
-      local ns_2_diags = {
-        make_warning("Warning 1", 2, 1, 2, 3),
-      }
+      exec_lua(function()
+        local ns_1_diags = {
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 3),
+        }
+        local ns_2_diags = {
+          _G.make_warning('Warning 1', 2, 1, 2, 3),
+        }
 
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-      vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
 
-      return {
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-        count_extmarks(diagnostic_bufnr, diagnostic_ns),
-        count_extmarks(diagnostic_bufnr, other_ns),
-      }
-    ]]
+        return {
+          _G.count_diagnostics(
+            _G.diagnostic_bufnr,
+            vim.diagnostic.severity.ERROR,
+            _G.diagnostic_ns
+          ),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+        }
+      end)
     )
 
     -- Clear diagnostics from namespace 1, and make sure we have the right amount of stuff for namespace 2
     eq(
       { 1, 1, 2, 0, 2 },
-      exec_lua [[
-      vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
-      return {
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-        count_extmarks(diagnostic_bufnr, diagnostic_ns),
-        count_extmarks(diagnostic_bufnr, other_ns),
-      }
-    ]]
+      exec_lua(function()
+        vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
+        return {
+          _G.count_diagnostics(
+            _G.diagnostic_bufnr,
+            vim.diagnostic.severity.ERROR,
+            _G.diagnostic_ns
+          ),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+        }
+      end)
     )
 
     -- Show diagnostics from namespace 1 again
     eq(
       all_highlights,
-      exec_lua([[
-      vim.diagnostic.enable(true, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
-      return {
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-        count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-        count_extmarks(diagnostic_bufnr, diagnostic_ns),
-        count_extmarks(diagnostic_bufnr, other_ns),
-      }
-    ]])
+      exec_lua(function()
+        vim.diagnostic.enable(true, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
+        return {
+          _G.count_diagnostics(
+            _G.diagnostic_bufnr,
+            vim.diagnostic.severity.ERROR,
+            _G.diagnostic_ns
+          ),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+          _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+        }
+      end)
     )
   end)
 
   it('does not display diagnostics when disabled', function()
     eq(
       { 0, 2 },
-      exec_lua [[
-      local ns_1_diags = {
-        make_error("Error 1", 1, 1, 1, 5),
-        make_warning("Warning on Server 1", 2, 1, 2, 3),
-      }
-      local ns_2_diags = {
-        make_warning("Warning 1", 2, 1, 2, 3),
-      }
+      exec_lua(function()
+        local ns_1_diags = {
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 3),
+        }
+        local ns_2_diags = {
+          _G.make_warning('Warning 1', 2, 1, 2, 3),
+        }
 
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-      vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
 
-      vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
+        vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
 
-      return {
-        count_extmarks(diagnostic_bufnr, diagnostic_ns),
-        count_extmarks(diagnostic_bufnr, other_ns),
-      }
-    ]]
+        return {
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+        }
+      end)
     )
 
     eq(
       { 4, 0 },
-      exec_lua [[
-      vim.diagnostic.enable(true, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
-      vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = other_ns })
+      exec_lua(function()
+        vim.diagnostic.enable(true, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
+        vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.other_ns })
 
-      return {
-        count_extmarks(diagnostic_bufnr, diagnostic_ns),
-        count_extmarks(diagnostic_bufnr, other_ns),
-      }
-    ]]
+        return {
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+        }
+      end)
     )
   end)
 
   describe('show() and hide()', function()
     it('works', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         local other_bufnr = vim.api.nvim_create_buf(true, false)
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
         local result = {}
 
         vim.diagnostic.config({ underline = false, virtual_text = true })
 
         local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 5),
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 5),
         }
         local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 5),
+          _G.make_warning('Warning 1', 2, 1, 2, 5),
         }
         local other_buffer_diags = {
-          make_info("This is interesting", 0, 0, 0, 0)
+          _G.make_info('This is interesting', 0, 0, 0, 0),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
-        vim.diagnostic.set(diagnostic_ns, other_bufnr, other_buffer_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, other_buffer_diags)
 
         -- All buffers and namespaces
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         -- Hide one namespace
-        vim.diagnostic.hide(diagnostic_ns)
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        vim.diagnostic.hide(_G.diagnostic_ns)
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         -- Show one namespace
-        vim.diagnostic.show(diagnostic_ns)
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        vim.diagnostic.show(_G.diagnostic_ns)
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         -- Hide one buffer
         vim.diagnostic.hide(nil, other_bufnr)
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         -- Hide everything
         vim.diagnostic.hide()
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         -- Show one buffer
-        vim.diagnostic.show(nil, diagnostic_bufnr)
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        vim.diagnostic.show(nil, _G.diagnostic_bufnr)
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         return result
-      ]]
+      end)
 
       eq(4, result[1])
       eq(1, result[2])
@@ -468,13 +557,17 @@ describe('vim.diagnostic', function()
     end)
 
     it("doesn't error after bwipeout on buffer", function()
-      exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {{ lnum = 0, end_lnum = 0, col = 0, end_col = 0 }})
-        vim.cmd("bwipeout! " .. diagnostic_bufnr)
+      exec_lua(function()
+        vim.diagnostic.set(
+          _G.diagnostic_ns,
+          _G.diagnostic_bufnr,
+          { { lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
+        )
+        vim.cmd('bwipeout! ' .. _G.diagnostic_bufnr)
 
-        vim.diagnostic.show(diagnostic_ns)
-        vim.diagnostic.hide(diagnostic_ns)
-      ]]
+        vim.diagnostic.show(_G.diagnostic_ns)
+        vim.diagnostic.hide(_G.diagnostic_ns)
+      end)
     end)
   end)
 
@@ -505,52 +598,64 @@ describe('vim.diagnostic', function()
     end)
 
     it('without arguments', function()
-      local result = exec_lua [[
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
         local result = {}
 
         vim.diagnostic.config({ underline = false, virtual_text = true })
 
         local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 5),
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 5),
         }
         local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 5),
+          _G.make_warning('Warning 1', 2, 1, 2, 5),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
         vim.diagnostic.enable(false)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
         -- Create a new buffer
         local other_bufnr = vim.api.nvim_create_buf(true, false)
         local other_buffer_diags = {
-          make_info("This is interesting", 0, 0, 0, 0)
+          _G.make_info('This is interesting', 0, 0, 0, 0),
         }
 
-        vim.diagnostic.set(diagnostic_ns, other_bufnr, other_buffer_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, other_buffer_diags)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         vim.diagnostic.enable()
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         return result
-      ]]
+      end)
 
       eq(3, result[1])
       eq(0, result[2])
@@ -559,54 +664,66 @@ describe('vim.diagnostic', function()
     end)
 
     it('with buffer argument', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         local other_bufnr = vim.api.nvim_create_buf(true, false)
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
         local result = {}
 
         vim.diagnostic.config({ underline = false, virtual_text = true })
 
         local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 5),
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 5),
         }
         local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 5),
+          _G.make_warning('Warning 1', 2, 1, 2, 5),
         }
         local other_buffer_diags = {
-          make_info("This is interesting", 0, 0, 0, 0)
+          _G.make_info('This is interesting', 0, 0, 0, 0),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
-        vim.diagnostic.set(diagnostic_ns, other_bufnr, other_buffer_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, other_buffer_diags)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
-        vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr })
+        vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
-        vim.diagnostic.enable(true, { bufnr = diagnostic_bufnr })
+        vim.diagnostic.enable(true, { bufnr = _G.diagnostic_bufnr })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         vim.diagnostic.enable(false, { bufnr = other_bufnr })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         return result
-      ]]
+      end)
 
       eq(4, result[1])
       eq(1, result[2])
@@ -615,44 +732,56 @@ describe('vim.diagnostic', function()
     end)
 
     it('with a namespace argument', function()
-      local result = exec_lua [[
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
         local result = {}
 
         vim.diagnostic.config({ underline = false, virtual_text = true })
 
         local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 5),
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 5),
         }
         local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 5),
+          _G.make_warning('Warning 1', 2, 1, 2, 5),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
-        vim.diagnostic.enable(false, { ns_id = diagnostic_ns })
+        vim.diagnostic.enable(false, { ns_id = _G.diagnostic_ns })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
-        vim.diagnostic.enable(true, { ns_id = diagnostic_ns })
+        vim.diagnostic.enable(true, { ns_id = _G.diagnostic_ns })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
-        vim.diagnostic.enable(false, { ns_id = other_ns })
+        vim.diagnostic.enable(false, { ns_id = _G.other_ns })
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+        )
 
         return result
-      ]]
+      end)
 
       eq(3, result[1])
       eq(1, result[2])
@@ -662,84 +791,93 @@ describe('vim.diagnostic', function()
 
     --- @return table
     local function test_enable(legacy)
-      local result = exec_lua(
-        [[
-        local legacy = ...
+      return exec_lua(function()
         local other_bufnr = vim.api.nvim_create_buf(true, false)
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
         local result = {}
 
         vim.diagnostic.config({ underline = false, virtual_text = true })
 
         local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 5),
+          _G.make_error('Error 1', 1, 1, 1, 5),
+          _G.make_warning('Warning on Server 1', 2, 1, 2, 5),
         }
         local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 5),
+          _G.make_warning('Warning 1', 2, 1, 2, 5),
         }
         local other_buffer_diags = {
-          make_info("This is interesting", 0, 0, 0, 0)
+          _G.make_info('This is interesting', 0, 0, 0, 0),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
-        vim.diagnostic.set(diagnostic_ns, other_bufnr, other_buffer_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, other_buffer_diags)
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         if legacy then
-          vim.diagnostic.disable(diagnostic_bufnr, diagnostic_ns)
+          vim.diagnostic.disable(_G.diagnostic_bufnr, _G.diagnostic_ns)
         else
-          vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
+          vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
         end
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         if legacy then
-          vim.diagnostic.disable(diagnostic_bufnr, other_ns)
+          vim.diagnostic.disable(_G.diagnostic_bufnr, _G.other_ns)
         else
-          vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = other_ns })
+          vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.other_ns })
         end
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         if legacy then
-          vim.diagnostic.enable(diagnostic_bufnr, diagnostic_ns)
+          vim.diagnostic.enable(_G.diagnostic_bufnr, _G.diagnostic_ns)
         else
-          vim.diagnostic.enable(true, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
+          vim.diagnostic.enable(true, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
         end
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         if legacy then
           -- Should have no effect
-          vim.diagnostic.disable(other_bufnr, other_ns)
+          vim.diagnostic.disable(other_bufnr, _G.other_ns)
         else
           -- Should have no effect
-          vim.diagnostic.enable(false, { bufnr = other_bufnr, ns_id = other_ns })
+          vim.diagnostic.enable(false, { bufnr = other_bufnr, ns_id = _G.other_ns })
         end
 
-        table.insert(result, count_extmarks(diagnostic_bufnr, diagnostic_ns) +
-                             count_extmarks(diagnostic_bufnr, other_ns) +
-                             count_extmarks(other_bufnr, diagnostic_ns))
+        table.insert(
+          result,
+          _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+            + _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns)
+            + _G.count_extmarks(other_bufnr, _G.diagnostic_ns)
+        )
 
         return result
-      ]],
-        legacy
-      )
-
-      return result
+      end)
     end
 
     it('with both buffer and namespace arguments', function()
@@ -772,442 +910,600 @@ describe('vim.diagnostic', function()
       local all_highlights = { 1, 1, 2, 4, 2 }
       eq(
         all_highlights,
-        exec_lua [[
-        local ns_1_diags = {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 2, 1, 2, 3),
-        }
-        local ns_2_diags = {
-          make_warning("Warning 1", 2, 1, 2, 3),
-        }
+        exec_lua(function()
+          local ns_1_diags = {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 2, 1, 2, 3),
+          }
+          local ns_2_diags = {
+            _G.make_warning('Warning 1', 2, 1, 2, 3),
+          }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diags)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diags)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diags)
+          vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diags)
 
-        return {
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-          count_extmarks(diagnostic_bufnr, diagnostic_ns),
-          count_extmarks(diagnostic_bufnr, other_ns),
-        }
-      ]]
+          return {
+            _G.count_diagnostics(
+              _G.diagnostic_bufnr,
+              vim.diagnostic.severity.ERROR,
+              _G.diagnostic_ns
+            ),
+            _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+            _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+            _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+            _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+          }
+        end)
       )
 
       -- Reset diagnostics from namespace 1
-      exec_lua([[ vim.diagnostic.reset(diagnostic_ns) ]])
+      exec_lua([[ vim.diagnostic.reset( _G.diagnostic_ns) ]])
 
       -- Make sure we have the right diagnostic count
       eq(
         { 0, 1, 1, 0, 2 },
-        exec_lua [[
-        local diagnostic_count = {}
-        vim.wait(100, function () diagnostic_count = {
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-          count_extmarks(diagnostic_bufnr, diagnostic_ns),
-          count_extmarks(diagnostic_bufnr, other_ns),
-        } end )
-        return diagnostic_count
-      ]]
+        exec_lua(function()
+          local diagnostic_count = {}
+          vim.wait(100, function()
+            diagnostic_count = {
+              _G.count_diagnostics(
+                _G.diagnostic_bufnr,
+                vim.diagnostic.severity.ERROR,
+                _G.diagnostic_ns
+              ),
+              _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+              _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+              _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+              _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+            }
+          end)
+          return diagnostic_count
+        end)
       )
 
       -- Reset diagnostics from namespace 2
-      exec_lua([[ vim.diagnostic.reset(other_ns) ]])
+      exec_lua([[ vim.diagnostic.reset(_G.other_ns) ]])
 
       -- Make sure we have the right diagnostic count
       eq(
         { 0, 0, 0, 0, 0 },
-        exec_lua [[
-        local diagnostic_count = {}
-        vim.wait(100, function () diagnostic_count = {
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN, other_ns),
-          count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.WARN),
-          count_extmarks(diagnostic_bufnr, diagnostic_ns),
-          count_extmarks(diagnostic_bufnr, other_ns),
-        } end )
-        return diagnostic_count
-      ]]
+        exec_lua(function()
+          local diagnostic_count = {}
+          vim.wait(100, function()
+            diagnostic_count = {
+              _G.count_diagnostics(
+                _G.diagnostic_bufnr,
+                vim.diagnostic.severity.ERROR,
+                _G.diagnostic_ns
+              ),
+              _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN, _G.other_ns),
+              _G.count_diagnostics(_G.diagnostic_bufnr, vim.diagnostic.severity.WARN),
+              _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns),
+              _G.count_extmarks(_G.diagnostic_bufnr, _G.other_ns),
+            }
+          end)
+          return diagnostic_count
+        end)
       )
     end)
 
     it("doesn't error after bwipeout called on buffer", function()
-      exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {{ lnum = 0, end_lnum = 0, col = 0, end_col = 0 }})
-        vim.cmd("bwipeout! " .. diagnostic_bufnr)
+      exec_lua(function()
+        vim.diagnostic.set(
+          _G.diagnostic_ns,
+          _G.diagnostic_bufnr,
+          { { lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
+        )
+        vim.cmd('bwipeout! ' .. _G.diagnostic_bufnr)
 
-        vim.diagnostic.reset(diagnostic_ns)
-      ]]
+        vim.diagnostic.reset(_G.diagnostic_ns)
+      end)
     end)
   end)
 
-  describe('get_next_pos()', function()
+  describe('get_next()', function()
     it('can find the next pos with only one namespace', function()
       eq(
         { 1, 1 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        return vim.diagnostic.get_next_pos()
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          local next = vim.diagnostic.get_next()
+          return { next.lnum, next.col }
+        end)
       )
     end)
 
     it('can find next pos with two errors', function()
       eq(
         { 4, 4 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-          make_error('Diagnostic #2', 4, 4, 4, 4),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_next_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+            _G.make_error('Diagnostic #2', 4, 4, 4, 4),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local next = vim.diagnostic.get_next({ namespace = _G.diagnostic_ns })
+          return { next.lnum, next.col }
+        end)
       )
     end)
 
     it('can cycle when position is past error', function()
       eq(
         { 1, 1 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_next_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local next = vim.diagnostic.get_next({ namespace = _G.diagnostic_ns })
+          return { next.lnum, next.col }
+        end)
       )
     end)
 
     it('will not cycle when wrap is off', function()
       eq(
-        false,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_next_pos { namespace = diagnostic_ns, wrap = false }
-      ]]
+        nil,
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local next = vim.diagnostic.get_next({ namespace = _G.diagnostic_ns, wrap = false })
+          return next
+        end)
       )
     end)
 
     it('can cycle even from the last line', function()
       eq(
         { 4, 4 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #2', 4, 4, 4, 4),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {vim.api.nvim_buf_line_count(0), 1})
-        return vim.diagnostic.get_prev_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #2', 4, 4, 4, 4),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { vim.api.nvim_buf_line_count(0), 1 })
+          local prev = vim.diagnostic.get_prev({ namespace = _G.diagnostic_ns })
+          return { prev.lnum, prev.col }
+        end)
       )
     end)
 
     it('works with diagnostics past the end of the line #16349', function()
       eq(
         { 4, 0 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 3, 9001, 3, 9001),
-          make_error('Diagnostic #2', 4, 0, 4, 0),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {1, 1})
-        vim.diagnostic.goto_next { float = false }
-        return vim.diagnostic.get_next_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 3, 9001, 3, 9001),
+            _G.make_error('Diagnostic #2', 4, 0, 4, 0),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          vim.diagnostic.jump({ count = 1, float = false })
+          local next = vim.diagnostic.get_next({ namespace = _G.diagnostic_ns })
+          return { next.lnum, next.col }
+        end)
       )
     end)
 
     it('works with diagnostics before the start of the line', function()
       eq(
         { 4, 0 },
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error('Diagnostic #1', 3, 9001, 3, 9001),
-            make_error('Diagnostic #2', 4, -1, 4, -1),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 3, 9001, 3, 9001),
+            _G.make_error('Diagnostic #2', 4, -1, 4, -1),
           })
-          vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-          vim.api.nvim_win_set_cursor(0, {1, 1})
-          vim.diagnostic.goto_next { float = false }
-          return vim.diagnostic.get_next_pos { namespace = diagnostic_ns }
-        ]]
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          vim.diagnostic.jump({ count = 1, float = false })
+          local next = vim.diagnostic.get_next({ namespace = _G.diagnostic_ns })
+          return { next.lnum, next.col }
+        end)
       )
     end)
 
     it('jumps to diagnostic with highest severity', function()
-      exec_lua([[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_info('Info', 1, 0, 1, 1),
-          make_error('Error', 2, 0, 2, 1),
-          make_warning('Warning', 3, 0, 3, 1),
-          make_error('Error', 4, 0, 4, 1),
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_info('Info', 1, 0, 1, 1),
+          _G.make_error('Error', 2, 0, 2, 1),
+          _G.make_warning('Warning', 3, 0, 3, 1),
+          _G.make_error('Error', 4, 0, 4, 1),
         })
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {1, 0})
-      ]])
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        vim.api.nvim_win_set_cursor(0, { 1, 0 })
+      end)
 
       eq(
         { 3, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next({_highest = true})
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1, _highest = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
 
       eq(
         { 5, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next({_highest = true})
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
-      )
-
-      exec_lua([[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_info('Info', 1, 0, 1, 1),
-          make_hint('Hint', 2, 0, 2, 1),
-          make_warning('Warning', 3, 0, 3, 1),
-          make_hint('Hint', 4, 0, 4, 1),
-          make_warning('Warning', 5, 0, 5, 1),
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1, _highest = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_info('Info', 1, 0, 1, 1),
+          _G.make_hint('Hint', 2, 0, 2, 1),
+          _G.make_warning('Warning', 3, 0, 3, 1),
+          _G.make_hint('Hint', 4, 0, 4, 1),
+          _G.make_warning('Warning', 5, 0, 5, 1),
         })
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {1, 0})
-      ]])
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        vim.api.nvim_win_set_cursor(0, { 1, 0 })
+      end)
 
       eq(
         { 4, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next({_highest = true})
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1, _highest = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
 
       eq(
         { 6, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next({_highest = true})
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1, _highest = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
     end)
 
     it('jumps to next diagnostic if severity is non-nil', function()
-      exec_lua([[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_info('Info', 1, 0, 1, 1),
-          make_error('Error', 2, 0, 2, 1),
-          make_warning('Warning', 3, 0, 3, 1),
-          make_error('Error', 4, 0, 4, 1),
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_info('Info', 1, 0, 1, 1),
+          _G.make_error('Error', 2, 0, 2, 1),
+          _G.make_warning('Warning', 3, 0, 3, 1),
+          _G.make_error('Error', 4, 0, 4, 1),
         })
 
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {1, 0})
-      ]])
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        vim.api.nvim_win_set_cursor(0, { 1, 0 })
+      end)
 
       eq(
         { 2, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next()
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
 
       eq(
         { 3, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next()
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
 
       eq(
         { 4, 0 },
-        exec_lua([[
-        vim.diagnostic.goto_next()
-        return vim.api.nvim_win_get_cursor(0)
-      ]])
+        exec_lua(function()
+          vim.diagnostic.jump({ count = 1 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
     end)
   end)
 
-  describe('get_prev_pos()', function()
-    it('can find the prev pos with only one namespace', function()
+  describe('get_prev()', function()
+    it('can find the previous diagnostic with only one namespace', function()
       eq(
         { 1, 1 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_prev_pos()
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local prev = vim.diagnostic.get_prev()
+          return { prev.lnum, prev.col }
+        end)
       )
     end)
 
-    it('can find prev pos with two errors', function()
+    it('can find the previous diagnostic with two errors', function()
       eq(
         { 1, 1 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-          make_error('Diagnostic #2', 4, 4, 4, 4),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_prev_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+            _G.make_error('Diagnostic #2', 4, 4, 4, 4),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local prev = vim.diagnostic.get_prev({ namespace = _G.diagnostic_ns })
+          return { prev.lnum, prev.col }
+        end)
       )
     end)
 
     it('can cycle when position is past error', function()
       eq(
         { 4, 4 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #2', 4, 4, 4, 4),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_prev_pos { namespace = diagnostic_ns }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #2', 4, 4, 4, 4),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local prev = vim.diagnostic.get_prev({ namespace = _G.diagnostic_ns })
+          return { prev.lnum, prev.col }
+        end)
       )
     end)
 
     it('respects wrap parameter', function()
       eq(
-        false,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #2', 4, 4, 4, 4),
-        })
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 1})
-        return vim.diagnostic.get_prev_pos { namespace = diagnostic_ns, wrap = false}
-      ]]
+        nil,
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #2', 4, 4, 4, 4),
+          })
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 1 })
+          local prev = vim.diagnostic.get_prev({ namespace = _G.diagnostic_ns, wrap = false })
+          return prev
+        end)
       )
     end)
 
     it('works on blank line #28397', function()
       eq(
         { 0, 2 },
-        exec_lua [[
-        local test_bufnr = vim.api.nvim_create_buf(true, false)
-        vim.api.nvim_buf_set_lines(test_bufnr, 0, -1, false, {
-          'first line',
-          '',
-          '',
-          'end line',
-        })
-        vim.diagnostic.set(diagnostic_ns, test_bufnr, {
-          make_info('Diagnostic #1', 0, 2, 0, 2),
-          make_info('Diagnostic #2', 2, 0, 2, 0),
-          make_info('Diagnostic #3', 2, 0, 2, 0),
+        exec_lua(function()
+          local test_bufnr = vim.api.nvim_create_buf(true, false)
+          vim.api.nvim_buf_set_lines(test_bufnr, 0, -1, false, {
+            'first line',
+            '',
+            '',
+            'end line',
+          })
+          vim.diagnostic.set(_G.diagnostic_ns, test_bufnr, {
+            _G.make_info('Diagnostic #1', 0, 2, 0, 2),
+            _G.make_info('Diagnostic #2', 2, 0, 2, 0),
+            _G.make_info('Diagnostic #3', 2, 0, 2, 0),
+          })
+          vim.api.nvim_win_set_buf(0, test_bufnr)
+          vim.api.nvim_win_set_cursor(0, { 3, 0 })
+          return vim.diagnostic.get_prev_pos { namespace = _G.diagnostic_ns }
+        end)
+      )
+    end)
+  end)
+
+  describe('jump()', function()
+    before_each(function()
+      exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 0, 0, 0, 2),
+          _G.make_error('Diagnostic #2', 1, 1, 1, 4),
+          _G.make_warning('Diagnostic #3', 2, -1, 2, -1),
+          _G.make_info('Diagnostic #4', 3, 0, 3, 3),
         })
-        vim.api.nvim_win_set_buf(0, test_bufnr)
-        vim.api.nvim_win_set_cursor(0, {3, 0})
-        return vim.diagnostic.get_prev_pos { namespace = diagnostic_ns}
-      ]]
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+      end)
+    end)
+
+    it('can move forward', function()
+      eq(
+        { 2, 1 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = 1 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 4, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = 3 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 4, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = math.huge, wrap = false })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+    end)
+
+    it('can move backward', function()
+      eq(
+        { 3, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 4, 0 })
+          vim.diagnostic.jump({ count = -1 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 1, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 4, 0 })
+          vim.diagnostic.jump({ count = -3 })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 1, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 4, 0 })
+          vim.diagnostic.jump({ count = -math.huge, wrap = false })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+    end)
+
+    it('can filter by severity', function()
+      eq(
+        { 3, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = 1, severity = vim.diagnostic.severity.WARN })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 3, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = 9999, severity = vim.diagnostic.severity.WARN })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+    end)
+
+    it('can wrap', function()
+      eq(
+        { 1, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 4, 0 })
+          vim.diagnostic.jump({ count = 1, wrap = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
+      )
+
+      eq(
+        { 4, 0 },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          vim.diagnostic.jump({ count = -1, wrap = true })
+          return vim.api.nvim_win_get_cursor(0)
+        end)
       )
     end)
   end)
 
   describe('get()', function()
     it('returns an empty table when no diagnostics are present', function()
-      eq({}, exec_lua [[return vim.diagnostic.get(diagnostic_bufnr, {namespace=diagnostic_ns})]])
+      eq(
+        {},
+        exec_lua [[return vim.diagnostic.get( _G.diagnostic_bufnr, {namespace=diagnostic_ns})]]
+      )
     end)
 
     it('returns all diagnostics when no severity is supplied', function()
       eq(
         2,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 1, 1, 2, 3),
-        })
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+          })
 
-        return #vim.diagnostic.get(diagnostic_bufnr)
-      ]]
+          return #vim.diagnostic.get(_G.diagnostic_bufnr)
+        end)
       )
     end)
 
     it('returns only requested diagnostics when severity range is supplied', function()
       eq(
         { 2, 3, 2 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 1, 1, 2, 3),
-          make_info("Ignored information", 1, 1, 2, 3),
-          make_hint("Here's a hint", 1, 1, 2, 3),
-        })
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_hint("Here's a hint", 1, 1, 2, 3),
+          })
 
-        return {
-          #vim.diagnostic.get(diagnostic_bufnr, { severity = {min=vim.diagnostic.severity.WARN} }),
-          #vim.diagnostic.get(diagnostic_bufnr, { severity = {max=vim.diagnostic.severity.WARN} }),
-          #vim.diagnostic.get(diagnostic_bufnr, {
-            severity = {
-              min=vim.diagnostic.severity.INFO,
-              max=vim.diagnostic.severity.WARN,
-            }
-          }),
-        }
-      ]]
+          return {
+            #vim.diagnostic.get(
+              _G.diagnostic_bufnr,
+              { severity = { min = vim.diagnostic.severity.WARN } }
+            ),
+            #vim.diagnostic.get(
+              _G.diagnostic_bufnr,
+              { severity = { max = vim.diagnostic.severity.WARN } }
+            ),
+            #vim.diagnostic.get(_G.diagnostic_bufnr, {
+              severity = {
+                min = vim.diagnostic.severity.INFO,
+                max = vim.diagnostic.severity.WARN,
+              },
+            }),
+          }
+        end)
       )
     end)
 
     it('returns only requested diagnostics when severities are supplied', function()
       eq(
         { 1, 1, 2 },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 1, 1, 2, 3),
-          make_info("Ignored information", 1, 1, 2, 3),
-          make_hint("Here's a hint", 1, 1, 2, 3),
-        })
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_hint("Here's a hint", 1, 1, 2, 3),
+          })
 
-        return {
-          #vim.diagnostic.get(diagnostic_bufnr, { severity = {vim.diagnostic.severity.WARN} }),
-          #vim.diagnostic.get(diagnostic_bufnr, { severity = {vim.diagnostic.severity.ERROR} }),
-          #vim.diagnostic.get(diagnostic_bufnr, {
-            severity = {
-              vim.diagnostic.severity.INFO,
-              vim.diagnostic.severity.WARN,
-            }
-          }),
-        }
-      ]]
+          return {
+            #vim.diagnostic.get(
+              _G.diagnostic_bufnr,
+              { severity = { vim.diagnostic.severity.WARN } }
+            ),
+            #vim.diagnostic.get(
+              _G.diagnostic_bufnr,
+              { severity = { vim.diagnostic.severity.ERROR } }
+            ),
+            #vim.diagnostic.get(_G.diagnostic_bufnr, {
+              severity = {
+                vim.diagnostic.severity.INFO,
+                vim.diagnostic.severity.WARN,
+              },
+            }),
+          }
+        end)
       )
     end)
 
     it('allows filtering by line', function()
       eq(
         2,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error("Error 1", 1, 1, 1, 5),
-          make_warning("Warning on Server 1", 1, 1, 2, 3),
-          make_info("Ignored information", 1, 1, 2, 3),
-          make_error("Error On Other Line", 3, 1, 3, 5),
-        })
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_error('Error On Other Line', 3, 1, 3, 5),
+          })
 
-        return #vim.diagnostic.get(diagnostic_bufnr, {lnum = 2})
-      ]]
+          return #vim.diagnostic.get(_G.diagnostic_bufnr, { lnum = 2 })
+        end)
       )
     end)
   end)
@@ -1215,118 +1511,144 @@ describe('vim.diagnostic', function()
   describe('count', function()
     it('returns actually present severity counts', function()
       eq(
-        exec_lua [[return {
-          [vim.diagnostic.severity.ERROR] = 4,
-          [vim.diagnostic.severity.WARN] = 3,
-          [vim.diagnostic.severity.INFO] = 2,
-          [vim.diagnostic.severity.HINT] = 1,
-        }]],
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Error 1", 1, 1, 1, 2),
-            make_error("Error 2", 1, 3, 1, 4),
-            make_error("Error 3", 1, 5, 1, 6),
-            make_error("Error 4", 1, 7, 1, 8),
-            make_warning("Warning 1", 2, 1, 2, 2),
-            make_warning("Warning 2", 2, 3, 2, 4),
-            make_warning("Warning 3", 2, 5, 2, 6),
-            make_info("Info 1", 3, 1, 3, 2),
-            make_info("Info 2", 3, 3, 3, 4),
-            make_hint("Hint 1", 4, 1, 4, 2),
+        exec_lua(function()
+          return {
+            [vim.diagnostic.severity.ERROR] = 4,
+            [vim.diagnostic.severity.WARN] = 3,
+            [vim.diagnostic.severity.INFO] = 2,
+            [vim.diagnostic.severity.HINT] = 1,
+          }
+        end),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 2),
+            _G.make_error('Error 2', 1, 3, 1, 4),
+            _G.make_error('Error 3', 1, 5, 1, 6),
+            _G.make_error('Error 4', 1, 7, 1, 8),
+            _G.make_warning('Warning 1', 2, 1, 2, 2),
+            _G.make_warning('Warning 2', 2, 3, 2, 4),
+            _G.make_warning('Warning 3', 2, 5, 2, 6),
+            _G.make_info('Info 1', 3, 1, 3, 2),
+            _G.make_info('Info 2', 3, 3, 3, 4),
+            _G.make_hint('Hint 1', 4, 1, 4, 2),
           })
-          return vim.diagnostic.count(diagnostic_bufnr)
-        ]]
-      )
-      eq(
-        exec_lua [[return {
-          [vim.diagnostic.severity.ERROR] = 2,
-          [vim.diagnostic.severity.INFO] = 1,
-        }]],
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Error 1", 1, 1, 1, 2),
-            make_error("Error 2", 1, 3, 1, 4),
-            make_info("Info 1", 3, 1, 3, 2),
+          return vim.diagnostic.count(_G.diagnostic_bufnr)
+        end)
+      )
+      eq(
+        exec_lua(function()
+          return {
+            [vim.diagnostic.severity.ERROR] = 2,
+            [vim.diagnostic.severity.INFO] = 1,
+          }
+        end),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 2),
+            _G.make_error('Error 2', 1, 3, 1, 4),
+            _G.make_info('Info 1', 3, 1, 3, 2),
           })
-          return vim.diagnostic.count(diagnostic_bufnr)
-        ]]
+          return vim.diagnostic.count(_G.diagnostic_bufnr)
+        end)
       )
     end)
 
     it('returns only requested diagnostics count when severity range is supplied', function()
       eq(
-        exec_lua [[return {
-          { [vim.diagnostic.severity.ERROR] = 1, [vim.diagnostic.severity.WARN] = 1 },
-          { [vim.diagnostic.severity.WARN] = 1,  [vim.diagnostic.severity.INFO] = 1, [vim.diagnostic.severity.HINT] = 1 },
-          { [vim.diagnostic.severity.WARN] = 1,  [vim.diagnostic.severity.INFO] = 1 },
-        }]],
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Error 1", 1, 1, 1, 5),
-            make_warning("Warning on Server 1", 1, 1, 2, 3),
-            make_info("Ignored information", 1, 1, 2, 3),
-            make_hint("Here's a hint", 1, 1, 2, 3),
+        exec_lua(function()
+          return {
+            { [vim.diagnostic.severity.ERROR] = 1, [vim.diagnostic.severity.WARN] = 1 },
+            {
+              [vim.diagnostic.severity.WARN] = 1,
+              [vim.diagnostic.severity.INFO] = 1,
+              [vim.diagnostic.severity.HINT] = 1,
+            },
+            { [vim.diagnostic.severity.WARN] = 1, [vim.diagnostic.severity.INFO] = 1 },
+          }
+        end),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_hint("Here's a hint", 1, 1, 2, 3),
           })
 
           return {
-            vim.diagnostic.count(diagnostic_bufnr, { severity = {min=vim.diagnostic.severity.WARN} }),
-            vim.diagnostic.count(diagnostic_bufnr, { severity = {max=vim.diagnostic.severity.WARN} }),
-            vim.diagnostic.count(diagnostic_bufnr, {
+            vim.diagnostic.count(
+              _G.diagnostic_bufnr,
+              { severity = { min = vim.diagnostic.severity.WARN } }
+            ),
+            vim.diagnostic.count(
+              _G.diagnostic_bufnr,
+              { severity = { max = vim.diagnostic.severity.WARN } }
+            ),
+            vim.diagnostic.count(_G.diagnostic_bufnr, {
               severity = {
-                min=vim.diagnostic.severity.INFO,
-                max=vim.diagnostic.severity.WARN,
-              }
+                min = vim.diagnostic.severity.INFO,
+                max = vim.diagnostic.severity.WARN,
+              },
             }),
           }
-        ]]
+        end)
       )
     end)
 
     it('returns only requested diagnostics when severities are supplied', function()
       eq(
-        exec_lua [[return {
-          { [vim.diagnostic.severity.WARN] = 1 },
-          { [vim.diagnostic.severity.ERROR] = 1 },
-          { [vim.diagnostic.severity.WARN] = 1, [vim.diagnostic.severity.INFO] = 1 },
-        }]],
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Error 1", 1, 1, 1, 5),
-            make_warning("Warning on Server 1", 1, 1, 2, 3),
-            make_info("Ignored information", 1, 1, 2, 3),
-            make_hint("Here's a hint", 1, 1, 2, 3),
+        exec_lua(function()
+          return {
+            { [vim.diagnostic.severity.WARN] = 1 },
+            { [vim.diagnostic.severity.ERROR] = 1 },
+            { [vim.diagnostic.severity.WARN] = 1, [vim.diagnostic.severity.INFO] = 1 },
+          }
+        end),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_hint("Here's a hint", 1, 1, 2, 3),
           })
 
           return {
-            vim.diagnostic.count(diagnostic_bufnr, { severity = {vim.diagnostic.severity.WARN} }),
-            vim.diagnostic.count(diagnostic_bufnr, { severity = {vim.diagnostic.severity.ERROR} }),
-            vim.diagnostic.count(diagnostic_bufnr, {
+            vim.diagnostic.count(
+              _G.diagnostic_bufnr,
+              { severity = { vim.diagnostic.severity.WARN } }
+            ),
+            vim.diagnostic.count(
+              _G.diagnostic_bufnr,
+              { severity = { vim.diagnostic.severity.ERROR } }
+            ),
+            vim.diagnostic.count(_G.diagnostic_bufnr, {
               severity = {
                 vim.diagnostic.severity.INFO,
                 vim.diagnostic.severity.WARN,
-              }
+              },
             }),
           }
-        ]]
+        end)
       )
     end)
 
     it('allows filtering by line', function()
       eq(
-        exec_lua [[return {
-          [vim.diagnostic.severity.WARN] = 1,
-          [vim.diagnostic.severity.INFO] = 1,
-        }]],
-        exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Error 1", 1, 1, 1, 5),
-            make_warning("Warning on Server 1", 1, 1, 2, 3),
-            make_info("Ignored information", 1, 1, 2, 3),
-            make_error("Error On Other Line", 3, 1, 3, 5),
+        exec_lua(function()
+          return {
+            [vim.diagnostic.severity.WARN] = 1,
+            [vim.diagnostic.severity.INFO] = 1,
+          }
+        end),
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Error 1', 1, 1, 1, 5),
+            _G.make_warning('Warning on Server 1', 1, 1, 2, 3),
+            _G.make_info('Ignored information', 1, 1, 2, 3),
+            _G.make_error('Error On Other Line', 3, 1, 3, 5),
           })
 
-          return vim.diagnostic.count(diagnostic_bufnr, {lnum = 2})
-        ]]
+          return vim.diagnostic.count(_G.diagnostic_bufnr, { lnum = 2 })
+        end)
       )
     end)
   end)
@@ -1335,137 +1657,138 @@ describe('vim.diagnostic', function()
     it('works with global, namespace, and ephemeral options', function()
       eq(
         1,
-        exec_lua [[
-        vim.diagnostic.config({
-          virtual_text = false,
-        })
+        exec_lua(function()
+          vim.diagnostic.config({
+            virtual_text = false,
+          })
 
-        vim.diagnostic.config({
-          virtual_text = true,
-          underline = false,
-        }, diagnostic_ns)
+          vim.diagnostic.config({
+            virtual_text = true,
+            underline = false,
+          }, _G.diagnostic_ns)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Some Error', 4, 4, 4, 4),
-        })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Some Error', 4, 4, 4, 4),
+          })
 
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
 
       eq(
         1,
-        exec_lua [[
-        vim.diagnostic.config({
-          virtual_text = false,
-        })
+        exec_lua(function()
+          vim.diagnostic.config({
+            virtual_text = false,
+          })
 
-        vim.diagnostic.config({
-          virtual_text = false,
-          underline = false,
-        }, diagnostic_ns)
+          vim.diagnostic.config({
+            virtual_text = false,
+            underline = false,
+          }, _G.diagnostic_ns)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Some Error', 4, 4, 4, 4),
-        }, {virtual_text = true})
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Some Error', 4, 4, 4, 4),
+          }, { virtual_text = true })
 
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
 
       eq(
         0,
-        exec_lua [[
-        vim.diagnostic.config({
-          virtual_text = false,
-        })
+        exec_lua(function()
+          vim.diagnostic.config({
+            virtual_text = false,
+          })
 
-        vim.diagnostic.config({
-          virtual_text = {severity=vim.diagnostic.severity.ERROR},
-          underline = false,
-        }, diagnostic_ns)
+          vim.diagnostic.config({
+            virtual_text = { severity = vim.diagnostic.severity.ERROR },
+            underline = false,
+          }, _G.diagnostic_ns)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning('Some Warning', 4, 4, 4, 4),
-        }, {virtual_text = true})
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Some Warning', 4, 4, 4, 4),
+          }, { virtual_text = true })
 
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
 
       eq(
         1,
-        exec_lua [[
-        vim.diagnostic.config({
-          virtual_text = false,
-        })
+        exec_lua(function()
+          vim.diagnostic.config({
+            virtual_text = false,
+          })
 
-        vim.diagnostic.config({
-          virtual_text = {severity=vim.diagnostic.severity.ERROR},
-          underline = false,
-        }, diagnostic_ns)
+          vim.diagnostic.config({
+            virtual_text = { severity = vim.diagnostic.severity.ERROR },
+            underline = false,
+          }, _G.diagnostic_ns)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning('Some Warning', 4, 4, 4, 4),
-        }, {
-          virtual_text = {} -- An empty table uses default values
-        })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Some Warning', 4, 4, 4, 4),
+          }, {
+            virtual_text = {}, -- An empty table uses default values
+          })
 
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
     end)
 
     it('can use functions for config values', function()
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
-          virtual_text = function() return true end,
-        }, diagnostic_ns)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Delayed Diagnostic', 4, 4, 4, 4),
+          virtual_text = function()
+            return true
+          end,
+        }, _G.diagnostic_ns)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
         })
-      ]]
+      end)
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(2, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(2, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
 
       -- Now, don't enable virtual text.
       -- We should have one less extmark displayed.
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
-          virtual_text = function() return false end,
-        }, diagnostic_ns)
-      ]]
+          virtual_text = function()
+            return false
+          end,
+        }, _G.diagnostic_ns)
+      end)
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(1, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(1, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
     end)
 
     it('allows filtering by severity', function()
       local get_extmark_count_with_severity = function(min_severity)
-        return exec_lua(
-          [[
+        return exec_lua(function()
           vim.diagnostic.config({
             underline = false,
             virtual_text = {
-              severity = {min=...},
+              severity = { min = min_severity },
             },
           })
 
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_warning('Delayed Diagnostic', 4, 4, 4, 4),
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Delayed Diagnostic', 4, 4, 4, 4),
           })
 
-          return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-        ]],
-          min_severity
-        )
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       end
 
       -- No messages with Error or higher
@@ -1477,152 +1800,158 @@ describe('vim.diagnostic', function()
     end)
 
     it('allows sorting by severity', function()
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
           underline = false,
           signs = true,
           virtual_text = true,
         })
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning('Warning', 4, 4, 4, 4),
-          make_error('Error', 4, 4, 4, 4),
-          make_info('Info', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_warning('Warning', 4, 4, 4, 4),
+          _G.make_error('Error', 4, 4, 4, 4),
+          _G.make_info('Info', 4, 4, 4, 4),
         })
 
-        function get_virt_text_and_signs(severity_sort)
+        function _G.get_virt_text_and_signs(severity_sort)
           vim.diagnostic.config({
             severity_sort = severity_sort,
           })
 
-          local virt_text = get_virt_text_extmarks(diagnostic_ns)[1][4].virt_text
+          local virt_text = _G.get_virt_text_extmarks(_G.diagnostic_ns)[1][4].virt_text
 
           local virt_texts = {}
           for i = 2, #virt_text - 1 do
-            table.insert(virt_texts, (string.gsub(virt_text[i][2], "DiagnosticVirtualText", "")))
+            table.insert(virt_texts, (string.gsub(virt_text[i][2], 'DiagnosticVirtualText', '')))
           end
 
-          local ns = vim.diagnostic.get_namespace(diagnostic_ns)
+          local ns = vim.diagnostic.get_namespace(_G.diagnostic_ns)
           local sign_ns = ns.user_data.sign_ns
           local signs = {}
-          local all_signs = vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, sign_ns, 0, -1, {type = 'sign', details = true})
+          local all_signs = vim.api.nvim_buf_get_extmarks(
+            _G.diagnostic_bufnr,
+            sign_ns,
+            0,
+            -1,
+            { type = 'sign', details = true }
+          )
           table.sort(all_signs, function(a, b)
             return a[1] > b[1]
           end)
 
           for _, v in ipairs(all_signs) do
-            local s = v[4].sign_hl_group:gsub('DiagnosticSign', "")
+            local s = v[4].sign_hl_group:gsub('DiagnosticSign', '')
             if not vim.tbl_contains(signs, s) then
               signs[#signs + 1] = s
             end
           end
 
-          return {virt_texts, signs}
+          return { virt_texts, signs }
         end
-      ]]
+      end)
 
-      local result = exec_lua [[return get_virt_text_and_signs(false)]]
+      local result = exec_lua [[return _G.get_virt_text_and_signs(false)]]
 
       -- Virt texts are defined lowest priority to highest, signs from
       -- highest to lowest
       eq({ 'Warn', 'Error', 'Info' }, result[1])
       eq({ 'Info', 'Error', 'Warn' }, result[2])
 
-      result = exec_lua [[return get_virt_text_and_signs(true)]]
+      result = exec_lua [[return _G.get_virt_text_and_signs(true)]]
       eq({ 'Info', 'Warn', 'Error' }, result[1])
       eq({ 'Error', 'Warn', 'Info' }, result[2])
 
-      result = exec_lua [[return get_virt_text_and_signs({ reverse = true })]]
+      result = exec_lua [[return _G.get_virt_text_and_signs({ reverse = true })]]
       eq({ 'Error', 'Warn', 'Info' }, result[1])
       eq({ 'Info', 'Warn', 'Error' }, result[2])
     end)
 
     it('can show diagnostic sources in virtual text', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0, 'source x'),
+          _G.make_error('Some error', 0, 0, 0, 0, 'source x'),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
           underline = false,
           virtual_text = {
             prefix = '',
             source = 'always',
-          }
+          },
         })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
         local virt_text = extmarks[1][4].virt_text[3][1]
         return virt_text
-      ]]
+      end)
       eq(' source x: Some error', result)
 
-      result = exec_lua [[
+      result = exec_lua(function()
         vim.diagnostic.config({
           underline = false,
           virtual_text = {
             prefix = '',
             source = 'if_many',
-          }
-        }, diagnostic_ns)
+          },
+        }, _G.diagnostic_ns)
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
         local virt_text = extmarks[1][4].virt_text[3][1]
         return virt_text
-      ]]
+      end)
       eq(' Some error', result)
 
-      result = exec_lua [[
+      result = exec_lua(function()
         local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0, 'source x'),
-          make_error('Another error', 1, 1, 1, 1, 'source y'),
+          _G.make_error('Some error', 0, 0, 0, 0, 'source x'),
+          _G.make_error('Another error', 1, 1, 1, 1, 'source y'),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
           underline = false,
           virtual_text = {
             prefix = '',
             source = 'if_many',
-          }
+          },
         })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        local virt_text = {extmarks[1][4].virt_text[3][1], extmarks[2][4].virt_text[3][1]}
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+        local virt_text = { extmarks[1][4].virt_text[3][1], extmarks[2][4].virt_text[3][1] }
         return virt_text
-      ]]
+      end)
       eq(' source x: Some error', result[1])
       eq(' source y: Another error', result[2])
     end)
 
     it('supports a format function for diagnostic messages', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         vim.diagnostic.config({
           underline = false,
           virtual_text = {
             prefix = '',
             format = function(diagnostic)
               if diagnostic.severity == vim.diagnostic.severity.ERROR then
-                return string.format("🔥 %s", diagnostic.message)
+                return string.format('🔥 %s', diagnostic.message)
               end
-              return string.format("👀 %s", diagnostic.message)
+              return string.format('👀 %s', diagnostic.message)
             end,
-          }
+          },
         })
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning('Warning', 0, 0, 0, 0),
-          make_error('Error', 1, 0, 1, 0),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_warning('Warning', 0, 0, 0, 0),
+          _G.make_error('Error', 1, 0, 1, 0),
         })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        return {extmarks[1][4].virt_text, extmarks[2][4].virt_text}
-      ]]
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+        return { extmarks[1][4].virt_text, extmarks[2][4].virt_text }
+      end)
       eq(' 👀 Warning', result[1][3][1])
       eq(' 🔥 Error', result[2][3][1])
     end)
 
     it('includes source for formatted diagnostics', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         vim.diagnostic.config({
           underline = false,
           virtual_text = {
@@ -1630,21 +1959,21 @@ describe('vim.diagnostic', function()
             source = 'always',
             format = function(diagnostic)
               if diagnostic.severity == vim.diagnostic.severity.ERROR then
-                return string.format("🔥 %s", diagnostic.message)
+                return string.format('🔥 %s', diagnostic.message)
               end
-              return string.format("👀 %s", diagnostic.message)
+              return string.format('👀 %s', diagnostic.message)
             end,
-          }
+          },
         })
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning('Warning', 0, 0, 0, 0, 'some_linter'),
-          make_error('Error', 1, 0, 1, 0, 'another_linter'),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_warning('Warning', 0, 0, 0, 0, 'some_linter'),
+          _G.make_error('Error', 1, 0, 1, 0, 'another_linter'),
         })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        return {extmarks[1][4].virt_text, extmarks[2][4].virt_text}
-      ]]
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+        return { extmarks[1][4].virt_text, extmarks[2][4].virt_text }
+      end)
       eq(' some_linter: 👀 Warning', result[1][3][1])
       eq(' another_linter: 🔥 Error', result[2][3][1])
     end)
@@ -1652,90 +1981,94 @@ describe('vim.diagnostic', function()
     it('can add a prefix to virtual text', function()
       eq(
         'E Some error',
-        exec_lua [[
-        local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0),
-        }
-
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
-          underline = false,
-          virtual_text = {
-            prefix = 'E',
-            suffix = '',
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Some error', 0, 0, 0, 0),
           }
-        })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        local prefix = extmarks[1][4].virt_text[2][1]
-        local message = extmarks[1][4].virt_text[3][1]
-        return prefix .. message
-      ]]
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
+            underline = false,
+            virtual_text = {
+              prefix = 'E',
+              suffix = '',
+            },
+          })
+
+          local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+          local prefix = extmarks[1][4].virt_text[2][1]
+          local message = extmarks[1][4].virt_text[3][1]
+          return prefix .. message
+        end)
       )
 
       eq(
         '[(1/1) err-code] Some error',
-        exec_lua [[
-        local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0, nil, 'err-code'),
-        }
-
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
-          underline = false,
-          virtual_text = {
-            prefix = function(diag, i, total) return string.format('[(%d/%d) %s]', i, total, diag.code) end,
-            suffix = '',
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Some error', 0, 0, 0, 0, nil, 'err-code'),
           }
-        })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        local prefix = extmarks[1][4].virt_text[2][1]
-        local message = extmarks[1][4].virt_text[3][1]
-        return prefix .. message
-      ]]
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
+            underline = false,
+            virtual_text = {
+              prefix = function(diag, i, total)
+                return string.format('[(%d/%d) %s]', i, total, diag.code)
+              end,
+              suffix = '',
+            },
+          })
+
+          local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+          local prefix = extmarks[1][4].virt_text[2][1]
+          local message = extmarks[1][4].virt_text[3][1]
+          return prefix .. message
+        end)
       )
     end)
 
     it('can add a suffix to virtual text', function()
       eq(
         ' Some error ✘',
-        exec_lua [[
-        local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0),
-        }
-
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
-          underline = false,
-          virtual_text = {
-            prefix = '',
-            suffix = ' ✘',
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Some error', 0, 0, 0, 0),
           }
-        })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        local virt_text = extmarks[1][4].virt_text[3][1]
-        return virt_text
-      ]]
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
+            underline = false,
+            virtual_text = {
+              prefix = '',
+              suffix = ' ✘',
+            },
+          })
+
+          local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+          local virt_text = extmarks[1][4].virt_text[3][1]
+          return virt_text
+        end)
       )
 
       eq(
         ' Some error [err-code]',
-        exec_lua [[
-        local diagnostics = {
-          make_error('Some error', 0, 0, 0, 0, nil, 'err-code'),
-        }
-
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics, {
-          underline = false,
-          virtual_text = {
-            prefix = '',
-            suffix = function(diag) return string.format(' [%s]', diag.code) end,
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Some error', 0, 0, 0, 0, nil, 'err-code'),
           }
-        })
 
-        local extmarks = get_virt_text_extmarks(diagnostic_ns)
-        local virt_text = extmarks[1][4].virt_text[3][1]
-        return virt_text
-      ]]
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics, {
+            underline = false,
+            virtual_text = {
+              prefix = '',
+              suffix = function(diag)
+                return string.format(' [%s]', diag.code)
+              end,
+            },
+          })
+
+          local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+          local virt_text = extmarks[1][4].virt_text[3][1]
+          return virt_text
+        end)
       )
     end)
   end)
@@ -1749,80 +2082,80 @@ describe('vim.diagnostic', function()
     end)
 
     it('can perform updates after insert_leave', function()
-      exec_lua [[vim.api.nvim_set_current_buf(diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
       -- Save the diagnostics
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
           update_in_insert = false,
         })
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Delayed Diagnostic', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
         })
-      ]]
+      end)
 
       -- No diagnostics displayed yet.
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(0, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(0, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
 
       api.nvim_input('<esc>')
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(2, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(2, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
     end)
 
     it('does not perform updates when not needed', function()
-      exec_lua [[vim.api.nvim_set_current_buf(diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
       -- Save the diagnostics
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
           update_in_insert = false,
           virtual_text = true,
         })
 
-        DisplayCount = 0
+        _G.DisplayCount = 0
         local set_virtual_text = vim.diagnostic.handlers.virtual_text.show
         vim.diagnostic.handlers.virtual_text.show = function(...)
-          DisplayCount = DisplayCount + 1
+          _G.DisplayCount = _G.DisplayCount + 1
           return set_virtual_text(...)
         end
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Delayed Diagnostic', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
         })
-      ]]
+      end)
 
       -- No diagnostics displayed yet.
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(0, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
-      eq(0, exec_lua [[return DisplayCount]])
+      eq(0, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
+      eq(0, exec_lua [[return _G.DisplayCount]])
 
       api.nvim_input('<esc>')
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(2, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
-      eq(1, exec_lua [[return DisplayCount]])
+      eq(2, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
+      eq(1, exec_lua [[return _G.DisplayCount]])
 
       -- Go in and out of insert mode one more time.
       api.nvim_input('o')
@@ -1832,52 +2165,51 @@ describe('vim.diagnostic', function()
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       -- Should not have set the virtual text again.
-      eq(1, exec_lua [[return DisplayCount]])
+      eq(1, exec_lua [[return _G.DisplayCount]])
     end)
 
     it('never sets virtual text, in combination with insert leave', function()
-      exec_lua [[vim.api.nvim_set_current_buf(diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
       -- Save the diagnostics
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
           update_in_insert = false,
           virtual_text = false,
         })
 
-
-        DisplayCount = 0
+        _G.DisplayCount = 0
         local set_virtual_text = vim.diagnostic.handlers.virtual_text.show
         vim.diagnostic.handlers.virtual_text.show = function(...)
-          DisplayCount = DisplayCount + 1
+          _G.DisplayCount = _G.DisplayCount + 1
           return set_virtual_text(...)
         end
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Delayed Diagnostic', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
         })
-      ]]
+      end)
 
       -- No diagnostics displayed yet.
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(0, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
-      eq(0, exec_lua [[return DisplayCount]])
+      eq(0, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
+      eq(0, exec_lua [[return _G.DisplayCount]])
 
       api.nvim_input('<esc>')
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(1, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
-      eq(0, exec_lua [[return DisplayCount]])
+      eq(1, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
+      eq(0, exec_lua [[return _G.DisplayCount]])
 
       -- Go in and out of insert mode one more time.
       api.nvim_input('o')
@@ -1887,124 +2219,136 @@ describe('vim.diagnostic', function()
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       -- Should not have set the virtual text still.
-      eq(0, exec_lua [[return DisplayCount]])
+      eq(0, exec_lua [[return _G.DisplayCount]])
     end)
 
     it('can perform updates while in insert mode, if desired', function()
-      exec_lua [[vim.api.nvim_set_current_buf(diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
       -- Save the diagnostics
-      exec_lua [[
+      exec_lua(function()
         vim.diagnostic.config({
           update_in_insert = true,
         })
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Delayed Diagnostic', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
         })
-      ]]
+      end)
 
       -- Diagnostics are displayed, because the user wanted them that way!
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(2, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(2, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
 
       api.nvim_input('<esc>')
       eq({ mode = 'n', blocking = false }, api.nvim_get_mode())
 
       eq(
         1,
-        exec_lua [[return count_diagnostics(diagnostic_bufnr, vim.diagnostic.severity.ERROR, diagnostic_ns)]]
+        exec_lua [[return _G.count_diagnostics( _G.diagnostic_bufnr, vim.diagnostic.severity.ERROR,  _G.diagnostic_ns)]]
       )
-      eq(2, exec_lua [[return count_extmarks(diagnostic_bufnr, diagnostic_ns)]])
+      eq(2, exec_lua [[return  _G.count_extmarks( _G.diagnostic_bufnr,  _G.diagnostic_ns)]])
     end)
 
     it('can set diagnostics without displaying them', function()
       eq(
         0,
-        exec_lua [[
-        vim.diagnostic.enable(false, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
-        })
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+        exec_lua(function()
+          vim.diagnostic.enable(false, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
+          })
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
 
       eq(
         2,
-        exec_lua [[
-        vim.diagnostic.enable(true, { bufnr = diagnostic_bufnr, ns_id = diagnostic_ns })
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+        exec_lua(function()
+          vim.diagnostic.enable(true, { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns })
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
     end)
 
     it('can set display options', function()
       eq(
         0,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
-        }, { virtual_text = false, underline = false })
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
+          }, { virtual_text = false, underline = false })
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
 
       eq(
         1,
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
-        }, { virtual_text = true, underline = false })
-        return count_extmarks(diagnostic_bufnr, diagnostic_ns)
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic From Server 1:1', 1, 1, 1, 1),
+          }, { virtual_text = true, underline = false })
+          return _G.count_extmarks(_G.diagnostic_bufnr, _G.diagnostic_ns)
+        end)
       )
     end)
 
     it('sets and clears signs #26193 #26555', function()
       do
-        local result = exec_lua [[
+        local result = exec_lua(function()
           vim.diagnostic.config({
             signs = true,
           })
 
           local diagnostics = {
-            make_error('Error', 1, 1, 1, 2),
-            make_warning('Warning', 3, 3, 3, 3),
+            _G.make_error('Error', 1, 1, 1, 2),
+            _G.make_warning('Warning', 3, 3, 3, 3),
           }
 
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
 
-          local ns = vim.diagnostic.get_namespace(diagnostic_ns)
+          local ns = vim.diagnostic.get_namespace(_G.diagnostic_ns)
           local sign_ns = ns.user_data.sign_ns
 
-          local signs = vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, sign_ns, 0, -1, {type ='sign', details = true})
+          local signs = vim.api.nvim_buf_get_extmarks(
+            _G.diagnostic_bufnr,
+            sign_ns,
+            0,
+            -1,
+            { type = 'sign', details = true }
+          )
           local result = {}
           for _, s in ipairs(signs) do
             result[#result + 1] = { lnum = s[2] + 1, name = s[4].sign_hl_group }
           end
           return result
-        ]]
+        end)
 
         eq({ 2, 'DiagnosticSignError' }, { result[1].lnum, result[1].name })
         eq({ 4, 'DiagnosticSignWarn' }, { result[2].lnum, result[2].name })
       end
 
       do
-        local result = exec_lua [[
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {})
+        local result = exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {})
 
-          local ns = vim.diagnostic.get_namespace(diagnostic_ns)
+          local ns = vim.diagnostic.get_namespace(_G.diagnostic_ns)
           local sign_ns = ns.user_data.sign_ns
 
-          return vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, sign_ns, 0, -1, {type ='sign', details = true})
-        ]]
+          return vim.api.nvim_buf_get_extmarks(
+            _G.diagnostic_bufnr,
+            sign_ns,
+            0,
+            -1,
+            { type = 'sign', details = true }
+          )
+        end)
 
         eq({}, result)
       end
@@ -2019,22 +2363,28 @@ describe('vim.diagnostic', function()
       n.command('sign define DiagnosticSignInfo text= texthl= linehl=Underlined numhl=Underlined')
       n.command('sign define DiagnosticSignHint text= texthl= linehl=Underlined numhl=Underlined')
 
-      local result = exec_lua [[
+      local result = exec_lua(function()
         vim.diagnostic.config({
           signs = true,
         })
 
         local diagnostics = {
-          make_error('Error', 1, 1, 1, 2),
-          make_warning('Warning', 3, 3, 3, 3),
+          _G.make_error('Error', 1, 1, 1, 2),
+          _G.make_warning('Warning', 3, 3, 3, 3),
         }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
 
-        local ns = vim.diagnostic.get_namespace(diagnostic_ns)
+        local ns = vim.diagnostic.get_namespace(_G.diagnostic_ns)
         local sign_ns = ns.user_data.sign_ns
 
-        local signs = vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, sign_ns, 0, -1, {type ='sign', details = true})
+        local signs = vim.api.nvim_buf_get_extmarks(
+          _G.diagnostic_bufnr,
+          sign_ns,
+          0,
+          -1,
+          { type = 'sign', details = true }
+        )
         local result = {}
         for _, s in ipairs(signs) do
           result[#result + 1] = {
@@ -2046,7 +2396,7 @@ describe('vim.diagnostic', function()
           }
         end
         return result
-      ]]
+      end)
 
       eq({
         lnum = 2,
@@ -2070,65 +2420,67 @@ describe('vim.diagnostic', function()
     it('can display a header', function()
       eq(
         { 'Diagnostics:', '1. Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float()
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float()
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { "We're no strangers to love...", '1. Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = "We're no strangers to love..."})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = "We're no strangers to love..." })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { 'You know the rules', '1. Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = {'You know the rules', 'Search'}})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = { 'You know the rules', 'Search' } })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
     it('can show diagnostics from the whole buffer', function()
       eq(
         { '1. Syntax error', '2. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 1, 1, 1, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope="buffer"})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, scope = 'buffer' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
@@ -2136,37 +2488,70 @@ describe('vim.diagnostic', function()
       -- Using cursor position
       eq(
         { '1. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 1, 1, 1, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        vim.api.nvim_win_set_cursor(0, {2, 1})
-        local float_bufnr, winnr = vim.diagnostic.open_float({header=false})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 2, 1 })
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       -- With specified position
       eq(
         { '1. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 1, 1, 1, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        vim.api.nvim_win_set_cursor(0, {1, 1})
-        local float_bufnr, winnr = vim.diagnostic.open_float({header=false, pos=1})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, pos = 1 })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
+      )
+
+      -- End position is exclusive
+      eq(
+        nil,
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 1, 1, 2, 0),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local _, winnr = vim.diagnostic.open_float(0, { header = false, pos = { 2, 0 } })
+          return winnr
+        end)
+      )
+
+      -- Works when width == 0
+      eq(
+        { '1. Syntax error' },
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 2, 0, 2, 0),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(0, { header = false, pos = { 2, 1 } })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
@@ -2174,55 +2559,94 @@ describe('vim.diagnostic', function()
       -- Using cursor position
       eq(
         { 'Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 1, 1, 1, 2),
-          make_warning("Some warning", 1, 3, 1, 4),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        vim.api.nvim_win_set_cursor(0, {2, 2})
-        local float_bufnr, winnr = vim.diagnostic.open_float({header=false, scope="cursor"})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 1, 1, 1, 3),
+            _G.make_warning('Some warning', 1, 3, 1, 4),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 2, 2 })
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, scope = 'cursor' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       -- With specified position
       eq(
         { 'Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 1, 1, 1, 2),
-          make_warning("Some warning", 1, 3, 1, 4),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        vim.api.nvim_win_set_cursor(0, {1, 1})
-        local float_bufnr, winnr = vim.diagnostic.open_float({header=false, scope="cursor", pos={1,3}})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 1, 1, 1, 3),
+            _G.make_warning('Some warning', 1, 3, 1, 4),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = false, scope = 'cursor', pos = { 1, 3 } })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       -- With column position past the end of the line. #16062
       eq(
         { 'Syntax error' },
-        exec_lua [[
-        local first_line_len = #vim.api.nvim_buf_get_lines(diagnostic_bufnr, 0, 1, true)[1]
-        local diagnostics = {
-          make_error("Syntax error", 0, first_line_len + 1, 1, 0),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        vim.api.nvim_win_set_cursor(0, {1, 1})
-        local float_bufnr, winnr = vim.diagnostic.open_float({header=false, scope="cursor", pos={0,first_line_len}})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local first_line_len = #vim.api.nvim_buf_get_lines(_G.diagnostic_bufnr, 0, 1, true)[1]
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, first_line_len + 1, 1, 0),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local float_bufnr, winnr = vim.diagnostic.open_float({
+            header = false,
+            scope = 'cursor',
+            pos = { 0, first_line_len },
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
+      )
+
+      -- End position is exclusive
+      eq(
+        nil,
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local _, winnr =
+            vim.diagnostic.open_float(0, { header = false, scope = 'cursor', pos = { 1, 3 } })
+          return winnr
+        end)
+      )
+
+      -- Works when width == 0
+      eq(
+        { 'Syntax error' },
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 2, 0, 2, 0),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          vim.api.nvim_win_set_cursor(0, { 1, 1 })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = false, scope = 'cursor', pos = { 2, 1 } })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
@@ -2234,17 +2658,17 @@ describe('vim.diagnostic', function()
         --    1. <msg>
         eq(
           2,
-          exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr)
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return #lines
-      ]]
+          exec_lua(function()
+            local diagnostics = {
+              _G.make_error('Syntax error', 0, 1, 0, 3),
+            }
+            vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+            vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+            local float_bufnr, winnr = vim.diagnostic.open_float(_G.diagnostic_bufnr)
+            local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+            vim.api.nvim_win_close(winnr, true)
+            return #lines
+          end)
         )
       end
     )
@@ -2252,43 +2676,44 @@ describe('vim.diagnostic', function()
     it('only reports diagnostics from the current buffer when bufnr is omitted #15710', function()
       eq(
         2,
-        exec_lua [[
-        local other_bufnr = vim.api.nvim_create_buf(true, false)
-        local buf_1_diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        local buf_2_diagnostics = {
-          make_warning("Some warning", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, buf_1_diagnostics)
-        vim.diagnostic.set(other_ns, other_bufnr, buf_2_diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float()
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return #lines
-      ]]
+        exec_lua(function()
+          local other_bufnr = vim.api.nvim_create_buf(true, false)
+          local buf_1_diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          local buf_2_diagnostics = {
+            _G.make_warning('Some warning', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, buf_1_diagnostics)
+          vim.diagnostic.set(_G.other_ns, other_bufnr, buf_2_diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float()
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return #lines
+        end)
       )
     end)
 
     it('allows filtering by namespace', function()
       eq(
         2,
-        exec_lua [[
-        local ns_1_diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        local ns_2_diagnostics = {
-          make_warning("Some warning", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, ns_1_diagnostics)
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, ns_2_diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {namespace = diagnostic_ns})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return #lines
-      ]]
+        exec_lua(function()
+          local ns_1_diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          local ns_2_diagnostics = {
+            _G.make_warning('Some warning', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, ns_1_diagnostics)
+          vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, ns_2_diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { namespace = _G.diagnostic_ns })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return #lines
+        end)
       )
     end)
 
@@ -2299,17 +2724,18 @@ describe('vim.diagnostic', function()
         --    1. <msg>
         eq(
           1,
-          exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {header = false})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return #lines
-      ]]
+          exec_lua(function()
+            local diagnostics = {
+              _G.make_error('Syntax error', 0, 1, 0, 3),
+            }
+            vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+            vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+            local float_bufnr, winnr =
+              vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false })
+            local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+            vim.api.nvim_win_close(winnr, true)
+            return #lines
+          end)
         )
       end
     )
@@ -2317,138 +2743,141 @@ describe('vim.diagnostic', function()
     it('clamps diagnostic line numbers within the valid range', function()
       eq(
         1,
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 6, 0, 6, 0),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {header = false, pos = 5})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return #lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 6, 0, 6, 0),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false, pos = 5 })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return #lines
+        end)
       )
     end)
 
     it('can show diagnostic source', function()
-      exec_lua [[vim.api.nvim_win_set_buf(0, diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_win_set_buf(0,  _G.diagnostic_bufnr)]]
 
       eq(
         { '1. Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3, "source x"),
-        }
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {
-          header = false,
-          source = "if_many",
-        })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3, 'source x'),
+          }
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float(_G.diagnostic_bufnr, {
+            header = false,
+            source = 'if_many',
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. source x: Syntax error' },
-        exec_lua [[
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {
-          header = false,
-          source = "always",
-        })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local float_bufnr, winnr = vim.diagnostic.open_float(_G.diagnostic_bufnr, {
+            header = false,
+            source = 'always',
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. source x: Syntax error', '2. source y: Another error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3, "source x"),
-          make_error("Another error", 0, 1, 0, 3, "source y"),
-        }
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, {
-          header = false,
-          source = "if_many",
-        })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3, 'source x'),
+            _G.make_error('Another error', 0, 1, 0, 3, 'source y'),
+          }
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float(_G.diagnostic_bufnr, {
+            header = false,
+            source = 'if_many',
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
     it('respects severity_sort', function()
-      exec_lua [[vim.api.nvim_win_set_buf(0, diagnostic_bufnr)]]
+      exec_lua [[vim.api.nvim_win_set_buf(0,  _G.diagnostic_bufnr)]]
 
       eq(
         { '1. Syntax error', '2. Info', '3. Error', '4. Warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_info('Info', 0, 3, 0, 4),
-          make_error('Error', 0, 2, 0, 2),
-          make_warning('Warning', 0, 0, 0, 1),
-        }
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_info('Info', 0, 3, 0, 4),
+            _G.make_error('Error', 0, 2, 0, 2),
+            _G.make_warning('Warning', 0, 0, 0, 1),
+          }
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
 
-        vim.diagnostic.config({severity_sort = false})
+          vim.diagnostic.config({ severity_sort = false })
 
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. Syntax error', '2. Error', '3. Warning', '4. Info' },
-        exec_lua [[
-        vim.diagnostic.config({severity_sort = true})
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          vim.diagnostic.config({ severity_sort = true })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. Info', '2. Warning', '3. Error', '4. Syntax error' },
-        exec_lua [[
-        vim.diagnostic.config({severity_sort = { reverse = true } })
-        local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          vim.diagnostic.config({ severity_sort = { reverse = true } })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
     it('can filter by severity', function()
       local count_diagnostics_with_severity = function(min_severity, max_severity)
-        return exec_lua(
-          [[
-          local min_severity, max_severity = ...
+        return exec_lua(function()
           vim.diagnostic.config({
             float = {
-              severity = {min=min_severity, max=max_severity},
+              severity = { min = min_severity, max = max_severity },
             },
           })
 
-          vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-            make_error("Syntax error", 0, 1, 0, 3),
-            make_info('Info', 0, 3, 0, 4),
-            make_error('Error', 0, 2, 0, 2),
-            make_warning('Warning', 0, 0, 0, 1),
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_info('Info', 0, 3, 0, 4),
+            _G.make_error('Error', 0, 2, 0, 2),
+            _G.make_warning('Warning', 0, 0, 0, 1),
           })
 
-          local float_bufnr, winnr = vim.diagnostic.open_float(diagnostic_bufnr, { header = false })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(_G.diagnostic_bufnr, { header = false })
           if not float_bufnr then
             return 0
           end
@@ -2456,10 +2885,7 @@ describe('vim.diagnostic', function()
           local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
           vim.api.nvim_win_close(winnr, true)
           return #lines
-        ]],
-          min_severity,
-          max_severity
-        )
+        end)
       end
 
       eq(2, count_diagnostics_with_severity('ERROR'))
@@ -2473,83 +2899,84 @@ describe('vim.diagnostic', function()
       -- Default is to add a number
       eq(
         { '1. Syntax error', '2. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 1, 1, 1, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope = "buffer"})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, scope = 'buffer' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { 'Syntax error', 'Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 1, 1, 1, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope = "buffer", prefix = ""})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 1, 1, 1, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = false, scope = 'buffer', prefix = '' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. Syntax error', '2. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-          make_warning("Some warning", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({
-          header = false,
-          prefix = function(_, i, total)
-            -- Only show a number if there is more than one diagnostic
-            if total > 1 then
-              return string.format("%d. ", i)
-            end
-            return ""
-          end,
-        })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+            _G.make_warning('Some warning', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({
+            header = false,
+            prefix = function(_, i, total)
+              -- Only show a number if there is more than one diagnostic
+              if total > 1 then
+                return string.format('%d. ', i)
+              end
+              return ''
+            end,
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { 'Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({
-          header = false,
-          prefix = function(_, i, total)
-            -- Only show a number if there is more than one diagnostic
-            if total > 1 then
-              return string.format("%d. ", i)
-            end
-            return ""
-          end,
-        })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({
+            header = false,
+            prefix = function(_, i, total)
+              -- Only show a number if there is more than one diagnostic
+              if total > 1 then
+                return string.format('%d. ', i)
+              end
+              return ''
+            end,
+          })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
@@ -2562,50 +2989,51 @@ describe('vim.diagnostic', function()
       -- Default is to render the diagnostic error code
       eq(
         { '1. Syntax error [code-x]', '2. Some warning [code-y]' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3, nil, "code-x"),
-          make_warning("Some warning", 1, 1, 1, 3, nil, "code-y"),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope = "buffer"})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3, nil, 'code-x'),
+            _G.make_warning('Some warning', 1, 1, 1, 3, nil, 'code-y'),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, scope = 'buffer' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
         { '1. Syntax error', '2. Some warning' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3, nil, "code-x"),
-          make_warning("Some warning", 1, 1, 1, 3, nil, "code-y"),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope = "buffer", suffix = ""})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3, nil, 'code-x'),
+            _G.make_warning('Some warning', 1, 1, 1, 3, nil, 'code-y'),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float({ header = false, scope = 'buffer', suffix = '' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       -- Suffix is rendered on the last line of a multiline diagnostic
       eq(
         { '1. Syntax error', '   More context [code-x]' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error\nMore context", 0, 1, 0, 3, nil, "code-x"),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float({header = false, scope = "buffer"})
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error\nMore context', 0, 1, 0, 3, nil, 'code-x'),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float({ header = false, scope = 'buffer' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       eq(
@@ -2617,96 +3045,134 @@ describe('vim.diagnostic', function()
     it('works with the old signature', function()
       eq(
         { '1. Syntax error' },
-        exec_lua [[
-        local diagnostics = {
-          make_error("Syntax error", 0, 1, 0, 3),
-        }
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          local diagnostics = {
+            _G.make_error('Syntax error', 0, 1, 0, 3),
+          }
+          vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+          local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
 
     it('works for multi-line diagnostics #21949', function()
-      -- open float failed non diagnostic lnum
-      eq(
-        vim.NIL,
-        exec_lua [[
+      -- create diagnostic
+      exec_lua(function()
         local diagnostics = {
-          make_error("Error in two lines lnum is 1 and end_lnum is 2", 1, 1, 2, 3),
+          _G.make_error('Error in two lines lnum is 1 and end_lnum is 2', 1, 1, 2, 3),
         }
-        local winids = {}
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, diagnostics)
-        local _, winnr = vim.diagnostic.open_float(0, { header = false })
-        return winnr
-      ]]
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, diagnostics)
+      end)
+
+      -- open float failed non diagnostic lnum
+      eq(
+        nil,
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          local _, winnr = vim.diagnostic.open_float(0, { header = false })
+          return winnr
+        end)
+      )
+      eq(
+        nil,
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 1, 0 })
+          local _, winnr = vim.diagnostic.open_float(0, { header = false, scope = 'cursor' })
+          return winnr
+        end)
       )
 
       -- can open a float window on lnum 1
       eq(
         { '1. Error in two lines lnum is 1 and end_lnum is 2' },
-        exec_lua [[
-        vim.api.nvim_win_set_cursor(0, {2, 0})
-        local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 2, 0 })
+          local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
+      )
+
+      -- can open a cursor-scoped float window on lnum 1
+      eq(
+        { 'Error in two lines lnum is 1 and end_lnum is 2' },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 2, 1 })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(0, { header = false, scope = 'cursor' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
 
       -- can open a float window on end_lnum 2
       eq(
         { '1. Error in two lines lnum is 1 and end_lnum is 2' },
-        exec_lua [[
-        vim.api.nvim_win_set_cursor(0, {3, 0})
-        local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
-        local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
-        vim.api.nvim_win_close(winnr, true)
-        return lines
-      ]]
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 3, 0 })
+          local float_bufnr, winnr = vim.diagnostic.open_float(0, { header = false })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
+      )
+
+      -- can open a cursor-scoped float window on end_lnum 2
+      eq(
+        { 'Error in two lines lnum is 1 and end_lnum is 2' },
+        exec_lua(function()
+          vim.api.nvim_win_set_cursor(0, { 3, 2 })
+          local float_bufnr, winnr =
+            vim.diagnostic.open_float(0, { header = false, scope = 'cursor' })
+          local lines = vim.api.nvim_buf_get_lines(float_bufnr, 0, -1, false)
+          vim.api.nvim_win_close(winnr, true)
+          return lines
+        end)
       )
     end)
   end)
 
   describe('setloclist()', function()
     it('sets diagnostics in lnum order', function()
-      local loc_list = exec_lua [[
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+      local loc_list = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Farther Diagnostic', 4, 4, 4, 4),
-          make_error('Lower Diagnostic', 1, 1, 1, 1),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Farther Diagnostic', 4, 4, 4, 4),
+          _G.make_error('Lower Diagnostic', 1, 1, 1, 1),
         })
 
         vim.diagnostic.setloclist()
 
         return vim.fn.getloclist(0)
-      ]]
+      end)
 
       assert(loc_list[1].lnum < loc_list[2].lnum)
     end)
 
     it('sets diagnostics in lnum order, regardless of namespace', function()
-      local loc_list = exec_lua [[
-        vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
+      local loc_list = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
 
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Lower Diagnostic', 1, 1, 1, 1),
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Lower Diagnostic', 1, 1, 1, 1),
         })
 
-        vim.diagnostic.set(other_ns, diagnostic_bufnr, {
-          make_warning('Farther Diagnostic', 4, 4, 4, 4),
+        vim.diagnostic.set(_G.other_ns, _G.diagnostic_bufnr, {
+          _G.make_warning('Farther Diagnostic', 4, 4, 4, 4),
         })
 
         vim.diagnostic.setloclist()
 
         return vim.fn.getloclist(0)
-      ]]
+      end)
 
       assert(loc_list[1].lnum < loc_list[2].lnum)
     end)
@@ -2725,22 +3191,23 @@ describe('vim.diagnostic', function()
       }
       eq(
         diagnostic,
-        exec_lua(
-          [[
-        return vim.diagnostic.match(..., "^(%w+): [^:]+:(%d+):(%d+):(.+)$", {"severity", "lnum", "col", "message"})
-      ]],
-          msg
-        )
+        exec_lua(function()
+          return vim.diagnostic.match(
+            msg,
+            '^(%w+): [^:]+:(%d+):(%d+):(.+)$',
+            { 'severity', 'lnum', 'col', 'message' }
+          )
+        end)
       )
     end)
 
     it('returns nil if the pattern fails to match', function()
       eq(
-        NIL,
-        exec_lua [[
-        local msg = "The answer to life, the universe, and everything is"
-        return vim.diagnostic.match(msg, "This definitely will not match", {})
-      ]]
+        nil,
+        exec_lua(function()
+          local msg = 'The answer to life, the universe, and everything is'
+          return vim.diagnostic.match(msg, 'This definitely will not match', {})
+        end)
       )
     end)
 
@@ -2756,12 +3223,15 @@ describe('vim.diagnostic', function()
       }
       eq(
         diagnostic,
-        exec_lua(
-          [[
-        return vim.diagnostic.match(..., "^[^:]+:(%d+):(.+)$", {"lnum", "message"}, nil, {severity = vim.diagnostic.severity.INFO})
-      ]],
-          msg
-        )
+        exec_lua(function()
+          return vim.diagnostic.match(
+            msg,
+            '^[^:]+:(%d+):(.+)$',
+            { 'lnum', 'message' },
+            nil,
+            { severity = vim.diagnostic.severity.INFO }
+          )
+        end)
       )
     end)
 
@@ -2777,38 +3247,40 @@ describe('vim.diagnostic', function()
       }
       eq(
         diagnostic,
-        exec_lua(
-          [[
-        return vim.diagnostic.match(..., "^(%d+):(%w+):(.+)$", {"lnum", "severity", "message"}, {FATAL = vim.diagnostic.severity.ERROR})
-      ]],
-          msg
-        )
+        exec_lua(function()
+          return vim.diagnostic.match(
+            msg,
+            '^(%d+):(%w+):(.+)$',
+            { 'lnum', 'severity', 'message' },
+            { FATAL = vim.diagnostic.severity.ERROR }
+          )
+        end)
       )
     end)
   end)
 
   describe('toqflist() and fromqflist()', function()
     it('works', function()
-      local result = exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Error 1', 0, 1, 0, 1),
-        make_error('Error 2', 1, 1, 1, 1),
-        make_warning('Warning', 2, 2, 2, 2),
-      })
+      local result = exec_lua(function()
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error 1', 0, 1, 0, 1),
+          _G.make_error('Error 2', 1, 1, 1, 1),
+          _G.make_warning('Warning', 2, 2, 2, 2),
+        })
 
-      local diagnostics = vim.diagnostic.get(diagnostic_bufnr)
-      vim.fn.setqflist(vim.diagnostic.toqflist(diagnostics))
-      local list = vim.fn.getqflist()
-      local new_diagnostics = vim.diagnostic.fromqflist(list)
+        local diagnostics = vim.diagnostic.get(_G.diagnostic_bufnr)
+        vim.fn.setqflist(vim.diagnostic.toqflist(diagnostics))
+        local list = vim.fn.getqflist()
+        local new_diagnostics = vim.diagnostic.fromqflist(list)
 
-      -- Remove namespace since it isn't present in the return value of
-      -- fromlist()
-      for _, v in ipairs(diagnostics) do
-        v.namespace = nil
-      end
+        -- Remove namespace since it isn't present in the return value of
+        -- fromlist()
+        for _, v in ipairs(diagnostics) do
+          v.namespace = nil
+        end
 
-      return {diagnostics, new_diagnostics}
-      ]]
+        return { diagnostics, new_diagnostics }
+      end)
       eq(result[1], result[2])
     end)
   end)
@@ -2828,179 +3300,181 @@ describe('vim.diagnostic', function()
     it('can add new handlers', function()
       eq(
         true,
-        exec_lua [[
-        local handler_called = false
-        vim.diagnostic.handlers.test = {
-          show = function(namespace, bufnr, diagnostics, opts)
-            assert(namespace == diagnostic_ns)
-            assert(bufnr == diagnostic_bufnr)
-            assert(#diagnostics == 1)
-            assert(opts.test.some_opt == 42)
-            handler_called = true
-          end,
-        }
+        exec_lua(function()
+          local handler_called = false
+          vim.diagnostic.handlers.test = {
+            show = function(namespace, bufnr, diagnostics, opts)
+              assert(namespace == _G.diagnostic_ns)
+              assert(bufnr == _G.diagnostic_bufnr)
+              assert(#diagnostics == 1)
+              assert(opts.test.some_opt == 42)
+              handler_called = true
+            end,
+          }
 
-        vim.diagnostic.config({test = {some_opt = 42}})
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning("Warning", 0, 0, 0, 0),
-        })
-        return handler_called
-      ]]
+          vim.diagnostic.config({ test = { some_opt = 42 } })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Warning', 0, 0, 0, 0),
+          })
+          return handler_called
+        end)
       )
     end)
 
     it('can disable handlers by setting the corresponding option to false', function()
       eq(
         false,
-        exec_lua [[
-        local handler_called = false
-        vim.diagnostic.handlers.test = {
-          show = function(namespace, bufnr, diagnostics, opts)
-            handler_called = true
-          end,
-        }
+        exec_lua(function()
+          local handler_called = false
+          vim.diagnostic.handlers.test = {
+            show = function(_, _, _, _)
+              handler_called = true
+            end,
+          }
 
-        vim.diagnostic.config({test = false})
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning("Warning", 0, 0, 0, 0),
-        })
-        return handler_called
-      ]]
+          vim.diagnostic.config({ test = false })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Warning', 0, 0, 0, 0),
+          })
+          return handler_called
+        end)
       )
     end)
 
     it("always calls a handler's hide function if defined", function()
       eq(
         { false, true },
-        exec_lua [[
-        local hide_called = false
-        local show_called = false
-        vim.diagnostic.handlers.test = {
-          show = function(namespace, bufnr, diagnostics, opts)
-            show_called = true
-          end,
-          hide = function(namespace, bufnr)
-            assert(namespace == diagnostic_ns)
-            assert(bufnr == diagnostic_bufnr)
-            hide_called = true
-          end,
-        }
+        exec_lua(function()
+          local hide_called = false
+          local show_called = false
+          vim.diagnostic.handlers.test = {
+            show = function(_, _, _, _)
+              show_called = true
+            end,
+            hide = function(namespace, bufnr)
+              assert(namespace == _G.diagnostic_ns)
+              assert(bufnr == _G.diagnostic_bufnr)
+              hide_called = true
+            end,
+          }
 
-        vim.diagnostic.config({test = false})
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_warning("Warning", 0, 0, 0, 0),
-        })
-        vim.diagnostic.hide(diagnostic_ns, diagnostic_bufnr)
-        return {show_called, hide_called}
-      ]]
+          vim.diagnostic.config({ test = false })
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_warning('Warning', 0, 0, 0, 0),
+          })
+          vim.diagnostic.hide(_G.diagnostic_ns, _G.diagnostic_bufnr)
+          return { show_called, hide_called }
+        end)
       )
     end)
 
     it('triggers the autocommand when diagnostics are set', function()
       eq(
         { true, true },
-        exec_lua [[
-        -- Set a different buffer as current to test that <abuf> is being set properly in
-        -- DiagnosticChanged callbacks
-        local tmp = vim.api.nvim_create_buf(false, true)
-        vim.api.nvim_set_current_buf(tmp)
-
-        local triggered = {}
-        vim.api.nvim_create_autocmd('DiagnosticChanged', {
-          callback = function(args)
-            triggered = {args.buf, #args.data.diagnostics}
-          end,
-        })
-        vim.api.nvim_buf_set_name(diagnostic_bufnr, "test | test")
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic', 0, 0, 0, 0)
-        })
-        return {
-          triggered[1] == diagnostic_bufnr,
-          triggered[2] == 1,
-        }
-      ]]
+        exec_lua(function()
+          -- Set a different buffer as current to test that <abuf> is being set properly in
+          -- DiagnosticChanged callbacks
+          local tmp = vim.api.nvim_create_buf(false, true)
+          vim.api.nvim_set_current_buf(tmp)
+
+          local triggered = {}
+          vim.api.nvim_create_autocmd('DiagnosticChanged', {
+            callback = function(args)
+              triggered = { args.buf, #args.data.diagnostics }
+            end,
+          })
+          vim.api.nvim_buf_set_name(_G.diagnostic_bufnr, 'test | test')
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic', 0, 0, 0, 0),
+          })
+          return {
+            triggered[1] == _G.diagnostic_bufnr,
+            triggered[2] == 1,
+          }
+        end)
       )
     end)
 
     it('triggers the autocommand when diagnostics are cleared', function()
       eq(
         true,
-        exec_lua [[
-        local tmp = vim.api.nvim_create_buf(false, true)
-        vim.api.nvim_set_current_buf(tmp)
-        vim.g.diagnostic_autocmd_triggered = 0
-        vim.cmd('autocmd DiagnosticChanged * let g:diagnostic_autocmd_triggered = +expand("<abuf>")')
-        vim.api.nvim_buf_set_name(diagnostic_bufnr, "test | test")
-        vim.diagnostic.reset(diagnostic_ns, diagnostic_bufnr)
-        return vim.g.diagnostic_autocmd_triggered == diagnostic_bufnr
-      ]]
+        exec_lua(function()
+          local tmp = vim.api.nvim_create_buf(false, true)
+          vim.api.nvim_set_current_buf(tmp)
+          vim.g.diagnostic_autocmd_triggered = 0
+          vim.cmd(
+            'autocmd DiagnosticChanged * let g:diagnostic_autocmd_triggered = +expand("<abuf>")'
+          )
+          vim.api.nvim_buf_set_name(_G.diagnostic_bufnr, 'test | test')
+          vim.diagnostic.reset(_G.diagnostic_ns, _G.diagnostic_bufnr)
+          return vim.g.diagnostic_autocmd_triggered == _G.diagnostic_bufnr
+        end)
       )
     end)
 
     it('is_enabled', function()
       eq(
         { false, false, false, false, false },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_set_current_buf(diagnostic_bufnr)
-        vim.diagnostic.enable(false)
-        return {
-          vim.diagnostic.is_enabled(),
-          vim.diagnostic.is_enabled{ bufnr = 0 },
-          vim.diagnostic.is_enabled{ bufnr = diagnostic_bufnr },
-          vim.diagnostic.is_enabled{ bufnr = diagnostic_bufnr, ns_id = diagnostic_ns },
-          vim.diagnostic.is_enabled{ bufnr = 0, ns_id = diagnostic_ns },
-        }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+          vim.diagnostic.enable(false)
+          return {
+            vim.diagnostic.is_enabled(),
+            vim.diagnostic.is_enabled { bufnr = 0 },
+            vim.diagnostic.is_enabled { bufnr = _G.diagnostic_bufnr },
+            vim.diagnostic.is_enabled { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns },
+            vim.diagnostic.is_enabled { bufnr = 0, ns_id = _G.diagnostic_ns },
+          }
+        end)
       )
 
       eq(
         { true, true, true, true, true },
-        exec_lua [[
-        vim.diagnostic.enable()
-        return {
-          vim.diagnostic.is_enabled(),
-          vim.diagnostic.is_enabled{ bufnr = 0 },
-          vim.diagnostic.is_enabled{ bufnr = diagnostic_bufnr },
-          vim.diagnostic.is_enabled{ bufnr = diagnostic_bufnr, ns_id = diagnostic_ns },
-          vim.diagnostic.is_enabled{ bufnr = 0, ns_id = diagnostic_ns },
-        }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.enable()
+          return {
+            vim.diagnostic.is_enabled(),
+            vim.diagnostic.is_enabled { bufnr = 0 },
+            vim.diagnostic.is_enabled { bufnr = _G.diagnostic_bufnr },
+            vim.diagnostic.is_enabled { bufnr = _G.diagnostic_bufnr, ns_id = _G.diagnostic_ns },
+            vim.diagnostic.is_enabled { bufnr = 0, ns_id = _G.diagnostic_ns },
+          }
+        end)
       )
     end)
 
     it('is_disabled (deprecated)', function()
       eq(
         { true, true, true, true },
-        exec_lua [[
-        vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-          make_error('Diagnostic #1', 1, 1, 1, 1),
-        })
-        vim.api.nvim_set_current_buf(diagnostic_bufnr)
-        vim.diagnostic.disable()
-        return {
-          vim.diagnostic.is_disabled(),
-          vim.diagnostic.is_disabled(diagnostic_bufnr),
-          vim.diagnostic.is_disabled(diagnostic_bufnr, diagnostic_ns),
-          vim.diagnostic.is_disabled(_, diagnostic_ns),
-        }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+            _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          })
+          vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+          vim.diagnostic.disable()
+          return {
+            vim.diagnostic.is_disabled(),
+            vim.diagnostic.is_disabled(_G.diagnostic_bufnr),
+            vim.diagnostic.is_disabled(_G.diagnostic_bufnr, _G.diagnostic_ns),
+            vim.diagnostic.is_disabled(0, _G.diagnostic_ns),
+          }
+        end)
       )
 
       eq(
         { false, false, false, false },
-        exec_lua [[
-        vim.diagnostic.enable()
-        return {
-          vim.diagnostic.is_disabled(),
-          vim.diagnostic.is_disabled(diagnostic_bufnr),
-          vim.diagnostic.is_disabled(diagnostic_bufnr, diagnostic_ns),
-          vim.diagnostic.is_disabled(_, diagnostic_ns),
-        }
-      ]]
+        exec_lua(function()
+          vim.diagnostic.enable()
+          return {
+            vim.diagnostic.is_disabled(),
+            vim.diagnostic.is_disabled(_G.diagnostic_bufnr),
+            vim.diagnostic.is_disabled(_G.diagnostic_bufnr, _G.diagnostic_ns),
+            vim.diagnostic.is_disabled(0, _G.diagnostic_ns),
+          }
+        end)
       )
     end)
   end)
diff --git a/test/functional/lua/ffi_spec.lua b/test/functional/lua/ffi_spec.lua
index 85ca264107..96f5812493 100644
--- a/test/functional/lua/ffi_spec.lua
+++ b/test/functional/lua/ffi_spec.lua
@@ -15,27 +15,27 @@ describe('ffi.cdef', function()
 
     eq(
       12,
-      exec_lua [=[
-      local ffi = require('ffi')
+      exec_lua(function()
+        local ffi = require('ffi')
 
-      ffi.cdef [[
+        ffi.cdef [[
         typedef struct window_S win_T;
         int win_col_off(win_T *wp);
         extern win_T *curwin;
       ]]
 
-      vim.cmd('set number numberwidth=4 signcolumn=yes:4')
+        vim.cmd('set number numberwidth=4 signcolumn=yes:4')
 
-      return ffi.C.win_col_off(ffi.C.curwin)
-    ]=]
+        return ffi.C.win_col_off(ffi.C.curwin)
+      end)
     )
 
     eq(
       20,
-      exec_lua [=[
-      local ffi = require('ffi')
+      exec_lua(function()
+        local ffi = require('ffi')
 
-      ffi.cdef[[
+        ffi.cdef [[
         typedef struct {} stl_hlrec_t;
         typedef struct {} StlClickRecord;
         typedef struct {} statuscol_T;
@@ -58,32 +58,32 @@ describe('ffi.cdef', function()
         );
       ]]
 
-      return ffi.C.build_stl_str_hl(
-        ffi.C.find_window_by_handle(0, ffi.new('Error')),
-        ffi.new('char[1024]'),
-        1024,
-        ffi.cast('char*', 'StatusLineOfLength20'),
-        -1,
-        0,
-        0,
-        0,
-        nil,
-        nil,
-        nil
-      )
-    ]=]
+        return ffi.C.build_stl_str_hl(
+          ffi.C.find_window_by_handle(0, ffi.new('Error')),
+          ffi.new('char[1024]'),
+          1024,
+          ffi.cast('char*', 'StatusLineOfLength20'),
+          -1,
+          0,
+          0,
+          0,
+          nil,
+          nil,
+          nil
+        )
+      end)
     )
 
     -- Check that extern symbols are exported and accessible
     eq(
       true,
-      exec_lua [[
-      local ffi = require('ffi')
+      exec_lua(function()
+        local ffi = require('ffi')
 
-      ffi.cdef('uint64_t display_tick;')
+        ffi.cdef('uint64_t display_tick;')
 
-      return ffi.C.display_tick >= 0
-    ]]
+        return ffi.C.display_tick >= 0
+      end)
     )
   end)
 end)
diff --git a/test/functional/lua/filetype_spec.lua b/test/functional/lua/filetype_spec.lua
index 7db04e6f6b..574c837f92 100644
--- a/test/functional/lua/filetype_spec.lua
+++ b/test/functional/lua/filetype_spec.lua
@@ -18,90 +18,82 @@ describe('vim.filetype', function()
   before_each(function()
     clear()
 
-    exec_lua [[
+    exec_lua(function()
       local bufnr = vim.api.nvim_create_buf(true, false)
       vim.api.nvim_set_current_buf(bufnr)
-    ]]
+    end)
   end)
 
   it('works with extensions', function()
     eq(
       'radicalscript',
-      exec_lua [[
-      vim.filetype.add({
-        extension = {
-          rs = 'radicalscript',
-        },
-      })
-      return vim.filetype.match({ filename = 'main.rs' })
-    ]]
+      exec_lua(function()
+        vim.filetype.add({
+          extension = {
+            rs = 'radicalscript',
+          },
+        })
+        return vim.filetype.match({ filename = 'main.rs' })
+      end)
     )
   end)
 
   it('prioritizes filenames over extensions', function()
     eq(
       'somethingelse',
-      exec_lua [[
-      vim.filetype.add({
-        extension = {
-          rs = 'radicalscript',
-        },
-        filename = {
-          ['main.rs'] = 'somethingelse',
-        },
-      })
-      return vim.filetype.match({ filename = 'main.rs' })
-    ]]
+      exec_lua(function()
+        vim.filetype.add({
+          extension = {
+            rs = 'radicalscript',
+          },
+          filename = {
+            ['main.rs'] = 'somethingelse',
+          },
+        })
+        return vim.filetype.match({ filename = 'main.rs' })
+      end)
     )
   end)
 
   it('works with filenames', function()
     eq(
       'nim',
-      exec_lua [[
-      vim.filetype.add({
-        filename = {
-          ['s_O_m_e_F_i_l_e'] = 'nim',
-        },
-      })
-      return vim.filetype.match({ filename = 's_O_m_e_F_i_l_e' })
-    ]]
+      exec_lua(function()
+        vim.filetype.add({
+          filename = {
+            ['s_O_m_e_F_i_l_e'] = 'nim',
+          },
+        })
+        return vim.filetype.match({ filename = 's_O_m_e_F_i_l_e' })
+      end)
     )
 
     eq(
       'dosini',
-      exec_lua(
-        [[
-      local root = ...
-      vim.filetype.add({
-        filename = {
-          ['config'] = 'toml',
-          [root .. '/.config/fun/config'] = 'dosini',
-        },
-      })
-      return vim.filetype.match({ filename = root .. '/.config/fun/config' })
-    ]],
-        root
-      )
+      exec_lua(function()
+        vim.filetype.add({
+          filename = {
+            ['config'] = 'toml',
+            [root .. '/.config/fun/config'] = 'dosini',
+          },
+        })
+        return vim.filetype.match({ filename = root .. '/.config/fun/config' })
+      end)
     )
   end)
 
   it('works with patterns', function()
     eq(
       'markdown',
-      exec_lua(
-        [[
-      local root = ...
-      vim.env.HOME = '/a-funky+home%dir'
-      vim.filetype.add({
-        pattern = {
-          ['~/blog/.*%.txt'] = 'markdown',
-        }
-      })
-      return vim.filetype.match({ filename = '~/blog/why_neovim_is_awesome.txt' })
-    ]],
-        root
-      )
+      exec_lua(function()
+        vim.env.HOME = '/a-funky+home%dir'
+        vim.filetype.add({
+          pattern = {
+            ['~/blog/.*%.txt'] = 'markdown',
+          },
+        })
+        return vim.filetype.match({ filename = '~/blog/why_neovim_is_awesome.txt' })
+      end)
     )
   end)
 
@@ -110,43 +102,43 @@ describe('vim.filetype', function()
     command('file relevant_to_me')
     eq(
       'foss',
-      exec_lua [[
-      vim.filetype.add({
-        pattern = {
-          ["relevant_to_(%a+)"] = function(path, bufnr, capture)
-            if capture == "me" then
-              return "foss"
-            end
-          end,
-        }
-      })
-      return vim.filetype.match({ buf = 0 })
-    ]]
+      exec_lua(function()
+        vim.filetype.add({
+          pattern = {
+            ['relevant_to_(%a+)'] = function(_, _, capture)
+              if capture == 'me' then
+                return 'foss'
+              end
+            end,
+          },
+        })
+        return vim.filetype.match({ buf = 0 })
+      end)
     )
   end)
 
   it('works with contents #22180', function()
     eq(
       'sh',
-      exec_lua [[
-      -- Needs to be set so detect#sh doesn't fail
-      vim.g.ft_ignore_pat = '\\.\\(Z\\|gz\\|bz2\\|zip\\|tgz\\)$'
-      return vim.filetype.match({ contents = { '#!/usr/bin/env bash' } })
-    ]]
+      exec_lua(function()
+        -- Needs to be set so detect#sh doesn't fail
+        vim.g.ft_ignore_pat = '\\.\\(Z\\|gz\\|bz2\\|zip\\|tgz\\)$'
+        return (vim.filetype.match({ contents = { '#!/usr/bin/env bash' } }))
+      end)
     )
   end)
 
   it('considers extension mappings when matching from hashbang', function()
     eq(
       'fooscript',
-      exec_lua [[
-      vim.filetype.add({
-        extension = {
-          foo = 'fooscript',
-        }
-      })
-      return vim.filetype.match({ contents = { '#!/usr/bin/env foo' } })
-    ]]
+      exec_lua(function()
+        vim.filetype.add({
+          extension = {
+            foo = 'fooscript',
+          },
+        })
+        return vim.filetype.match({ contents = { '#!/usr/bin/env foo' } })
+      end)
     )
   end)
 
@@ -160,7 +152,12 @@ describe('vim.filetype', function()
       xml = { formatexpr = 'xmlformat#Format()' },
     } do
       for option, value in pairs(opts) do
-        eq(value, exec_lua([[ return vim.filetype.get_option(...) ]], ft, option))
+        eq(
+          value,
+          exec_lua(function()
+            return vim.filetype.get_option(ft, option)
+          end)
+        )
       end
     end
   end)
diff --git a/test/functional/lua/fs_spec.lua b/test/functional/lua/fs_spec.lua
index aba02ab01b..f0d49205e7 100644
--- a/test/functional/lua/fs_spec.lua
+++ b/test/functional/lua/fs_spec.lua
@@ -141,19 +141,14 @@ describe('vim.fs', function()
     it('works', function()
       eq(
         true,
-        exec_lua(
-          [[
-        local dir, nvim = ...
-        for name, type in vim.fs.dir(dir) do
-          if name == nvim and type == 'file' then
-            return true
+        exec_lua(function()
+          for name, type in vim.fs.dir(nvim_dir) do
+            if name == nvim_prog_basename and type == 'file' then
+              return true
+            end
           end
-        end
-        return false
-      ]],
-          nvim_dir,
-          nvim_prog_basename
-        )
+          return false
+        end)
       )
     end)
 
@@ -172,14 +167,12 @@ describe('vim.fs', function()
       io.open('testd/a/b/c/c4', 'w'):close()
 
       local function run(dir, depth, skip)
-        local r = exec_lua(
-          [[
-          local dir, depth, skip = ...
+        return exec_lua(function()
           local r = {}
           local skip_f
           if skip then
-            skip_f = function(n)
-              if vim.tbl_contains(skip or {}, n) then
+            skip_f = function(n0)
+              if vim.tbl_contains(skip or {}, n0) then
                 return false
               end
             end
@@ -188,12 +181,7 @@ describe('vim.fs', function()
             r[name] = type_
           end
           return r
-        ]],
-          dir,
-          depth,
-          skip
-        )
-        return r
+        end)
       end
 
       local exp = {}
@@ -263,13 +251,12 @@ describe('vim.fs', function()
 
       opts = { path = test_source_path .. '/contrib', limit = math.huge }
       eq(
-        exec_lua(
-          [[
-          local dir = ...
-          return vim.tbl_map(vim.fs.basename, vim.fn.glob(dir..'/contrib/*', false, true))
-        ]],
-          test_source_path
-        ),
+        exec_lua(function()
+          return vim.tbl_map(
+            vim.fs.basename,
+            vim.fn.glob(test_source_path .. '/contrib/*', false, true)
+          )
+        end),
         vim.tbl_map(
           vim.fs.basename,
           vim.fs.find(function(_, d)
@@ -299,11 +286,11 @@ describe('vim.fs', function()
 
     it('works with a function', function()
       ---@type string
-      local result = exec_lua([[
-        return vim.fs.root(0, function(name, path)
+      local result = exec_lua(function()
+        return vim.fs.root(0, function(name, _)
           return name:match('%.txt$')
         end)
-      ]])
+      end)
       eq(vim.fs.joinpath(test_source_path, 'test/functional/fixtures'), result)
     end)
 
@@ -352,13 +339,10 @@ describe('vim.fs', function()
       local xdg_config_home = test_build_dir .. '/.config'
       eq(
         xdg_config_home .. '/nvim',
-        exec_lua(
-          [[
-        vim.env.XDG_CONFIG_HOME = ...
-        return vim.fs.normalize('$XDG_CONFIG_HOME/nvim')
-      ]],
-          xdg_config_home
-        )
+        exec_lua(function()
+          vim.env.XDG_CONFIG_HOME = xdg_config_home
+          return vim.fs.normalize('$XDG_CONFIG_HOME/nvim')
+        end)
       )
     end)
 
diff --git a/test/functional/lua/glob_spec.lua b/test/functional/lua/glob_spec.lua
index 56cd4c9bb5..8302c7334d 100644
--- a/test/functional/lua/glob_spec.lua
+++ b/test/functional/lua/glob_spec.lua
@@ -2,21 +2,15 @@ local t = require('test.testutil')
 local n = require('test.functional.testnvim')()
 
 local eq = t.eq
-local exec_lua = n.exec_lua
 
 describe('glob', function()
   before_each(n.clear)
   after_each(n.clear)
 
-  local match = function(...)
-    return exec_lua(
-      [[
-      local pattern = select(1, ...)
-      local str = select(2, ...)
-      return require("vim.glob").to_lpeg(pattern):match(str) ~= nil
-    ]],
-      ...
-    )
+  local match = function(pattern, str)
+    return n.exec_lua(function()
+      return require('vim.glob').to_lpeg(pattern):match(str) ~= nil
+    end)
   end
 
   describe('glob matching', function()
@@ -161,7 +155,7 @@ describe('glob', function()
       eq(false, match('{ab,cd}', 'a'))
       eq(true, match('{ab,cd}', 'cd'))
       eq(true, match('{a,b,c}', 'c'))
-      eq(true, match('{a,{b,c}}', 'c'))
+      eq(false, match('{a,{b,c}}', 'c')) -- {} cannot nest
     end)
 
     it('should match [] groups', function()
@@ -205,6 +199,19 @@ describe('glob', function()
       eq(true, match('[!a-zA-Z0-9]', '!'))
     end)
 
+    it('should handle long patterns', function()
+      -- lpeg has a recursion limit of 200 by default, make sure the grammar does trigger it on
+      -- strings longer than that
+      local fill_200 =
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+      eq(200, fill_200:len())
+      local long_lit = fill_200 .. 'a'
+      eq(false, match(long_lit, 'b'))
+      eq(true, match(long_lit, long_lit))
+      local long_pat = fill_200 .. 'a/**/*.c'
+      eq(true, match(long_pat, fill_200 .. 'a/b/c/d.c'))
+    end)
+
     it('should match complex patterns', function()
       eq(false, match('**/*.{c,h}', ''))
       eq(false, match('**/*.{c,h}', 'c'))
@@ -223,6 +230,17 @@ describe('glob', function()
       eq(true, match('{[0-9],[a-z]}', '0'))
       eq(true, match('{[0-9],[a-z]}', 'a'))
       eq(false, match('{[0-9],[a-z]}', 'A'))
+
+      -- glob is from willRename filter in typescript-language-server
+      -- https://github.com/typescript-language-server/typescript-language-server/blob/b224b878652438bcdd639137a6b1d1a6630129e4/src/lsp-server.ts#L266
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.js'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.ts'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.mts'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.mjs'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.cjs'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.cts'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.jsx'))
+      eq(true, match('**/*.{ts,js,jsx,tsx,mjs,mts,cjs,cts}', 'test.tsx'))
     end)
   end)
 end)
diff --git a/test/functional/lua/highlight_spec.lua b/test/functional/lua/highlight_spec.lua
index c9f2d0a47f..c048949df8 100644
--- a/test/functional/lua/highlight_spec.lua
+++ b/test/functional/lua/highlight_spec.lua
@@ -1,14 +1,112 @@
 local t = require('test.testutil')
 local n = require('test.functional.testnvim')()
+local Screen = require('test.functional.ui.screen')
 
 local exec_lua = n.exec_lua
 local eq = t.eq
-local neq = t.neq
 local eval = n.eval
 local command = n.command
 local clear = n.clear
 local api = n.api
 
+describe('vim.highlight.range', function()
+  local screen
+
+  before_each(function()
+    clear()
+    screen = Screen.new(60, 6)
+    screen:add_extra_attr_ids({
+      [100] = { foreground = Screen.colors.Blue, background = Screen.colors.Yellow, bold = true },
+    })
+    screen:attach()
+    api.nvim_set_option_value('list', true, {})
+    api.nvim_set_option_value('listchars', 'eol:$', {})
+    api.nvim_buf_set_lines(0, 0, -1, true, {
+      'asdfghjkl',
+      '«口=口»',
+      'qwertyuiop',
+      '口口=口口',
+      'zxcvbnm',
+    })
+  end)
+
+  it('works with charwise selection', function()
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.highlight.range(0, ns, 'Search', { 1, 5 }, { 3, 10 })
+    end)
+    screen:expect([[
+      ^asdfghjkl{1:$}                                                  |
+      «口{10:=口»}{100:$}                                                    |
+      {10:qwertyuiop}{100:$}                                                 |
+      {10:口口=口}口{1:$}                                                  |
+      zxcvbnm{1:$}                                                    |
+                                                                  |
+    ]])
+  end)
+
+  it('works with linewise selection', function()
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.highlight.range(0, ns, 'Search', { 0, 0 }, { 4, 0 }, { regtype = 'V' })
+    end)
+    screen:expect([[
+      {10:^asdfghjkl}{100:$}                                                  |
+      {10:«口=口»}{100:$}                                                    |
+      {10:qwertyuiop}{100:$}                                                 |
+      {10:口口=口口}{100:$}                                                  |
+      {10:zxcvbnm}{100:$}                                                    |
+                                                                  |
+    ]])
+  end)
+
+  it('works with blockwise selection', function()
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.highlight.range(0, ns, 'Search', { 0, 0 }, { 4, 4 }, { regtype = '\022' })
+    end)
+    screen:expect([[
+      {10:^asdf}ghjkl{1:$}                                                  |
+      {10:«口=}口»{1:$}                                                    |
+      {10:qwer}tyuiop{1:$}                                                 |
+      {10:口口}=口口{1:$}                                                  |
+      {10:zxcv}bnm{1:$}                                                    |
+                                                                  |
+    ]])
+  end)
+
+  it('works with blockwise selection with width', function()
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.highlight.range(0, ns, 'Search', { 0, 4 }, { 4, 7 }, { regtype = '\0226' })
+    end)
+    screen:expect([[
+      ^asdf{10:ghjkl}{1:$}                                                  |
+      «口={10:口»}{1:$}                                                    |
+      qwer{10:tyuiop}{1:$}                                                 |
+      口口{10:=口口}{1:$}                                                  |
+      zxcv{10:bnm}{1:$}                                                    |
+                                                                  |
+    ]])
+  end)
+
+  it('can use -1 or v:maxcol to indicate end of line', function()
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.highlight.range(0, ns, 'Search', { 0, 4 }, { 1, -1 }, {})
+      vim.highlight.range(0, ns, 'Search', { 2, 6 }, { 3, vim.v.maxcol }, {})
+    end)
+    screen:expect([[
+      ^asdf{10:ghjkl}{100:$}                                                  |
+      {10:«口=口»}{100:$}                                                    |
+      qwerty{10:uiop}{100:$}                                                 |
+      {10:口口=口口}{1:$}                                                  |
+      zxcvbnm{1:$}                                                    |
+                                                                  |
+    ]])
+  end)
+end)
+
 describe('vim.highlight.on_yank', function()
   before_each(function()
     clear()
@@ -16,53 +114,62 @@ describe('vim.highlight.on_yank', function()
 
   it('does not show errors even if buffer is wiped before timeout', function()
     command('new')
-    exec_lua([[
-      vim.highlight.on_yank({timeout = 10, on_macro = true, event = {operator = "y", regtype = "v"}})
+    exec_lua(function()
+      vim.highlight.on_yank({
+        timeout = 10,
+        on_macro = true,
+        event = { operator = 'y', regtype = 'v' },
+      })
       vim.cmd('bwipeout!')
-    ]])
+    end)
     vim.uv.sleep(10)
     n.feed('<cr>') -- avoid hang if error message exists
     eq('', eval('v:errmsg'))
   end)
 
   it('does not close timer twice', function()
-    exec_lua([[
-      vim.highlight.on_yank({timeout = 10, on_macro = true, event = {operator = "y"}})
+    exec_lua(function()
+      vim.highlight.on_yank({ timeout = 10, on_macro = true, event = { operator = 'y' } })
       vim.uv.sleep(10)
       vim.schedule(function()
-        vim.highlight.on_yank({timeout = 0, on_macro = true, event = {operator = "y"}})
+        vim.highlight.on_yank({ timeout = 0, on_macro = true, event = { operator = 'y' } })
       end)
-    ]])
+    end)
     eq('', eval('v:errmsg'))
   end)
 
   it('does not show in another window', function()
     command('vsplit')
-    exec_lua([[
-      vim.api.nvim_buf_set_mark(0,"[",1,1,{})
-      vim.api.nvim_buf_set_mark(0,"]",1,1,{})
-      vim.highlight.on_yank({timeout = math.huge, on_macro = true, event = {operator = "y"}})
-    ]])
-    neq({}, api.nvim__win_get_ns(0))
+    exec_lua(function()
+      vim.api.nvim_buf_set_mark(0, '[', 1, 1, {})
+      vim.api.nvim_buf_set_mark(0, ']', 1, 1, {})
+      vim.highlight.on_yank({ timeout = math.huge, on_macro = true, event = { operator = 'y' } })
+    end)
+    local ns = api.nvim_create_namespace('hlyank')
+    local win = api.nvim_get_current_win()
+    eq({ win }, api.nvim__ns_get(ns).wins)
     command('wincmd w')
-    eq({}, api.nvim__win_get_ns(0))
+    eq({ win }, api.nvim__ns_get(ns).wins)
   end)
 
   it('removes old highlight if new one is created before old one times out', function()
     command('vnew')
-    exec_lua([[
-      vim.api.nvim_buf_set_mark(0,"[",1,1,{})
-      vim.api.nvim_buf_set_mark(0,"]",1,1,{})
-      vim.highlight.on_yank({timeout = math.huge, on_macro = true, event = {operator = "y"}})
-    ]])
-    neq({}, api.nvim__win_get_ns(0))
+    exec_lua(function()
+      vim.api.nvim_buf_set_mark(0, '[', 1, 1, {})
+      vim.api.nvim_buf_set_mark(0, ']', 1, 1, {})
+      vim.highlight.on_yank({ timeout = math.huge, on_macro = true, event = { operator = 'y' } })
+    end)
+    local ns = api.nvim_create_namespace('hlyank')
+    eq(api.nvim_get_current_win(), api.nvim__ns_get(ns).wins[1])
     command('wincmd w')
-    exec_lua([[
-      vim.api.nvim_buf_set_mark(0,"[",1,1,{})
-      vim.api.nvim_buf_set_mark(0,"]",1,1,{})
-      vim.highlight.on_yank({timeout = math.huge, on_macro = true, event = {operator = "y"}})
-    ]])
+    exec_lua(function()
+      vim.api.nvim_buf_set_mark(0, '[', 1, 1, {})
+      vim.api.nvim_buf_set_mark(0, ']', 1, 1, {})
+      vim.highlight.on_yank({ timeout = math.huge, on_macro = true, event = { operator = 'y' } })
+    end)
+    local win = api.nvim_get_current_win()
+    eq({ win }, api.nvim__ns_get(ns).wins)
     command('wincmd w')
-    eq({}, api.nvim__win_get_ns(0))
+    eq({ win }, api.nvim__ns_get(ns).wins)
   end)
 end)
diff --git a/test/functional/lua/inspector_spec.lua b/test/functional/lua/inspector_spec.lua
index 8fadba6ee8..3a1263f6a3 100644
--- a/test/functional/lua/inspector_spec.lua
+++ b/test/functional/lua/inspector_spec.lua
@@ -12,22 +12,21 @@ describe('vim.inspect_pos', function()
   end)
 
   it('it returns items', function()
-    local ret = exec_lua([[
+    local buf, items, other_buf_syntax = exec_lua(function()
       local buf = vim.api.nvim_create_buf(true, false)
       local buf1 = vim.api.nvim_create_buf(true, false)
-      local ns1 = vim.api.nvim_create_namespace("ns1")
-      local ns2 = vim.api.nvim_create_namespace("")
+      local ns1 = vim.api.nvim_create_namespace('ns1')
+      local ns2 = vim.api.nvim_create_namespace('')
       vim.api.nvim_set_current_buf(buf)
-      vim.api.nvim_buf_set_lines(0, 0, -1, false, {"local a = 123"})
-      vim.api.nvim_buf_set_lines(buf1, 0, -1, false, {"--commentline"})
+      vim.api.nvim_buf_set_lines(0, 0, -1, false, { 'local a = 123' })
+      vim.api.nvim_buf_set_lines(buf1, 0, -1, false, { '--commentline' })
       vim.bo[buf].filetype = 'lua'
       vim.bo[buf1].filetype = 'lua'
-      vim.api.nvim_buf_set_extmark(buf, ns1, 0, 10, { hl_group = "Normal" })
-      vim.api.nvim_buf_set_extmark(buf, ns2, 0, 10, { hl_group = "Normal" })
-      vim.cmd("syntax on")
-      return {buf, vim.inspect_pos(0, 0, 10), vim.inspect_pos(buf1, 0, 10).syntax }
-    ]])
-    local buf, items, other_buf_syntax = unpack(ret)
+      vim.api.nvim_buf_set_extmark(buf, ns1, 0, 10, { hl_group = 'Normal' })
+      vim.api.nvim_buf_set_extmark(buf, ns2, 0, 10, { hl_group = 'Normal' })
+      vim.cmd('syntax on')
+      return buf, vim.inspect_pos(0, 0, 10), vim.inspect_pos(buf1, 0, 10).syntax
+    end)
 
     eq('', eval('v:errmsg'))
     eq({
@@ -95,14 +94,14 @@ describe('vim.show_pos', function()
   end)
 
   it('it does not error', function()
-    exec_lua([[
+    exec_lua(function()
       local buf = vim.api.nvim_create_buf(true, false)
       vim.api.nvim_set_current_buf(buf)
-      vim.api.nvim_buf_set_lines(0, 0, -1, false, {"local a = 123"})
+      vim.api.nvim_buf_set_lines(0, 0, -1, false, { 'local a = 123' })
       vim.bo[buf].filetype = 'lua'
-      vim.cmd("syntax on")
-      return {buf, vim.show_pos(0, 0, 10)}
-    ]])
+      vim.cmd('syntax on')
+      return { buf, vim.show_pos(0, 0, 10) }
+    end)
     eq('', eval('v:errmsg'))
   end)
 end)
diff --git a/test/functional/lua/loader_spec.lua b/test/functional/lua/loader_spec.lua
index f13e6664c5..8508f2aa14 100644
--- a/test/functional/lua/loader_spec.lua
+++ b/test/functional/lua/loader_spec.lua
@@ -12,14 +12,14 @@ describe('vim.loader', function()
 
   it('can work in compatibility with --luamod-dev #27413', function()
     clear({ args = { '--luamod-dev' } })
-    exec_lua [[
+    exec_lua(function()
       vim.loader.enable()
 
-      require("vim.fs")
+      require('vim.fs')
 
       -- try to load other vim submodules as well (Nvim Lua stdlib)
       for key, _ in pairs(vim._submodules) do
-        local modname = 'vim.' .. key   -- e.g. "vim.fs"
+        local modname = 'vim.' .. key -- e.g. "vim.fs"
 
         local lhs = vim[key]
         local rhs = require(modname)
@@ -28,28 +28,25 @@ describe('vim.loader', function()
           ('%s != require("%s"), %s != %s'):format(modname, modname, tostring(lhs), tostring(rhs))
         )
       end
-    ]]
+    end)
   end)
 
   it('handles changing files (#23027)', function()
-    exec_lua [[
+    exec_lua(function()
       vim.loader.enable()
-    ]]
+    end)
 
     local tmp = t.tmpname()
     command('edit ' .. tmp)
 
     eq(
       1,
-      exec_lua(
-        [[
-      vim.api.nvim_buf_set_lines(0, 0, -1, true, {'_G.TEST=1'})
-      vim.cmd.write()
-      loadfile(...)()
-      return _G.TEST
-    ]],
-        tmp
-      )
+      exec_lua(function()
+        vim.api.nvim_buf_set_lines(0, 0, -1, true, { '_G.TEST=1' })
+        vim.cmd.write()
+        loadfile(tmp)()
+        return _G.TEST
+      end)
     )
 
     -- fs latency
@@ -57,15 +54,12 @@ describe('vim.loader', function()
 
     eq(
       2,
-      exec_lua(
-        [[
-      vim.api.nvim_buf_set_lines(0, 0, -1, true, {'_G.TEST=2'})
-      vim.cmd.write()
-      loadfile(...)()
-      return _G.TEST
-    ]],
-        tmp
-      )
+      exec_lua(function()
+        vim.api.nvim_buf_set_lines(0, 0, -1, true, { '_G.TEST=2' })
+        vim.cmd.write()
+        loadfile(tmp)()
+        return _G.TEST
+      end)
     )
   end)
 
@@ -74,8 +68,7 @@ describe('vim.loader', function()
       vim.loader.enable()
     ]]
 
-    local tmp = t.tmpname()
-    assert(os.remove(tmp))
+    local tmp = t.tmpname(false)
     assert(t.mkdir(tmp))
     assert(t.mkdir(tmp .. '/%'))
     local tmp1 = tmp .. '/%/x'
@@ -88,4 +81,15 @@ describe('vim.loader', function()
     eq(1, exec_lua('return loadfile(...)()', tmp1))
     eq(2, exec_lua('return loadfile(...)()', tmp2))
   end)
+
+  it('correct indent on error message (#29809)', function()
+    local errmsg = exec_lua [[
+      vim.loader.enable()
+      local _, errmsg = pcall(require, 'non_existent_module')
+      return errmsg
+    ]]
+    local errors = vim.split(errmsg, '\n')
+    eq("\tcache_loader: module 'non_existent_module' not found", errors[3])
+    eq("\tcache_loader_lib: module 'non_existent_module' not found", errors[4])
+  end)
 end)
diff --git a/test/functional/lua/loop_spec.lua b/test/functional/lua/loop_spec.lua
index 566a171a84..de8200a5f1 100644
--- a/test/functional/lua/loop_spec.lua
+++ b/test/functional/lua/loop_spec.lua
@@ -25,30 +25,34 @@ describe('vim.uv', function()
   it('timer', function()
     exec_lua('vim.api.nvim_set_var("coroutine_cnt", 0)', {})
 
-    local code = [[
+    local code = function()
       local touch = 0
       local function wait(ms)
         local this = coroutine.running()
         assert(this)
-        local timer = vim.uv.new_timer()
-        timer:start(ms, 0, vim.schedule_wrap(function ()
-          timer:close()
-          touch = touch + 1
-          coroutine.resume(this)
-          touch = touch + 1
-          assert(touch==3)
-          vim.api.nvim_set_var("coroutine_cnt_1", touch)
-        end))
+        local timer = assert(vim.uv.new_timer())
+        timer:start(
+          ms,
+          0,
+          vim.schedule_wrap(function()
+            timer:close()
+            touch = touch + 1
+            coroutine.resume(this)
+            touch = touch + 1
+            assert(touch == 3)
+            vim.api.nvim_set_var('coroutine_cnt_1', touch)
+          end)
+        )
         coroutine.yield()
         touch = touch + 1
         return touch
       end
       coroutine.wrap(function()
         local touched = wait(10)
-        assert(touched==touch)
-        vim.api.nvim_set_var("coroutine_cnt", touched)
+        assert(touched == touch)
+        vim.api.nvim_set_var('coroutine_cnt', touched)
       end)()
-    ]]
+    end
 
     eq(0, api.nvim_get_var('coroutine_cnt'))
     exec_lua(code)
@@ -99,15 +103,19 @@ describe('vim.uv', function()
 
     -- callbacks can be scheduled to be executed in the main event loop
     -- where the entire API is available
-    exec_lua([[
-      local timer = vim.uv.new_timer()
-      timer:start(20, 0, vim.schedule_wrap(function ()
-        _G.is_fast = vim.in_fast_event()
-        timer:close()
-        vim.api.nvim_set_var("valid", true)
-        vim.api.nvim_command("echomsg 'howdy'")
-      end))
-    ]])
+    exec_lua(function()
+      local timer = assert(vim.uv.new_timer())
+      timer:start(
+        20,
+        0,
+        vim.schedule_wrap(function()
+          _G.is_fast = vim.in_fast_event()
+          timer:close()
+          vim.api.nvim_set_var('valid', true)
+          vim.api.nvim_command("echomsg 'howdy'")
+        end)
+      )
+    end)
 
     screen:expect([[
       ^                                                  |
@@ -118,15 +126,15 @@ describe('vim.uv', function()
     eq(false, exec_lua('return _G.is_fast'))
 
     -- fast (not deferred) API functions are allowed to be called directly
-    exec_lua([[
-      local timer = vim.uv.new_timer()
-      timer:start(20, 0, function ()
+    exec_lua(function()
+      local timer = assert(vim.uv.new_timer())
+      timer:start(20, 0, function()
         timer:close()
         -- input is queued for processing after the callback returns
-        vim.api.nvim_input("isneaky")
+        vim.api.nvim_input('isneaky')
         _G.mode = vim.api.nvim_get_mode()
       end)
-    ]])
+    end)
     screen:expect([[
       sneaky^                                            |
       {1:~                                                 }|*8
@@ -134,15 +142,15 @@ describe('vim.uv', function()
     ]])
     eq({ blocking = false, mode = 'n' }, exec_lua('return _G.mode'))
 
-    exec_lua([[
-      local timer = vim.uv.new_timer()
-      timer:start(20, 0, function ()
+    exec_lua(function()
+      local timer = assert(vim.uv.new_timer())
+      timer:start(20, 0, function()
         _G.is_fast = vim.in_fast_event()
         timer:close()
-        _G.value = vim.fn.has("nvim-0.5")
-        _G.unvalue = vim.fn.has("python3")
+        _G.value = vim.fn.has('nvim-0.5')
+        _G.unvalue = vim.fn.has('python3')
       end)
-    ]])
+    end)
 
     screen:expect({ any = [[{3:Vim:E5560: Vimscript function must not be called i}]] })
     feed('<cr>')
diff --git a/test/functional/lua/luaeval_spec.lua b/test/functional/lua/luaeval_spec.lua
index 3f62cd8325..2b23f72c7d 100644
--- a/test/functional/lua/luaeval_spec.lua
+++ b/test/functional/lua/luaeval_spec.lua
@@ -13,6 +13,7 @@ local fn = n.fn
 local clear = n.clear
 local eval = n.eval
 local feed = n.feed
+local assert_alive = n.assert_alive
 local NIL = vim.NIL
 local eq = t.eq
 
@@ -72,9 +73,9 @@ describe('luaeval()', function()
     end)
     it('are successfully converted to special dictionaries in table keys', function()
       command([[let d = luaeval('{["\0"]=1}')]])
-      eq({_TYPE={}, _VAL={{{_TYPE={}, _VAL={'\n'}}, 1}}}, api.nvim_get_var('d'))
+      eq({_TYPE={}, _VAL={{'\000', 1}}}, api.nvim_get_var('d'))
       eq(1, fn.eval('d._TYPE is v:msgpack_types.map'))
-      eq(1, fn.eval('d._VAL[0][0]._TYPE is v:msgpack_types.string'))
+      eq(eval('v:t_blob'), fn.eval('type(d._VAL[0][0])'))
     end)
     it('are successfully converted to blobs from a list', function()
       command([[let l = luaeval('{"abc", "a\0b", "c\0d", "def"}')]])
@@ -125,11 +126,11 @@ describe('luaeval()', function()
     local level = 30
     eq(nested_by_level[level].o, fn.luaeval(nested_by_level[level].s))
 
-    eq({_TYPE={}, _VAL={{{_TYPE={}, _VAL={'\n', '\n'}}, '\000\n\000\000'}}},
+    eq({_TYPE={}, _VAL={{'\000\n\000', '\000\n\000\000'}}},
        fn.luaeval([[{['\0\n\0']='\0\n\0\0'}]]))
     eq(1, eval([[luaeval('{["\0\n\0"]="\0\n\0\0"}')._TYPE is v:msgpack_types.map]]))
-    eq(1, eval([[luaeval('{["\0\n\0"]="\0\n\0\0"}')._VAL[0][0]._TYPE is v:msgpack_types.string]]))
-    eq({nested={{_TYPE={}, _VAL={{{_TYPE={}, _VAL={'\n', '\n'}}, '\000\n\000\000'}}}}},
+    eq(eval("v:t_blob"), eval([[type(luaeval('{["\0\n\0"]="\0\n\0\0"}')._VAL[0][0])]]))
+    eq({nested={{_TYPE={}, _VAL={{'\000\n\000', '\000\n\000\000'}}}}},
        fn.luaeval([[{nested={{['\0\n\0']='\0\n\0\0'}}}]]))
   end)
 
@@ -177,17 +178,15 @@ describe('luaeval()', function()
   end
 
   it('correctly passes special dictionaries', function()
-    eq({0, '\000\n\000'}, luaevalarg(sp('binary', '["\\n", "\\n"]')))
     eq({0, '\000\n\000'}, luaevalarg(sp('string', '["\\n", "\\n"]')))
     eq({0, true}, luaevalarg(sp('boolean', 1)))
     eq({0, false}, luaevalarg(sp('boolean', 0)))
     eq({0, NIL}, luaevalarg(sp('nil', 0)))
-    eq({0, {[""]=""}}, luaevalarg(mapsp(sp('binary', '[""]'), '""')))
     eq({0, {[""]=""}}, luaevalarg(mapsp(sp('string', '[""]'), '""')))
   end)
 
   it('issues an error in some cases', function()
-    eq("Vim(call):E5100: Cannot convert given lua table: table should contain either only integer keys or only string keys",
+    eq("Vim(call):E5100: Cannot convert given Lua table: table should contain either only integer keys or only string keys",
        exc_exec('call luaeval("{1, foo=2}")'))
 
     startswith("Vim(call):E5107: Error loading lua [string \"luaeval()\"]:",
@@ -511,23 +510,16 @@ describe('v:lua', function()
 
   it('works in func options', function()
     local screen = Screen.new(60, 8)
-    screen:set_default_attr_ids({
-      [1] = {bold = true, foreground = Screen.colors.Blue1},
-      [2] = {background = Screen.colors.WebGray},
-      [3] = {background = Screen.colors.LightMagenta},
-      [4] = {bold = true},
-      [5] = {bold = true, foreground = Screen.colors.SeaGreen4},
-    })
     screen:attach()
     api.nvim_set_option_value('omnifunc', 'v:lua.mymod.omni', {})
     feed('isome st<c-x><c-o>')
     screen:expect{grid=[[
       some stuff^                                                  |
-      {1:~   }{2: stuff          }{1:                                        }|
-      {1:~   }{3: steam          }{1:                                        }|
-      {1:~   }{3: strange things }{1:                                        }|
+      {1:~   }{12: stuff          }{1:                                        }|
+      {1:~   }{4: steam          }{1:                                        }|
+      {1:~   }{4: strange things }{1:                                        }|
       {1:~                                                           }|*3
-      {4:-- Omni completion (^O^N^P) }{5:match 1 of 3}                    |
+      {5:-- Omni completion (^O^N^P) }{6:match 1 of 3}                    |
     ]]}
     api.nvim_set_option_value('operatorfunc', 'v:lua.mymod.noisy', {})
     feed('<Esc>g@g@')
@@ -560,5 +552,41 @@ describe('v:lua', function()
     eq("Vim:E107: Missing parentheses: v:lua", pcall_err(eval, "'bad'->v:lua"))
     eq("Vim:E1085: Not a callable type: v:lua", pcall_err(eval, "'bad'->v:lua()"))
     eq([[Vim:E15: Invalid expression: "v:lua.()"]], pcall_err(eval, "'bad'->v:lua.()"))
+
+    eq("Vim:E1085: Not a callable type: v:lua", pcall_err(eval, "v:lua()"))
+    eq([[Vim:E15: Invalid expression: "v:lua.()"]], pcall_err(eval, "v:lua.()"))
+  end)
+
+  describe('invalid use in fold text', function()
+    before_each(function()
+      feed('ifoo<CR>bar<Esc>')
+      command('1,2fold')
+    end)
+
+    it('with missing function name when used as simple function', function()
+      api.nvim_set_option_value('debug', 'throw', {})
+      eq(
+        [[Vim(eval):E15: Invalid expression: "v:lua.()"]],
+        pcall_err(command, 'set foldtext=v:lua.() | eval foldtextresult(1)')
+      )
+    end)
+
+    it('with missing function name when used in expression', function()
+      api.nvim_set_option_value('debug', 'throw', {})
+      eq(
+        [[Vim(eval):E15: Invalid expression: "+v:lua.()"]],
+        pcall_err(command, 'set foldtext=+v:lua.() | eval foldtextresult(1)')
+      )
+    end)
+
+    it('with non-existent function when used as simple function', function()
+      command('set foldtext=v:lua.NoSuchFunc() | eval foldtextresult(1)')
+      assert_alive()
+    end)
+
+    it('with non-existent function when used in expression', function()
+      command('set foldtext=+v:lua.NoSuchFunc() | eval foldtextresult(1)')
+      assert_alive()
+    end)
   end)
 end)
diff --git a/test/functional/lua/mpack_spec.lua b/test/functional/lua/mpack_spec.lua
index efd69d4607..ebede26936 100644
--- a/test/functional/lua/mpack_spec.lua
+++ b/test/functional/lua/mpack_spec.lua
@@ -11,20 +11,20 @@ describe('lua vim.mpack', function()
   it('encodes vim.NIL', function()
     eq(
       { true, true, true, true },
-      exec_lua [[
-      local var = vim.mpack.decode(vim.mpack.encode({33, vim.NIL, 77}))
-      return {var[1]==33, var[2]==vim.NIL, var[3]==77, var[4]==nil}
-    ]]
+      exec_lua(function()
+        local var = vim.mpack.decode(vim.mpack.encode({ 33, vim.NIL, 77 }))
+        return { var[1] == 33, var[2] == vim.NIL, var[3] == 77, var[4] == nil }
+      end)
     )
   end)
 
   it('encodes vim.empty_dict()', function()
     eq(
       { { {}, 'foo', {} }, true, false },
-      exec_lua [[
-      local var = vim.mpack.decode(vim.mpack.encode({{}, "foo", vim.empty_dict()}))
-      return {var, vim.islist(var[1]), vim.islist(var[3])}
-    ]]
+      exec_lua(function()
+        local var = vim.mpack.decode(vim.mpack.encode({ {}, 'foo', vim.empty_dict() }))
+        return { var, vim.islist(var[1]), vim.islist(var[3]) }
+      end)
     )
   end)
 end)
diff --git a/test/functional/lua/overrides_spec.lua b/test/functional/lua/overrides_spec.lua
index 849978f080..33a2813200 100644
--- a/test/functional/lua/overrides_spec.lua
+++ b/test/functional/lua/overrides_spec.lua
@@ -134,14 +134,12 @@ describe('print', function()
     eq('abc  def', exec_capture('lua print("abc", "", "def")'))
   end)
   it('defers printing in luv event handlers', function()
-    exec_lua(
-      [[
-      local cmd = ...
+    exec_lua(function(cmd)
       function test()
         local timer = vim.uv.new_timer()
         local done = false
         timer:start(10, 0, function()
-          print("very fast")
+          print('very fast')
           timer:close()
           done = true
         end)
@@ -149,14 +147,12 @@ describe('print', function()
         -- loop until we know for sure the callback has been executed
         while not done do
           os.execute(cmd)
-          vim.uv.run("nowait") -- fake os_breakcheck()
+          vim.uv.run('nowait') -- fake os_breakcheck()
         end
-        print("very slow")
-        vim.api.nvim_command("sleep 1m") -- force deferred event processing
+        print('very slow')
+        vim.api.nvim_command('sleep 1m') -- force deferred event processing
       end
-    ]],
-      (is_os('win') and 'timeout 1') or 'sleep 0.1'
-    )
+    end, (is_os('win') and 'timeout 1') or 'sleep 0.1')
     eq('very slow\nvery fast', exec_capture('lua test()'))
   end)
 
diff --git a/test/functional/lua/runtime_spec.lua b/test/functional/lua/runtime_spec.lua
index 4adce42c3e..f63363d6d9 100644
--- a/test/functional/lua/runtime_spec.lua
+++ b/test/functional/lua/runtime_spec.lua
@@ -401,4 +401,12 @@ describe('runtime:', function()
       eq('ABab', eval('g:seq'))
     end)
   end)
+
+  it('cpp ftplugin loads c ftplugin #29053', function()
+    eq('', eval('&commentstring'))
+    eq('', eval('&omnifunc'))
+    exec('edit file.cpp')
+    eq('// %s', eval('&commentstring'))
+    eq('ccomplete#Complete', eval('&omnifunc'))
+  end)
 end)
diff --git a/test/functional/lua/snippet_spec.lua b/test/functional/lua/snippet_spec.lua
index 413aa93994..eb2f17216c 100644
--- a/test/functional/lua/snippet_spec.lua
+++ b/test/functional/lua/snippet_spec.lua
@@ -1,3 +1,5 @@
+---@diagnostic disable: no-unknown
+
 local t = require('test.testutil')
 local n = require('test.functional.testnvim')()
 
@@ -16,11 +18,6 @@ local retry = t.retry
 describe('vim.snippet', function()
   before_each(function()
     clear()
-
-    exec_lua([[
-      vim.keymap.set({ 'i', 's' }, '<Tab>', function() vim.snippet.jump(1) end, { buffer = true })
-      vim.keymap.set({ 'i', 's' }, '<S-Tab>', function() vim.snippet.jump(-1) end, { buffer = true })
-    ]])
   end)
   after_each(clear)
 
@@ -61,7 +58,13 @@ describe('vim.snippet', function()
   end)
 
   it('adds indentation based on the start of snippet lines', function()
+    local curbuf = api.nvim_get_current_buf()
+
     test_expand_success({ 'if $1 then', '  $0', 'end' }, { 'if  then', '  ', 'end' })
+
+    -- Regression test: #29658
+    api.nvim_buf_set_lines(curbuf, 0, -1, false, {})
+    test_expand_success({ '${1:foo^bar}\n' }, { 'foo^bar', '' })
   end)
 
   it('replaces tabs with spaces when expandtab is set', function()
@@ -286,4 +289,24 @@ describe('vim.snippet', function()
     ]]
     )
   end)
+
+  it('restores snippet navigation keymaps', function()
+    -- Create a buffer keymap in insert mode that deletes all lines.
+    local curbuf = api.nvim_get_current_buf()
+    exec_lua('vim.api.nvim_buf_set_keymap(..., "i", "<Tab>", "<cmd>normal ggdG<cr>", {})', curbuf)
+
+    test_expand_success({ 'var $1 = $2' }, { 'var  = ' })
+
+    -- While the snippet is active, <Tab> should navigate between tabstops.
+    feed('x')
+    poke_eventloop()
+    feed('<Tab>0')
+    eq({ 'var x = 0' }, buf_lines(0))
+
+    exec_lua('vim.snippet.stop()')
+
+    -- After exiting the snippet, the buffer keymap should be restored.
+    feed('<Esc>O<cr><Tab>')
+    eq({ '' }, buf_lines(0))
+  end)
 end)
diff --git a/test/functional/lua/system_spec.lua b/test/functional/lua/system_spec.lua
index e72a009d2e..482bfcf1a9 100644
--- a/test/functional/lua/system_spec.lua
+++ b/test/functional/lua/system_spec.lua
@@ -6,10 +6,8 @@ local exec_lua = n.exec_lua
 local eq = t.eq
 
 local function system_sync(cmd, opts)
-  return exec_lua(
-    [[
-    local cmd, opts = ...
-    local obj = vim.system(...)
+  return exec_lua(function()
+    local obj = vim.system(cmd, opts)
 
     if opts.timeout then
       -- Minor delay before calling wait() so the timeout uv timer can have a headstart over the
@@ -24,16 +22,11 @@ local function system_sync(cmd, opts)
     assert(not proc, 'process still exists')
 
     return res
-  ]],
-    cmd,
-    opts
-  )
+  end)
 end
 
 local function system_async(cmd, opts)
-  return exec_lua(
-    [[
-    local cmd, opts = ...
+  return exec_lua(function()
     _G.done = false
     local obj = vim.system(cmd, opts, function(obj)
       _G.done = true
@@ -51,10 +44,7 @@ local function system_async(cmd, opts)
     assert(not proc, 'process still exists')
 
     return _G.ret
-  ]],
-    cmd,
-    opts
-  )
+  end)
 end
 
 describe('vim.system', function()
@@ -84,7 +74,7 @@ describe('vim.system', function()
   end
 
   it('kill processes', function()
-    exec_lua([[
+    exec_lua(function()
       local signal
       local cmd = vim.system({ 'cat', '-' }, { stdin = true }, function(r)
         signal = r.signal
@@ -104,19 +94,21 @@ describe('vim.system', function()
       assert(not proc, 'process still exists')
 
       assert(signal == 2)
-    ]])
+    end)
   end)
 
   it('SystemObj:wait() does not process non-fast events #27292', function()
     eq(
       false,
-      exec_lua([[
+      exec_lua(function()
         _G.processed = false
         local cmd = vim.system({ 'sleep', '1' })
-        vim.schedule(function() _G.processed = true end)
+        vim.schedule(function()
+          _G.processed = true
+        end)
         cmd:wait()
         return _G.processed
-      ]])
+      end)
     )
     eq(true, exec_lua([[return _G.processed]]))
   end)
diff --git a/test/functional/lua/text_spec.lua b/test/functional/lua/text_spec.lua
index 9e77953c8c..be471bfd62 100644
--- a/test/functional/lua/text_spec.lua
+++ b/test/functional/lua/text_spec.lua
@@ -20,5 +20,11 @@ describe('vim.text', function()
         eq(input, vim.text.hexdecode(output))
       end
     end)
+
+    it('works with very large strings', function()
+      local input, output = string.rep('😂', 2 ^ 16), string.rep('F09F9882', 2 ^ 16)
+      eq(output, vim.text.hexencode(input))
+      eq(input, vim.text.hexdecode(output))
+    end)
   end)
 end)
diff --git a/test/functional/lua/thread_spec.lua b/test/functional/lua/thread_spec.lua
index 780057b580..cbf23517dc 100644
--- a/test/functional/lua/thread_spec.lua
+++ b/test/functional/lua/thread_spec.lua
@@ -18,13 +18,6 @@ describe('thread', function()
     clear()
     screen = Screen.new(50, 10)
     screen:attach()
-    screen:set_default_attr_ids({
-      [1] = { bold = true, foreground = Screen.colors.Blue1 },
-      [2] = { bold = true, reverse = true },
-      [3] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
-      [4] = { bold = true, foreground = Screen.colors.SeaGreen4 },
-      [5] = { bold = true },
-    })
   end)
 
   it('entry func is executed in protected mode', function()
@@ -38,10 +31,10 @@ describe('thread', function()
     screen:expect([[
                                                         |
       {1:~                                                 }|*5
-      {2:                                                  }|
-      {3:Error in luv thread:}                              |
-      {3:[string "<nvim>"]:2: Error in thread entry func}   |
-      {4:Press ENTER or type command to continue}^           |
+      {3:                                                  }|
+      {9:Error in luv thread:}                              |
+      {9:[string "<nvim>"]:2: Error in thread entry func}   |
+      {6:Press ENTER or type command to continue}^           |
     ]])
     feed('<cr>')
     assert_alive()
@@ -65,10 +58,10 @@ describe('thread', function()
     screen:expect([[
                                                         |
       {1:~                                                 }|*5
-      {2:                                                  }|
-      {3:Error in luv callback, thread:}                    |
-      {3:[string "<nvim>"]:6: Error in thread callback}     |
-      {4:Press ENTER or type command to continue}^           |
+      {3:                                                  }|
+      {9:Error in luv callback, thread:}                    |
+      {9:[string "<nvim>"]:6: Error in thread callback}     |
+      {6:Press ENTER or type command to continue}^           |
     ]])
     feed('<cr>')
     assert_alive()
@@ -265,13 +258,6 @@ describe('threadpool', function()
   it('with invalid return value', function()
     local screen = Screen.new(50, 10)
     screen:attach()
-    screen:set_default_attr_ids({
-      [1] = { bold = true, foreground = Screen.colors.Blue1 },
-      [2] = { bold = true, reverse = true },
-      [3] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
-      [4] = { bold = true, foreground = Screen.colors.SeaGreen4 },
-      [5] = { bold = true },
-    })
 
     exec_lua [[
       local work = vim.uv.new_work(function() return {} end, function() end)
@@ -281,10 +267,10 @@ describe('threadpool', function()
     screen:expect([[
                                                         |
       {1:~                                                 }|*5
-      {2:                                                  }|
-      {3:Error in luv thread:}                              |
-      {3:Error: thread arg not support type 'table' at 1}   |
-      {4:Press ENTER or type command to continue}^           |
+      {3:                                                  }|
+      {9:Error in luv thread:}                              |
+      {9:Error: thread arg not support type 'table' at 1}   |
+      {6:Press ENTER or type command to continue}^           |
     ]])
   end)
 
diff --git a/test/functional/lua/ui_event_spec.lua b/test/functional/lua/ui_event_spec.lua
index 1e80c88403..0a6deaa41c 100644
--- a/test/functional/lua/ui_event_spec.lua
+++ b/test/functional/lua/ui_event_spec.lua
@@ -37,6 +37,9 @@ describe('vim.ui_attach', function()
       [2] = { bold = true },
       [3] = { background = Screen.colors.Grey },
       [4] = { background = Screen.colors.LightMagenta },
+      [5] = { reverse = true },
+      [6] = { reverse = true, bold = true },
+      [7] = { background = Screen.colors.Yellow1 },
     })
     screen:attach()
   end)
@@ -188,6 +191,56 @@ describe('vim.ui_attach', function()
     feed('version<CR><CR>v<Esc>')
     n.assert_alive()
   end)
+
+  it("preserved 'incsearch/command' screen state after :redraw from ext_cmdline", function()
+    exec_lua([[
+      vim.cmd.norm('ifoobar')
+      vim.cmd('1split cmdline')
+      local buf = vim.api.nvim_get_current_buf()
+      vim.cmd.wincmd('p')
+      vim.ui_attach(ns, { ext_cmdline = true }, function(event, ...)
+        if event == 'cmdline_show' then
+          local content = select(1, ...)
+          vim.api.nvim_buf_set_lines(buf, -2, -1, false, {content[1][2]})
+          vim.cmd('redraw')
+        end
+        return true
+      end)
+    ]])
+    -- Updates a cmdline window
+    feed(':cmdline')
+    screen:expect({
+      grid = [[
+        cmdline                                 |
+        {5:cmdline [+]                             }|
+        fooba^r                                  |
+        {6:[No Name] [+]                           }|
+                                                |
+      ]],
+    })
+    -- Does not clear 'incsearch' highlighting
+    feed('<Esc>/foo')
+    screen:expect({
+      grid = [[
+        foo                                     |
+        {5:cmdline [+]                             }|
+        {5:foo}ba^r                                  |
+        {6:[No Name] [+]                           }|
+                                                |
+      ]],
+    })
+    -- Shows new cmdline state during 'inccommand'
+    feed('<Esc>:%s/bar/baz')
+    screen:expect({
+      grid = [[
+        %s/bar/baz                              |
+        {5:cmdline [+]                             }|
+        foo{7:ba^z}                                  |
+        {6:[No Name] [+]                           }|
+                                                |
+      ]],
+    })
+  end)
 end)
 
 describe('vim.ui_attach', function()
diff --git a/test/functional/lua/ui_spec.lua b/test/functional/lua/ui_spec.lua
index d69e893c96..d5eede2885 100644
--- a/test/functional/lua/ui_spec.lua
+++ b/test/functional/lua/ui_spec.lua
@@ -157,5 +157,28 @@ describe('vim.ui', function()
         exec_lua [[local _, err = vim.ui.open('foo') ; return err]]
       )
     end)
+
+    it('opt.cmd #29490', function()
+      t.matches(
+        'ENOENT: no such file or directory',
+        t.pcall_err(exec_lua, function()
+          vim.ui.open('foo', { cmd = { 'non-existent-tool' } })
+        end)
+      )
+
+      eq(
+        {
+          code = 0,
+          signal = 0,
+          stderr = '',
+          stdout = 'arg1=arg1;arg2=https://example.com;',
+        },
+        exec_lua(function(cmd_)
+          local cmd, err = vim.ui.open('https://example.com', { cmd = cmd_ })
+          assert(cmd and not err)
+          return cmd:wait()
+        end, { n.testprg('printargs-test'), 'arg1' })
+      )
+    end)
   end)
 end)
diff --git a/test/functional/lua/uri_spec.lua b/test/functional/lua/uri_spec.lua
index 553afb35d3..258b96bc43 100644
--- a/test/functional/lua/uri_spec.lua
+++ b/test/functional/lua/uri_spec.lua
@@ -217,7 +217,7 @@ describe('URI methods', function()
         ]],
         file
       )
-      local expected_uri = 'file:///' .. file:gsub('\\', '/')
+      local expected_uri = 'file:///' .. t.fix_slashes(file)
       eq(expected_uri, exec_lua(test_case))
       os.remove(file)
     end)
diff --git a/test/functional/lua/version_spec.lua b/test/functional/lua/version_spec.lua
index 4ce8fb8dfe..c172555091 100644
--- a/test/functional/lua/version_spec.lua
+++ b/test/functional/lua/version_spec.lua
@@ -112,6 +112,10 @@ describe('version', function()
       assert(vim.version.range('1.2.3-alpha'):has('1.2.3-alpha'))
       assert(not vim.version.range('1.2.3-alpha'):has('1.2.3-beta'))
     end)
+
+    it('returns nil with empty version', function()
+      eq(vim.version.parse(''), nil)
+    end)
   end)
 
   describe('cmp()', function()
diff --git a/test/functional/lua/vim_spec.lua b/test/functional/lua/vim_spec.lua
index c8f94c6ffa..3c65ec664e 100644
--- a/test/functional/lua/vim_spec.lua
+++ b/test/functional/lua/vim_spec.lua
@@ -135,19 +135,19 @@ describe('lua stdlib', function()
     -- See MAINTAIN.md for the soft/hard deprecation policy
 
     describe(('vim.deprecate prerel=%s,'):format(prerel or 'nil'), function()
-      local curver = exec_lua('return vim.version()') --[[@as {major:number, minor:number}]]
-      -- "0.10" or "0.10-dev+xxx"
-      local curstr = ('%s.%s%s'):format(curver.major, curver.minor, prerel or '')
-      -- "0.10" or "0.11"
-      local nextver = ('%s.%s'):format(curver.major, curver.minor + (prerel and 0 or 1))
-      local was_removed = prerel and 'was removed' or 'will be removed'
+      local curver --- @type {major:number, minor:number}
+
+      before_each(function()
+        curver = exec_lua('return vim.version()')
+      end)
 
       it('plugin=nil, same message skipped', function()
+        -- "0.10" or "0.10-dev+xxx"
+        local curstr = ('%s.%s%s'):format(curver.major, curver.minor, prerel or '')
         eq(
-          dedent(
-            [[
-            foo.bar() is deprecated. Run ":checkhealth vim.deprecated" for more information]]
-          ):format(curstr),
+          ([[foo.bar() is deprecated. Run ":checkhealth vim.deprecated" for more information]]):format(
+            curstr
+          ),
           exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', curstr)
         )
         -- Same message as above; skipped this time.
@@ -162,6 +162,10 @@ describe('lua stdlib', function()
       end)
 
       it('plugin=nil, show error if hard-deprecated', function()
+        -- "0.10" or "0.11"
+        local nextver = ('%s.%s'):format(curver.major, curver.minor + (prerel and 0 or 1))
+
+        local was_removed = prerel and 'was removed' or 'will be removed'
         eq(
           dedent(
             [[
@@ -173,8 +177,7 @@ describe('lua stdlib', function()
 
       it('plugin=nil, to be deleted in the next major version (1.0)', function()
         eq(
-          dedent [[
-            foo.baz() is deprecated. Run ":checkhealth vim.deprecated" for more information]],
+          [[foo.baz() is deprecated. Run ":checkhealth vim.deprecated" for more information]],
           exec_lua [[ return vim.deprecate('foo.baz()', nil, '1.0') ]]
         )
       end)
@@ -535,12 +538,6 @@ describe('lua stdlib', function()
     matches('big failure\nvery async', remove_trace(eval('v:errmsg')))
 
     local screen = Screen.new(60, 5)
-    screen:set_default_attr_ids({
-      [1] = { bold = true, foreground = Screen.colors.Blue1 },
-      [2] = { bold = true, reverse = true },
-      [3] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
-      [4] = { bold = true, foreground = Screen.colors.SeaGreen4 },
-    })
     screen:attach()
     screen:expect {
       grid = [[
@@ -559,11 +556,11 @@ describe('lua stdlib', function()
     ]])
     screen:expect {
       grid = [[
-      {3:stack traceback:}                                            |
-      {3:        [C]: in function 'nvim_command'}                     |
-      {3:        [string "<nvim>"]:2: in function <[string "<nvim>"]:}|
-      {3:1>}                                                          |
-      {4:Press ENTER or type command to continue}^                     |
+      {9:stack traceback:}                                            |
+      {9:        [C]: in function 'nvim_command'}                     |
+      {9:        [string "<nvim>"]:2: in function <[string "<nvim>"]:}|
+      {9:1>}                                                          |
+      {6:Press ENTER or type command to continue}^                     |
     ]],
     }
   end)
@@ -1062,7 +1059,7 @@ describe('lua stdlib', function()
       local a = { a = {[2] = 3} }
       local b = { a = {[3] = 3} }
       local c = vim.tbl_deep_extend("force", a, b)
-      return vim.deep_equal(c, {a = {[3] = 3}})
+      return vim.deep_equal(c, {a = {[2] = 3, [3] = 3}})
     ]]))
 
     eq(
@@ -1074,34 +1071,28 @@ describe('lua stdlib', function()
     ]])
     )
 
-    matches(
-      'invalid "behavior": nil',
-      pcall_err(
-        exec_lua,
-        [[
-        return vim.tbl_deep_extend()
-      ]]
-      )
-    )
+    ok(exec_lua([[
+      local a = { sub = { 'a', 'b' } }
+      local b = { sub = { 'b', 'c' } }
+      local c = vim.tbl_deep_extend('force', a, b)
+      return vim.deep_equal(c, { sub = { 'b', 'c' } })
+    ]]))
+
+    matches('invalid "behavior": nil', pcall_err(exec_lua, [[return vim.tbl_deep_extend()]]))
 
     matches(
       'wrong number of arguments %(given 1, expected at least 3%)',
-      pcall_err(
-        exec_lua,
-        [[
-        return vim.tbl_deep_extend("keep")
-      ]]
-      )
+      pcall_err(exec_lua, [[return vim.tbl_deep_extend("keep")]])
     )
 
     matches(
       'wrong number of arguments %(given 2, expected at least 3%)',
-      pcall_err(
-        exec_lua,
-        [[
-        return vim.tbl_deep_extend("keep", {})
-      ]]
-      )
+      pcall_err(exec_lua, [[return vim.tbl_deep_extend("keep", {})]])
+    )
+
+    matches(
+      'after the second argument%: expected table, got number',
+      pcall_err(exec_lua, [[return vim.tbl_deep_extend("keep", {}, 42)]])
     )
   end)
 
@@ -1200,8 +1191,7 @@ describe('lua stdlib', function()
     ]])
     eq(true, exec_lua([[return next(vim.fn.FooFunc(3)) == nil ]]))
     eq(3, eval('g:test'))
-    -- compat: nvim_call_function uses "special" value for empty dict
-    eq(true, exec_lua([[return next(vim.api.nvim_call_function("FooFunc", {5})) == true ]]))
+    eq(true, exec_lua([[return vim.tbl_isempty(vim.api.nvim_call_function("FooFunc", {5}))]]))
     eq(5, eval('g:test'))
 
     eq({ 2, 'foo', true }, exec_lua([[return vim.fn.VarArg(2, "foo", true)]]))
@@ -1239,7 +1229,7 @@ describe('lua stdlib', function()
     )
   end)
 
-  it('vim.fn should error when calling API function', function()
+  it('vim.fn errors when calling API function', function()
     matches(
       'Tried to call API function with vim.fn: use vim.api.nvim_get_current_line instead',
       pcall_err(exec_lua, 'vim.fn.nvim_get_current_line()')
@@ -1314,12 +1304,6 @@ describe('lua stdlib', function()
     end)
 
     local screen = Screen.new(50, 7)
-    screen:set_default_attr_ids({
-      [1] = { bold = true, foreground = Screen.colors.Blue1 },
-      [2] = { bold = true, reverse = true },
-      [3] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
-      [4] = { bold = true, foreground = Screen.colors.SeaGreen4 },
-    })
     screen:attach()
     exec_lua([[
       timer = vim.uv.new_timer()
@@ -1332,13 +1316,13 @@ describe('lua stdlib', function()
     ]])
     screen:expect {
       grid = [[
-      {3:[string "<nvim>"]:6: E5560: rpcrequest must not be}|
-      {3: called in a lua loop callback}                    |
-      {3:stack traceback:}                                  |
-      {3:        [C]: in function 'rpcrequest'}             |
-      {3:        [string "<nvim>"]:6: in function <[string }|
-      {3:"<nvim>"]:2>}                                      |
-      {4:Press ENTER or type command to continue}^           |
+      {9:[string "<nvim>"]:6: E5560: rpcrequest must not be}|
+      {9: called in a lua loop callback}                    |
+      {9:stack traceback:}                                  |
+      {9:        [C]: in function 'rpcrequest'}             |
+      {9:        [string "<nvim>"]:6: in function <[string }|
+      {9:"<nvim>"]:2>}                                      |
+      {6:Press ENTER or type command to continue}^           |
     ]],
     }
     feed('<cr>')
@@ -1408,7 +1392,25 @@ describe('lua stdlib', function()
     exec_lua("vim.validate{arg1={{}, 't' }, arg2={ 'foo', 's' }}")
     exec_lua("vim.validate{arg1={2, function(a) return (a % 2) == 0  end, 'even number' }}")
     exec_lua("vim.validate{arg1={5, {'n', 's'} }, arg2={ 'foo', {'n', 's'} }}")
-
+    vim.validate('arg1', 5, 'number')
+    vim.validate('arg1', '5', 'string')
+    vim.validate('arg1', { 5 }, 'table')
+    vim.validate('arg1', function()
+      return 5
+    end, 'function')
+    vim.validate('arg1', nil, 'number', true)
+    vim.validate('arg1', nil, 'string', true)
+    vim.validate('arg1', nil, 'table', true)
+    vim.validate('arg1', nil, 'function', true)
+
+    matches('arg1: expected number, got nil', pcall_err(vim.validate, 'arg1', nil, 'number'))
+    matches('arg1: expected string, got nil', pcall_err(vim.validate, 'arg1', nil, 'string'))
+    matches('arg1: expected table, got nil', pcall_err(vim.validate, 'arg1', nil, 'table'))
+    matches('arg1: expected function, got nil', pcall_err(vim.validate, 'arg1', nil, 'function'))
+    matches('arg1: expected string, got number', pcall_err(vim.validate, 'arg1', 5, 'string'))
+    matches('arg1: expected table, got number', pcall_err(vim.validate, 'arg1', 5, 'table'))
+    matches('arg1: expected function, got number', pcall_err(vim.validate, 'arg1', 5, 'function'))
+    matches('arg1: expected number, got string', pcall_err(vim.validate, 'arg1', '5', 'number'))
     matches('expected table, got number', pcall_err(exec_lua, "vim.validate{ 1, 'x' }"))
     matches('invalid type name: x', pcall_err(exec_lua, "vim.validate{ arg1={ 1, 'x' }}"))
     matches('invalid type name: 1', pcall_err(exec_lua, 'vim.validate{ arg1={ 1, 1 }}'))
@@ -1472,6 +1474,60 @@ describe('lua stdlib', function()
     ]])
     )
 
+    eq(
+      { false, false },
+      exec_lua([[
+      local meta = { __call = {} }
+      assert(meta.__call)
+      local function new()
+        return setmetatable({}, meta)
+      end
+      local not_callable = new()
+      return { pcall(function() not_callable() end), vim.is_callable(not_callable) }
+    ]])
+    )
+    eq(
+      { false, false },
+      exec_lua([[
+      local function new()
+        return { __call = function()end }
+      end
+      local not_callable = new()
+      assert(not_callable.__call)
+      return { pcall(function() not_callable() end), vim.is_callable(not_callable) }
+    ]])
+    )
+    eq(
+      { false, false },
+      exec_lua([[
+      local meta = setmetatable(
+        { __index = { __call = function() end } },
+        { __index = { __call = function() end } }
+      )
+      assert(meta.__call)
+      local not_callable = setmetatable({}, meta)
+      assert(not_callable.__call)
+      return { pcall(function() not_callable() end), vim.is_callable(not_callable) }
+    ]])
+    )
+    eq(
+      { false, false },
+      exec_lua([[
+      local meta = setmetatable({
+        __index = function()
+          return function() end
+        end,
+      }, {
+        __index = function()
+          return function() end
+        end,
+      })
+      assert(meta.__call)
+      local not_callable = setmetatable({}, meta)
+      assert(not_callable.__call)
+      return { pcall(function() not_callable() end), vim.is_callable(not_callable) }
+    ]])
+    )
     eq(false, exec_lua('return vim.is_callable(1)'))
     eq(false, exec_lua("return vim.is_callable('foo')"))
     eq(false, exec_lua('return vim.is_callable({})'))
@@ -1891,7 +1947,7 @@ describe('lua stdlib', function()
     eq(NIL, fn.luaeval 'vim.v.null')
     matches([[attempt to index .* nil value]], pcall_err(exec_lua, 'return vim.v[0].progpath'))
     eq('Key is read-only: count', pcall_err(exec_lua, [[vim.v.count = 42]]))
-    eq('Dictionary is locked', pcall_err(exec_lua, [[vim.v.nosuchvar = 42]]))
+    eq('Dict is locked', pcall_err(exec_lua, [[vim.v.nosuchvar = 42]]))
     eq('Key is fixed: errmsg', pcall_err(exec_lua, [[vim.v.errmsg = nil]]))
     exec_lua([[vim.v.errmsg = 'set by Lua']])
     eq('set by Lua', eval('v:errmsg'))
@@ -1919,16 +1975,12 @@ describe('lua stdlib', function()
     eq({ 1, 5 }, api.nvim_win_get_cursor(0))
 
     local screen = Screen.new(60, 3)
-    screen:set_default_attr_ids({
-      [0] = { bold = true, foreground = Screen.colors.Blue },
-      [1] = { background = Screen.colors.Yellow },
-    })
     screen:attach()
     eq(1, eval('v:hlsearch'))
     screen:expect {
       grid = [[
-       {1:foo} {1:^foo} {1:foo}                                                |
-      {0:~                                                           }|
+       {10:foo} {10:^foo} {10:foo}                                                |
+      {1:~                                                           }|
                                                                   |
     ]],
     }
@@ -1937,7 +1989,7 @@ describe('lua stdlib', function()
     screen:expect {
       grid = [[
        foo ^foo foo                                                |
-      {0:~                                                           }|
+      {1:~                                                           }|
                                                                   |
     ]],
     }
@@ -1945,8 +1997,8 @@ describe('lua stdlib', function()
     eq(1, eval('v:hlsearch'))
     screen:expect {
       grid = [[
-       {1:foo} {1:^foo} {1:foo}                                                |
-      {0:~                                                           }|
+       {10:foo} {10:^foo} {10:foo}                                                |
+      {1:~                                                           }|
                                                                   |
     ]],
     }
@@ -2005,13 +2057,17 @@ describe('lua stdlib', function()
     vim.cmd "enew"
     ]]
     eq(100, fn.luaeval 'vim.wo.scrolloff')
+
+    matches('only bufnr=0 is supported', pcall_err(exec_lua, 'vim.wo[0][10].signcolumn = "no"'))
+
+    matches('only bufnr=0 is supported', pcall_err(exec_lua, 'local a = vim.wo[0][10].signcolumn'))
   end)
 
   describe('vim.opt', function()
     -- TODO: We still need to write some tests for optlocal, opt and then getting the options
     --  Probably could also do some stuff with getting things from viml side as well to confirm behavior is the same.
 
-    it('should allow setting number values', function()
+    it('allows setting number values', function()
       local scrolloff = exec_lua [[
         vim.opt.scrolloff = 10
         return vim.o.scrolloff
@@ -2019,7 +2075,7 @@ describe('lua stdlib', function()
       eq(10, scrolloff)
     end)
 
-    pending('should handle STUPID window things', function()
+    pending('handles STUPID window things', function()
       local result = exec_lua [[
         local result = {}
 
@@ -2032,7 +2088,7 @@ describe('lua stdlib', function()
       eq({}, result)
     end)
 
-    it('should allow setting tables', function()
+    it('allows setting tables', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = { 'hello', 'world' }
         return vim.o.wildignore
@@ -2040,7 +2096,7 @@ describe('lua stdlib', function()
       eq('hello,world', wildignore)
     end)
 
-    it('should allow setting tables with shortnames', function()
+    it('allows setting tables with shortnames', function()
       local wildignore = exec_lua [[
         vim.opt.wig = { 'hello', 'world' }
         return vim.o.wildignore
@@ -2048,7 +2104,7 @@ describe('lua stdlib', function()
       eq('hello,world', wildignore)
     end)
 
-    it('should error when you attempt to set string values to numeric options', function()
+    it('errors when you attempt to set string values to numeric options', function()
       local result = exec_lua [[
         return {
           pcall(function() vim.opt.textwidth = 'hello world' end)
@@ -2058,7 +2114,7 @@ describe('lua stdlib', function()
       eq(false, result[1])
     end)
 
-    it('should error when you attempt to setlocal a global value', function()
+    it('errors when you attempt to setlocal a global value', function()
       local result = exec_lua [[
         return pcall(function() vim.opt_local.clipboard = "hello" end)
       ]]
@@ -2066,7 +2122,7 @@ describe('lua stdlib', function()
       eq(false, result)
     end)
 
-    it('should allow you to set boolean values', function()
+    it('allows you to set boolean values', function()
       eq(
         { true, false, true },
         exec_lua [[
@@ -2086,7 +2142,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should change current buffer values and defaults for global local values', function()
+    it('changes current buffer values and defaults for global local values', function()
       local result = exec_lua [[
         local result = {}
 
@@ -2125,7 +2181,7 @@ describe('lua stdlib', function()
       eq('', result[8])
     end)
 
-    it('should allow you to retrieve window opts even if they have not been set', function()
+    it('allows you to retrieve window opts even if they have not been set', function()
       local result = exec_lua [[
         local result = {}
         table.insert(result, vim.opt.number:get())
@@ -2140,7 +2196,7 @@ describe('lua stdlib', function()
       eq({ false, false, true, true }, result)
     end)
 
-    it('should allow all sorts of string manipulation', function()
+    it('allows all sorts of string manipulation', function()
       eq(
         { 'hello', 'hello world', 'start hello world' },
         exec_lua [[
@@ -2161,7 +2217,7 @@ describe('lua stdlib', function()
     end)
 
     describe('option:get()', function()
-      it('should work for boolean values', function()
+      it('works for boolean values', function()
         eq(
           false,
           exec_lua [[
@@ -2171,7 +2227,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should work for number values', function()
+      it('works for number values', function()
         local tabstop = exec_lua [[
           vim.opt.tabstop = 10
           return vim.opt.tabstop:get()
@@ -2180,7 +2236,7 @@ describe('lua stdlib', function()
         eq(10, tabstop)
       end)
 
-      it('should work for string values', function()
+      it('works for string values', function()
         eq(
           'hello world',
           exec_lua [[
@@ -2190,7 +2246,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should work for set type flaglists', function()
+      it('works for set type flaglists', function()
         local formatoptions = exec_lua [[
           vim.opt.formatoptions = 'tcro'
           return vim.opt.formatoptions:get()
@@ -2200,7 +2256,7 @@ describe('lua stdlib', function()
         eq(true, not formatoptions.q)
       end)
 
-      it('should work for set type flaglists', function()
+      it('works for set type flaglists', function()
         local formatoptions = exec_lua [[
           vim.opt.formatoptions = { t = true, c = true, r = true, o = true }
           return vim.opt.formatoptions:get()
@@ -2210,7 +2266,7 @@ describe('lua stdlib', function()
         eq(true, not formatoptions.q)
       end)
 
-      it('should work for array list type options', function()
+      it('works for array list type options', function()
         local wildignore = exec_lua [[
           vim.opt.wildignore = "*.c,*.o,__pycache__"
           return vim.opt.wildignore:get()
@@ -2220,7 +2276,7 @@ describe('lua stdlib', function()
         eq('*.c', wildignore[1])
       end)
 
-      it('should work for options that are both commalist and flaglist', function()
+      it('works for options that are both commalist and flaglist', function()
         local result = exec_lua [[
           vim.opt.whichwrap = "b,s"
           return vim.opt.whichwrap:get()
@@ -2236,7 +2292,7 @@ describe('lua stdlib', function()
         eq({ b = true, h = true }, result)
       end)
 
-      it('should work for key-value pair options', function()
+      it('works for key-value pair options', function()
         local listchars = exec_lua [[
           vim.opt.listchars = "tab:> ,space:_"
           return vim.opt.listchars:get()
@@ -2248,7 +2304,7 @@ describe('lua stdlib', function()
         }, listchars)
       end)
 
-      it('should allow you to add numeric options', function()
+      it('allows you to add numeric options', function()
         eq(
           16,
           exec_lua [[
@@ -2259,7 +2315,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should allow you to subtract numeric options', function()
+      it('allows you to subtract numeric options', function()
         eq(
           2,
           exec_lua [[
@@ -2272,7 +2328,7 @@ describe('lua stdlib', function()
     end)
 
     describe('key:value style options', function()
-      it('should handle dictionary style', function()
+      it('handles dict style', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2284,7 +2340,7 @@ describe('lua stdlib', function()
         eq('eol:~,space:.', listchars)
       end)
 
-      it('should allow adding dictionary style', function()
+      it('allows adding dict style', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2299,7 +2355,7 @@ describe('lua stdlib', function()
         eq('eol:~,space:-', listchars)
       end)
 
-      it('should allow adding dictionary style', function()
+      it('allows adding dict style', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2313,7 +2369,7 @@ describe('lua stdlib', function()
         eq('eol:~,space:_', listchars)
       end)
 
-      it('should allow completely new keys', function()
+      it('allows completely new keys', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2327,7 +2383,7 @@ describe('lua stdlib', function()
         eq('eol:~,space:.,tab:>>>', listchars)
       end)
 
-      it('should allow subtracting dictionary style', function()
+      it('allows subtracting dict style', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2341,7 +2397,7 @@ describe('lua stdlib', function()
         eq('eol:~', listchars)
       end)
 
-      it('should allow subtracting dictionary style', function()
+      it('allows subtracting dict style', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2355,7 +2411,7 @@ describe('lua stdlib', function()
         eq('', listchars)
       end)
 
-      it('should allow subtracting dictionary style multiple times', function()
+      it('allows subtracting dict style multiple times', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2369,7 +2425,7 @@ describe('lua stdlib', function()
         eq('eol:~', listchars)
       end)
 
-      it('should allow adding a key:value string to a listchars', function()
+      it('allows adding a key:value string to a listchars', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2383,7 +2439,7 @@ describe('lua stdlib', function()
         eq('eol:~,space:.,tab:>~', listchars)
       end)
 
-      it('should allow prepending a key:value string to a listchars', function()
+      it('allows prepending a key:value string to a listchars', function()
         local listchars = exec_lua [[
           vim.opt.listchars = {
             eol = "~",
@@ -2398,7 +2454,7 @@ describe('lua stdlib', function()
       end)
     end)
 
-    it('should automatically set when calling remove', function()
+    it('automatically sets when calling remove', function()
       eq(
         'foo,baz',
         exec_lua [[
@@ -2410,7 +2466,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should automatically set when calling remove with a table', function()
+    it('automatically sets when calling remove with a table', function()
       eq(
         'foo',
         exec_lua [[
@@ -2422,7 +2478,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should automatically set when calling append', function()
+    it('automatically sets when calling append', function()
       eq(
         'foo,bar,baz,bing',
         exec_lua [[
@@ -2434,7 +2490,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should automatically set when calling append with a table', function()
+    it('automatically sets when calling append with a table', function()
       eq(
         'foo,bar,baz,bing,zap',
         exec_lua [[
@@ -2446,7 +2502,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should allow adding tables', function()
+    it('allows adding tables', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = 'foo'
         return vim.o.wildignore
@@ -2460,7 +2516,7 @@ describe('lua stdlib', function()
       eq('foo,bar,baz', wildignore)
     end)
 
-    it('should handle adding duplicates', function()
+    it('handles adding duplicates', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = 'foo'
         return vim.o.wildignore
@@ -2480,7 +2536,7 @@ describe('lua stdlib', function()
       eq('foo,bar,baz', wildignore)
     end)
 
-    it('should allow adding multiple times', function()
+    it('allows adding multiple times', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = 'foo'
         vim.opt.wildignore = vim.opt.wildignore + 'bar' + 'baz'
@@ -2489,7 +2545,7 @@ describe('lua stdlib', function()
       eq('foo,bar,baz', wildignore)
     end)
 
-    it('should remove values when you use minus', function()
+    it('removes values when you use minus', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = 'foo'
         return vim.o.wildignore
@@ -2509,7 +2565,7 @@ describe('lua stdlib', function()
       eq('foo,baz', wildignore)
     end)
 
-    it('should prepend values when using ^', function()
+    it('prepends values when using ^', function()
       local wildignore = exec_lua [[
         vim.opt.wildignore = 'foo'
         vim.opt.wildignore = vim.opt.wildignore ^ 'first'
@@ -2524,7 +2580,7 @@ describe('lua stdlib', function()
       eq('super_first,first,foo', wildignore)
     end)
 
-    it('should not remove duplicates from wildmode: #14708', function()
+    it('does not remove duplicates from wildmode: #14708', function()
       local wildmode = exec_lua [[
         vim.opt.wildmode = {"full", "list", "full"}
         return vim.o.wildmode
@@ -2534,7 +2590,7 @@ describe('lua stdlib', function()
     end)
 
     describe('option types', function()
-      it('should allow to set option with numeric value', function()
+      it('allows to set option with numeric value', function()
         eq(
           4,
           exec_lua [[
@@ -2583,7 +2639,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should allow to set option with boolean value', function()
+      it('allows to set option with boolean value', function()
         eq(
           true,
           exec_lua [[
@@ -2632,7 +2688,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should allow to set option with array or string value', function()
+      it('allows to set option with array or string value', function()
         eq(
           'indent,eol,start',
           exec_lua [[
@@ -2679,7 +2735,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should allow set option with map or string value', function()
+      it('allows set option with map or string value', function()
         eq(
           'eol:~,space:.',
           exec_lua [[
@@ -2729,7 +2785,7 @@ describe('lua stdlib', function()
         )
       end)
 
-      it('should allow set option with set or string value', function()
+      it('allows set option with set or string value', function()
         local ww = exec_lua [[
           vim.opt.whichwrap = {
             b = true,
@@ -3179,11 +3235,11 @@ describe('lua stdlib', function()
       ]]
     end)
 
-    it('should run from lua', function()
+    it('runs from lua', function()
       exec_lua [[vim.wait(100, function() return true end)]]
     end)
 
-    it('should wait the expected time if false', function()
+    it('waits the expected time if false', function()
       eq(
         { time = true, wait_result = { false, -1 } },
         exec_lua [[
@@ -3199,7 +3255,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should not block other events', function()
+    it('does not block other events', function()
       eq(
         { time = true, wait_result = true },
         exec_lua [[
@@ -3224,7 +3280,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should not process non-fast events when commanded', function()
+    it('does not process non-fast events when commanded', function()
       eq(
         { wait_result = false },
         exec_lua [[
@@ -3247,7 +3303,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should work with vim.defer_fn', function()
+    it('works with vim.defer_fn', function()
       eq(
         { time = true, wait_result = true },
         exec_lua [[
@@ -3264,7 +3320,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should not crash when callback errors', function()
+    it('does not crash when callback errors', function()
       local result = exec_lua [[
         return {pcall(function() vim.wait(1000, function() error("As Expected") end) end)}
       ]]
@@ -3280,7 +3336,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should allow waiting with no callback, explicit', function()
+    it('allows waiting with no callback, explicit', function()
       eq(
         true,
         exec_lua [[
@@ -3291,7 +3347,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should allow waiting with no callback, implicit', function()
+    it('allows waiting with no callback, implicit', function()
       eq(
         true,
         exec_lua [[
@@ -3302,7 +3358,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should call callbacks exactly once if they return true immediately', function()
+    it('calls callbacks exactly once if they return true immediately', function()
       eq(
         true,
         exec_lua [[
@@ -3316,7 +3372,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should call callbacks few times with large `interval`', function()
+    it('calls callbacks few times with large `interval`', function()
       eq(
         true,
         exec_lua [[
@@ -3327,7 +3383,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should play nice with `not` when fails', function()
+    it('plays nice with `not` when fails', function()
       eq(
         true,
         exec_lua [[
@@ -3340,7 +3396,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should play nice with `if` when success', function()
+    it('plays nice with `if` when success', function()
       eq(
         true,
         exec_lua [[
@@ -3353,7 +3409,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should return immediately with false if timeout is 0', function()
+    it('returns immediately with false if timeout is 0', function()
       eq(
         { false, -1 },
         exec_lua [[
@@ -3364,7 +3420,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should work with tables with __call', function()
+    it('works with tables with __call', function()
       eq(
         true,
         exec_lua [[
@@ -3374,7 +3430,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should work with tables with __call that change', function()
+    it('works with tables with __call that change', function()
       eq(
         true,
         exec_lua [[
@@ -3391,7 +3447,7 @@ describe('lua stdlib', function()
       )
     end)
 
-    it('should not work with negative intervals', function()
+    it('fails with negative intervals', function()
       local pcall_result = exec_lua [[
         return pcall(function() vim.wait(1000, function() return false end, -1) end)
       ]]
@@ -3399,7 +3455,7 @@ describe('lua stdlib', function()
       eq(false, pcall_result)
     end)
 
-    it('should not work with weird intervals', function()
+    it('fails with weird intervals', function()
       local pcall_result = exec_lua [[
         return pcall(function() vim.wait(1000, function() return false end, 'a string value') end)
       ]]
@@ -3442,7 +3498,7 @@ describe('lua stdlib', function()
       end)
     end)
 
-    it('should not run in fast callbacks #26122', function()
+    it('fails in fast callbacks #26122', function()
       local screen = Screen.new(80, 10)
       screen:attach()
       exec_lua([[
@@ -3462,15 +3518,11 @@ describe('lua stdlib', function()
 
   it('vim.notify_once', function()
     local screen = Screen.new(60, 5)
-    screen:set_default_attr_ids({
-      [0] = { bold = true, foreground = Screen.colors.Blue },
-      [1] = { foreground = Screen.colors.Red },
-    })
     screen:attach()
     screen:expect {
       grid = [[
       ^                                                            |
-      {0:~                                                           }|*3
+      {1:~                                                           }|*3
                                                                   |
     ]],
     }
@@ -3478,15 +3530,15 @@ describe('lua stdlib', function()
     screen:expect {
       grid = [[
       ^                                                            |
-      {0:~                                                           }|*3
-      {1:I'll only tell you this once...}                             |
+      {1:~                                                           }|*3
+      {19:I'll only tell you this once...}                             |
     ]],
     }
     feed('<C-l>')
     screen:expect {
       grid = [[
       ^                                                            |
-      {0:~                                                           }|*3
+      {1:~                                                           }|*3
                                                                   |
     ]],
     }
@@ -3663,10 +3715,6 @@ describe('lua stdlib', function()
     it('updates ruler if cursor moved', function()
       -- Fixed for win_execute in vim-patch:8.1.2124, but should've applied to nvim_win_call too!
       local screen = Screen.new(30, 5)
-      screen:set_default_attr_ids {
-        [1] = { reverse = true },
-        [2] = { bold = true, reverse = true },
-      }
       screen:attach()
       exec_lua [[
         _G.api = vim.api
@@ -3681,9 +3729,9 @@ describe('lua stdlib', function()
       ]]
       screen:expect [[
         19                            |
-        {1:[No Name] [+]  20,1         3%}|
-        ^19                            |
         {2:[No Name] [+]  20,1         3%}|
+        ^19                            |
+        {3:[No Name] [+]  20,1         3%}|
                                       |
       ]]
       exec_lua [[
@@ -3692,9 +3740,9 @@ describe('lua stdlib', function()
       ]]
       screen:expect [[
         99                            |
-        {1:[No Name] [+]  100,1       19%}|
+        {2:[No Name] [+]  100,1       19%}|
         ^19                            |
-        {2:[No Name] [+]  20,1         3%}|
+        {3:[No Name] [+]  20,1         3%}|
                                       |
       ]]
     end)
@@ -3810,13 +3858,6 @@ describe('lua stdlib', function()
 
   it('vim.lua_omnifunc', function()
     local screen = Screen.new(60, 5)
-    screen:set_default_attr_ids {
-      [1] = { foreground = Screen.colors.Blue1, bold = true },
-      [2] = { background = Screen.colors.WebGray },
-      [3] = { background = Screen.colors.LightMagenta },
-      [4] = { bold = true },
-      [5] = { foreground = Screen.colors.SeaGreen, bold = true },
-    }
     screen:attach()
     command [[ set omnifunc=v:lua.vim.lua_omnifunc ]]
 
@@ -3826,10 +3867,10 @@ describe('lua stdlib', function()
     screen:expect {
       grid = [[
       vim.inspect^                                                 |
-      {1:~  }{2: inspect        }{1:                                         }|
-      {1:~  }{3: inspect_pos    }{1:                                         }|
+      {1:~  }{12: inspect        }{1:                                         }|
+      {1:~  }{4: inspect_pos    }{1:                                         }|
       {1:~                                                           }|
-      {4:-- Omni completion (^O^N^P) }{5:match 1 of 2}                    |
+      {5:-- Omni completion (^O^N^P) }{6:match 1 of 2}                    |
     ]],
     }
   end)
@@ -4002,7 +4043,36 @@ end)
 describe('vim.keymap', function()
   before_each(clear)
 
-  it('can make a mapping', function()
+  it('validates', function()
+    matches(
+      'mode: expected string|table, got number',
+      pcall_err(exec_lua, [[vim.keymap.set(42, 'x', print)]])
+    )
+
+    matches(
+      'rhs: expected string|function, got nil',
+      pcall_err(exec_lua, [[vim.keymap.set('n', 'x')]])
+    )
+
+    matches(
+      'lhs: expected string, got table',
+      pcall_err(exec_lua, [[vim.keymap.set('n', {}, print)]])
+    )
+
+    matches(
+      'opts: expected table, got function',
+      pcall_err(exec_lua, [[vim.keymap.set({}, 'x', 42, function() end)]])
+    )
+
+    matches(
+      'rhs: expected string|function, got number',
+      pcall_err(exec_lua, [[vim.keymap.set('z', 'x', 42)]])
+    )
+
+    matches('Invalid mode shortname: "z"', pcall_err(exec_lua, [[vim.keymap.set('z', 'x', 'y')]]))
+  end)
+
+  it('mapping', function()
     eq(
       0,
       exec_lua [[
@@ -4017,7 +4087,7 @@ describe('vim.keymap', function()
     eq(1, exec_lua [[return GlobalCount]])
   end)
 
-  it('can make an expr mapping', function()
+  it('expr mapping', function()
     exec_lua [[
       vim.keymap.set('n', 'aa', function() return '<Insert>π<C-V><M-π>foo<lt><Esc>' end, {expr = true})
     ]]
@@ -4027,7 +4097,7 @@ describe('vim.keymap', function()
     eq({ 'π<M-π>foo<' }, api.nvim_buf_get_lines(0, 0, -1, false))
   end)
 
-  it('can overwrite a mapping', function()
+  it('overwrite a mapping', function()
     eq(
       0,
       exec_lua [[
@@ -4050,7 +4120,7 @@ describe('vim.keymap', function()
     eq(0, exec_lua [[return GlobalCount]])
   end)
 
-  it('can unmap a mapping', function()
+  it('unmap', function()
     eq(
       0,
       exec_lua [[
@@ -4074,7 +4144,7 @@ describe('vim.keymap', function()
     eq('\nNo mapping found', n.exec_capture('nmap asdf'))
   end)
 
-  it('works with buffer-local mappings', function()
+  it('buffer-local mappings', function()
     eq(
       0,
       exec_lua [[
@@ -4116,7 +4186,7 @@ describe('vim.keymap', function()
     )
   end)
 
-  it('can do <Plug> mappings', function()
+  it('<Plug> mappings', function()
     eq(
       0,
       exec_lua [[
diff --git a/test/functional/lua/watch_spec.lua b/test/functional/lua/watch_spec.lua
index bd8faadf5b..ad16df8a7c 100644
--- a/test/functional/lua/watch_spec.lua
+++ b/test/functional/lua/watch_spec.lua
@@ -12,7 +12,6 @@ local skip = t.skip
 -- events which can happen with some backends on some platforms
 local function touch(path)
   local tmp = t.tmpname()
-  io.open(tmp, 'w'):close()
   assert(vim.uv.fs_rename(tmp, path))
 end
 
@@ -22,16 +21,78 @@ describe('vim._watch', function()
   end)
 
   local function run(watchfunc)
-    it('detects file changes (watchfunc=' .. watchfunc .. '())', function()
-      if watchfunc == 'fswatch' then
+    -- Monkey-patches vim.notify_once so we can "spy" on it.
+    local function spy_notify_once()
+      exec_lua [[
+        _G.__notify_once_msgs = {}
+        vim.notify_once = (function(overridden)
+          return function(msg, level, opts)
+            table.insert(_G.__notify_once_msgs, msg)
+            return overridden(msg, level, opts)
+          end
+        end)(vim.notify_once)
+      ]]
+    end
+
+    local function last_notify_once_msg()
+      return exec_lua 'return _G.__notify_once_msgs[#_G.__notify_once_msgs]'
+    end
+
+    local function do_watch(root_dir, watchfunc_)
+      exec_lua(
+        [[
+          local root_dir, watchfunc = ...
+
+          _G.events = {}
+
+          _G.stop_watch = vim._watch[watchfunc](root_dir, {
+            debounce = 100,
+            include_pattern = vim.lpeg.P(root_dir) * vim.lpeg.P("/file") ^ -1,
+            exclude_pattern = vim.lpeg.P(root_dir .. '/file.unwatched'),
+          }, function(path, change_type)
+            table.insert(_G.events, { path = path, change_type = change_type })
+          end)
+      ]],
+        root_dir,
+        watchfunc_
+      )
+    end
+
+    it(watchfunc .. '() ignores nonexistent paths', function()
+      if watchfunc == 'inotify' then
+        skip(n.fn.executable('inotifywait') == 0, 'inotifywait not found')
+        skip(is_os('bsd'), 'inotifywait on bsd CI seems to expect path to exist?')
+      end
+
+      local msg = ('watch.%s: ENOENT: no such file or directory'):format(watchfunc)
+
+      spy_notify_once()
+      do_watch('/i am /very/funny.go', watchfunc)
+
+      if watchfunc ~= 'inotify' then -- watch.inotify() doesn't (currently) call vim.notify_once.
+        t.retry(nil, 2000, function()
+          t.eq(msg, last_notify_once_msg())
+        end)
+      end
+      eq(0, exec_lua [[return #_G.events]])
+
+      exec_lua [[_G.stop_watch()]]
+    end)
+
+    it(watchfunc .. '() detects file changes', function()
+      if watchfunc == 'inotify' then
         skip(is_os('win'), 'not supported on windows')
         skip(is_os('mac'), 'flaky test on mac')
-        skip(not is_ci() and n.fn.executable('fswatch') == 0, 'fswatch not installed and not on CI')
+        skip(not is_ci() and n.fn.executable('inotifywait') == 0, 'inotifywait not found')
       end
 
+      -- Note: because this is not `elseif`, BSD is skipped for *all* cases...?
       if watchfunc == 'watch' then
         skip(is_os('mac'), 'flaky test on mac')
         skip(is_os('bsd'), 'Stopped working on bsd after 3ca967387c49c754561c3b11a574797504d40f38')
+      elseif watchfunc == 'watchdirs' and is_os('mac') then
+        -- Bump this (or fix the bug) if CI continues to fail in future versions of macos CI.
+        skip(is_ci() and vim.uv.os_uname().release == '24.0.0', 'weird failure for macOS arm 15 CI')
       else
         skip(
           is_os('bsd'),
@@ -39,10 +100,8 @@ describe('vim._watch', function()
         )
       end
 
-      local root_dir = vim.uv.fs_mkdtemp(vim.fs.dirname(t.tmpname()) .. '/nvim_XXXXXXXXXX')
-
       local expected_events = 0
-
+      --- Waits for a new event, or fails if no events are triggered.
       local function wait_for_event()
         expected_events = expected_events + 1
         exec_lua(
@@ -63,26 +122,11 @@ describe('vim._watch', function()
         )
       end
 
+      local root_dir = vim.uv.fs_mkdtemp(vim.fs.dirname(t.tmpname(false)) .. '/nvim_XXXXXXXXXX')
       local unwatched_path = root_dir .. '/file.unwatched'
       local watched_path = root_dir .. '/file'
 
-      exec_lua(
-        [[
-          local root_dir, watchfunc = ...
-
-          _G.events = {}
-
-          _G.stop_watch = vim._watch[watchfunc](root_dir, {
-            debounce = 100,
-            include_pattern = vim.lpeg.P(root_dir) * vim.lpeg.P("/file") ^ -1,
-            exclude_pattern = vim.lpeg.P(root_dir .. '/file.unwatched'),
-          }, function(path, change_type)
-            table.insert(_G.events, { path = path, change_type = change_type })
-          end)
-      ]],
-        root_dir,
-        watchfunc
-      )
+      do_watch(root_dir, watchfunc)
 
       if watchfunc ~= 'watch' then
         vim.uv.sleep(200)
@@ -90,16 +134,13 @@ describe('vim._watch', function()
 
       touch(watched_path)
       touch(unwatched_path)
-
       wait_for_event()
 
       os.remove(watched_path)
       os.remove(unwatched_path)
-
       wait_for_event()
 
       exec_lua [[_G.stop_watch()]]
-
       -- No events should come through anymore
 
       vim.uv.sleep(100)
@@ -123,5 +164,5 @@ describe('vim._watch', function()
 
   run('watch')
   run('watchdirs')
-  run('fswatch')
+  run('inotify')
 end)
diff --git a/test/functional/lua/with_spec.lua b/test/functional/lua/with_spec.lua
new file mode 100644
index 0000000000..99b80ef749
--- /dev/null
+++ b/test/functional/lua/with_spec.lua
@@ -0,0 +1,1626 @@
+local t = require('test.testutil')
+local n = require('test.functional.testnvim')()
+local Screen = require('test.functional.ui.screen')
+
+local fn = n.fn
+local api = n.api
+local command = n.command
+local eq = t.eq
+local exec_lua = n.exec_lua
+local exec_capture = n.exec_capture
+local matches = t.matches
+local pcall_err = t.pcall_err
+
+describe('vim._with', function()
+  before_each(function()
+    n.clear()
+    exec_lua([[
+      _G.fn = vim.fn
+      _G.api = vim.api
+
+      _G.setup_buffers = function()
+        return api.nvim_create_buf(false, true), api.nvim_get_current_buf()
+      end
+
+      _G.setup_windows = function()
+        local other_win = api.nvim_get_current_win()
+        vim.cmd.new()
+        return other_win, api.nvim_get_current_win()
+      end
+    ]])
+  end)
+
+  local assert_events_trigger = function()
+    local out = exec_lua [[
+      -- Needs three global values defined:
+      -- - `test_events` - array of events which are tested.
+      -- - `test_context` - context to be tested.
+      -- - `test_trig_event` - callable triggering at least one tested event.
+      _G.n_events = 0
+      local opts = { callback = function() _G.n_events = _G.n_events + 1 end }
+      api.nvim_create_autocmd(_G.test_events, opts)
+
+      local context = { bo = { commentstring = '-- %s' } }
+
+      -- Should not trigger events on its own
+      vim._with(_G.test_context, function() end)
+      local is_no_events = _G.n_events == 0
+
+      -- Should trigger events if specifically asked inside callback
+      local is_events = vim._with(_G.test_context, function()
+        _G.test_trig_event()
+        return _G.n_events > 0
+      end)
+      return { is_no_events, is_events }
+    ]]
+    eq({ true, true }, out)
+  end
+
+  describe('`bo` context', function()
+    before_each(function()
+      exec_lua [[
+        _G.other_buf, _G.cur_buf = setup_buffers()
+
+        -- 'commentstring' is local to buffer and string
+        vim.bo[other_buf].commentstring = '## %s'
+        vim.bo[cur_buf].commentstring = '// %s'
+        vim.go.commentstring = '$$ %s'
+
+        -- 'undolevels' is global or local to buffer (global-local) and number
+        vim.bo[other_buf].undolevels = 100
+        vim.bo[cur_buf].undolevels = 250
+        vim.go.undolevels = 500
+
+        _G.get_state = function()
+          return {
+            bo = {
+              cms_cur = vim.bo[cur_buf].commentstring,
+              cms_other = vim.bo[other_buf].commentstring,
+              ul_cur = vim.bo[cur_buf].undolevels,
+              ul_other = vim.bo[other_buf].undolevels,
+            },
+            go = {
+              cms = vim.go.commentstring,
+              ul = vim.go.undolevels,
+            },
+          }
+        end
+      ]]
+    end)
+
+    it('works', function()
+      local out = exec_lua [[
+        local context = { bo = { commentstring = '-- %s', undolevels = 0 } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == cur_buf)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '-- %s', cms_other = '## %s', ul_cur = 0, ul_other = 100 },
+        go = { cms = '$$ %s', ul = 500 },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('sets options in `buf` context', function()
+      local out = exec_lua [[
+        local context = { buf = other_buf, bo = { commentstring = '-- %s', undolevels = 0 } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == other_buf)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '// %s', cms_other = '-- %s', ul_cur = 250, ul_other = 0 },
+        go = { cms = '$$ %s', ul = 500 },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('restores only options from context', function()
+      local out = exec_lua [[
+        local context = { bo = { commentstring = '-- %s' } }
+
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == cur_buf)
+          vim.bo[cur_buf].undolevels = 750
+          vim.bo[cur_buf].commentstring = '!! %s'
+          return get_state()
+        end)
+
+        return { inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '!! %s', cms_other = '## %s', ul_cur = 750, ul_other = 100 },
+        go = { cms = '$$ %s', ul = 500 },
+      }, out.inner)
+      eq({
+        bo = { cms_cur = '// %s', cms_other = '## %s', ul_cur = 750, ul_other = 100 },
+        go = { cms = '$$ %s', ul = 500 },
+      }, out.after)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = { 'BufEnter', 'BufLeave', 'BufWinEnter', 'BufWinLeave' }
+        _G.test_context = { bo = { commentstring = '-- %s' } }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        local before, before_inner, after_inner = get_state(), nil, nil
+        vim._with({ bo = { commentstring = '-- %s', undolevels = 0 } }, function()
+          before_inner = get_state()
+          inner = vim._with({ bo = { commentstring = '!! %s' } }, get_state)
+          after_inner = get_state()
+        end)
+        return {
+          before = before, before_inner = before_inner,
+          inner = inner,
+          after_inner = after_inner, after = get_state(),
+        }
+      ]]
+      eq('!! %s', out.inner.bo.cms_cur)
+      eq(0, out.inner.bo.ul_cur)
+      eq(out.before_inner, out.after_inner)
+      eq(out.before, out.after)
+    end)
+  end)
+
+  describe('`buf` context', function()
+    it('works', function()
+      local out = exec_lua [[
+        local other_buf, cur_buf = setup_buffers()
+        local inner = vim._with({ buf = other_buf }, function()
+          return api.nvim_get_current_buf()
+        end)
+        return { inner == other_buf, api.nvim_get_current_buf() == cur_buf }
+      ]]
+      eq({ true, true }, out)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = { 'BufEnter', 'BufLeave', 'BufWinEnter', 'BufWinLeave' }
+        _G.test_context = { buf = other_buf }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can access buffer options', function()
+      local out = exec_lua [[
+        other_buf, cur_buf = setup_buffers()
+        vim.bo[other_buf].commentstring = '## %s'
+        vim.bo[cur_buf].commentstring = '// %s'
+
+        vim._with({ buf = other_buf }, function()
+          vim.cmd.set('commentstring=--\\ %s')
+        end)
+
+        return vim.bo[other_buf].commentstring == '-- %s' and
+          vim.bo[cur_buf].commentstring == '// %s'
+      ]]
+      eq(true, out)
+    end)
+
+    it('works with different kinds of buffers', function()
+      exec_lua [[
+        local assert_buf = function(buf)
+          vim._with({ buf = buf }, function()
+            assert(api.nvim_get_current_buf() == buf)
+          end)
+        end
+
+        -- Current
+        assert_buf(api.nvim_get_current_buf())
+
+        -- Hidden listed
+        local listed = api.nvim_create_buf(true, true)
+        assert_buf(listed)
+
+        -- Visible
+        local other_win, cur_win = setup_windows()
+        api.nvim_win_set_buf(other_win, listed)
+        assert_buf(listed)
+
+        -- Shown but not visible
+        vim.cmd.tabnew()
+        assert_buf(listed)
+
+        -- Shown in several windows
+        api.nvim_win_set_buf(0, listed)
+        assert_buf(listed)
+
+        -- Shown in floating window
+        local float_buf = api.nvim_create_buf(false, true)
+        local config = { relative = 'editor', row = 1, col = 1, width = 5, height = 5 }
+        api.nvim_open_win(float_buf, false, config)
+        assert_buf(float_buf)
+      ]]
+    end)
+
+    it('does not cause ml_get errors with invalid visual selection', function()
+      exec_lua [[
+        api.nvim_buf_set_lines(0, 0, -1, true, { 'a', 'b', 'c' })
+        api.nvim_feedkeys(vim.keycode('G<C-V>'), 'txn', false)
+        local other_buf, _ = setup_buffers()
+        vim._with({ buf = buf }, function() vim.cmd.redraw() end)
+      ]]
+    end)
+
+    it('can be nested', function()
+      exec_lua [[
+        local other_buf, cur_buf = setup_buffers()
+        vim._with({ buf = other_buf }, function()
+          assert(api.nvim_get_current_buf() == other_buf)
+          inner = vim._with({ buf = cur_buf }, function()
+            assert(api.nvim_get_current_buf() == cur_buf)
+          end)
+          assert(api.nvim_get_current_buf() == other_buf)
+        end)
+        assert(api.nvim_get_current_buf() == cur_buf)
+      ]]
+    end)
+
+    it('can be nested crazily with hidden buffers', function()
+      local out = exec_lua([[
+        local n = 0
+        local function with_recursive_nested_bufs()
+          n = n + 1
+          if n > 20 then return true end
+
+          local other_buf, _ = setup_buffers()
+          vim.bo[other_buf].commentstring = '## %s'
+          local callback = function()
+            return api.nvim_get_current_buf() == other_buf
+              and vim.bo[other_buf].commentstring == '## %s'
+              and with_recursive_nested_bufs()
+          end
+          return vim._with({ buf = other_buf }, callback) and
+            api.nvim_buf_delete(other_buf, {}) == nil
+        end
+
+        return with_recursive_nested_bufs()
+      ]])
+      eq(true, out)
+    end)
+  end)
+
+  describe('`emsg_silent` context', function()
+    pending('works', function()
+      local ok = pcall(
+        exec_lua,
+        [[
+          _G.f = function()
+            error('This error should not interfer with execution', 0)
+          end
+          -- Should not produce error same as `vim.cmd('silent! lua _G.f()')`
+          vim._with({ emsg_silent = true }, f)
+        ]]
+      )
+      eq(true, ok)
+
+      -- Should properly report errors afterwards
+      ok = pcall(exec_lua, 'lua _G.f()')
+      eq(false, ok)
+    end)
+
+    it('can be nested', function()
+      local ok = pcall(
+        exec_lua,
+        [[
+          _G.f = function()
+            error('This error should not interfer with execution', 0)
+          end
+          -- Should produce error same as `_G.f()`
+          vim._with({ emsg_silent = true }, function()
+            vim._with( { emsg_silent = false }, f)
+          end)
+        ]]
+      )
+      eq(false, ok)
+    end)
+  end)
+
+  describe('`env` context', function()
+    before_each(function()
+      exec_lua [[
+        vim.fn.setenv('aaa', 'hello')
+        _G.get_state = function()
+          return { aaa = vim.fn.getenv('aaa'), bbb = vim.fn.getenv('bbb') }
+        end
+      ]]
+    end)
+
+    it('works', function()
+      local out = exec_lua [[
+        local context = { env = { aaa = 'inside', bbb = 'wow' } }
+        local before = get_state()
+        local inner = vim._with(context, get_state)
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({ aaa = 'inside', bbb = 'wow' }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('restores only variables from context', function()
+      local out = exec_lua [[
+        local context = { env = { bbb = 'wow' } }
+        local before = get_state()
+        local inner = vim._with(context, function()
+          vim.env.aaa = 'inside'
+          return get_state()
+        end)
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({ aaa = 'inside', bbb = 'wow' }, out.inner)
+      eq({ aaa = 'inside', bbb = vim.NIL }, out.after)
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        local before, before_inner, after_inner = get_state(), nil, nil
+        vim._with({ env = { aaa = 'inside', bbb = 'wow' } }, function()
+          before_inner = get_state()
+          inner = vim._with({ env = { aaa = 'more inside' } }, get_state)
+          after_inner = get_state()
+        end)
+        return {
+          before = before, before_inner = before_inner,
+          inner = inner,
+          after_inner = after_inner, after = get_state(),
+        }
+      ]]
+      eq('more inside', out.inner.aaa)
+      eq('wow', out.inner.bbb)
+      eq(out.before_inner, out.after_inner)
+      eq(out.before, out.after)
+    end)
+  end)
+
+  describe('`go` context', function()
+    before_each(function()
+      exec_lua [[
+        vim.bo.commentstring = '## %s'
+        vim.go.commentstring = '$$ %s'
+        vim.wo.winblend = 25
+        vim.go.winblend = 50
+        vim.go.langmap = 'xy,yx'
+
+        _G.get_state = function()
+          return {
+            bo = { cms = vim.bo.commentstring },
+            wo = { winbl = vim.wo.winblend },
+            go = {
+              cms = vim.go.commentstring,
+              winbl = vim.go.winblend,
+              lmap = vim.go.langmap,
+            },
+          }
+        end
+      ]]
+    end)
+
+    it('works', function()
+      local out = exec_lua [[
+        local context = {
+          go = { commentstring = '-- %s', winblend = 75, langmap = 'ab,ba' },
+        }
+        local before = get_state()
+        local inner = vim._with(context, get_state)
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms = '## %s' },
+        wo = { winbl = 25 },
+        go = { cms = '-- %s', winbl = 75, lmap = 'ab,ba' },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('works with `eventignore`', function()
+      -- This might be an issue if saving and restoring option context is done
+      -- to account for triggering `OptionSet`, but in not a good way
+      local out = exec_lua [[
+        vim.go.eventignore = 'ModeChanged'
+        local inner = vim._with({ go = { eventignore = 'CursorMoved' } }, function()
+          return vim.go.eventignore
+        end)
+        return { inner = inner, after = vim.go.eventignore }
+      ]]
+      eq({ inner = 'CursorMoved', after = 'ModeChanged' }, out)
+    end)
+
+    it('restores only options from context', function()
+      local out = exec_lua [[
+        local context = { go = { langmap = 'ab,ba' } }
+
+        local inner = vim._with(context, function()
+          vim.go.commentstring = '!! %s'
+          vim.go.winblend = 75
+          vim.go.langmap = 'uv,vu'
+          return get_state()
+        end)
+
+        return { inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms = '## %s' },
+        wo = { winbl = 25 },
+        go = { cms = '!! %s', winbl = 75, lmap = 'uv,vu' },
+      }, out.inner)
+      eq({
+        bo = { cms = '## %s' },
+        wo = { winbl = 25 },
+        go = { cms = '!! %s', winbl = 75, lmap = 'xy,yx' },
+      }, out.after)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = {
+          'BufEnter', 'BufLeave', 'BufWinEnter', 'BufWinLeave', 'WinEnter', 'WinLeave'
+        }
+        _G.test_context = { go = { commentstring = '-- %s', winblend = 75, langmap = 'ab,ba' } }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        local before, before_inner, after_inner = get_state(), nil, nil
+        vim._with({ go = { langmap = 'ab,ba', commentstring = '-- %s' } }, function()
+          before_inner = get_state()
+          inner = vim._with({ go = { langmap = 'uv,vu' } }, get_state)
+          after_inner = get_state()
+        end)
+        return {
+          before = before, before_inner = before_inner,
+          inner = inner,
+          after_inner = after_inner, after = get_state(),
+        }
+      ]]
+      eq('uv,vu', out.inner.go.lmap)
+      eq('-- %s', out.inner.go.cms)
+      eq(out.before_inner, out.after_inner)
+      eq(out.before, out.after)
+    end)
+  end)
+
+  describe('`hide` context', function()
+    pending('works', function()
+      local ok = pcall(
+        exec_lua,
+        [[
+          vim.o.hidden = false
+          vim.bo.modified = true
+          local init_buf = api.nvim_get_current_buf()
+          -- Should not produce error same as `vim.cmd('hide enew')`
+          vim._with({ hide = true }, function()
+            vim.cmd.enew()
+          end)
+          assert(api.nvim_get_current_buf() ~= init_buf)
+        ]]
+      )
+      eq(true, ok)
+    end)
+
+    it('can be nested', function()
+      local ok = pcall(
+        exec_lua,
+        [[
+          vim.o.hidden = false
+          vim.bo.modified = true
+          -- Should produce error same as `vim.cmd.enew()`
+          vim._with({ hide = true }, function()
+            vim._with({ hide = false }, function()
+              vim.cmd.enew()
+            end)
+          end)
+        ]]
+      )
+      eq(false, ok)
+    end)
+  end)
+
+  describe('`horizontal` context', function()
+    local is_approx_eq = function(dim, id_1, id_2)
+      local f = dim == 'height' and api.nvim_win_get_height or api.nvim_win_get_width
+      return math.abs(f(id_1) - f(id_2)) <= 1
+    end
+
+    local win_id_1, win_id_2, win_id_3
+    before_each(function()
+      win_id_1 = api.nvim_get_current_win()
+      command('wincmd v | wincmd 5>')
+      win_id_2 = api.nvim_get_current_win()
+      command('wincmd s | wincmd 5+')
+      win_id_3 = api.nvim_get_current_win()
+
+      eq(is_approx_eq('width', win_id_1, win_id_2), false)
+      eq(is_approx_eq('height', win_id_3, win_id_2), false)
+    end)
+
+    pending('works', function()
+      exec_lua [[
+        -- Should be same as `vim.cmd('horizontal wincmd =')`
+        vim._with({ horizontal = true }, function()
+          vim.cmd.wincmd('=')
+        end)
+      ]]
+      eq(is_approx_eq('width', win_id_1, win_id_2), true)
+      eq(is_approx_eq('height', win_id_3, win_id_2), false)
+    end)
+
+    pending('can be nested', function()
+      exec_lua [[
+        -- Should be same as `vim.cmd.wincmd('=')`
+        vim._with({ horizontal = true }, function()
+          vim._with({ horizontal = false }, function()
+            vim.cmd.wincmd('=')
+          end)
+        end)
+      ]]
+      eq(is_approx_eq('width', win_id_1, win_id_2), true)
+      eq(is_approx_eq('height', win_id_3, win_id_2), true)
+    end)
+  end)
+
+  describe('`keepalt` context', function()
+    pending('works', function()
+      local out = exec_lua [[
+        vim.cmd('edit alt')
+        vim.cmd('edit new')
+        assert(fn.bufname('#') == 'alt')
+
+        -- Should work as `vim.cmd('keepalt edit very-new')`
+        vim._with({ keepalt = true }, function()
+          vim.cmd.edit('very-new')
+        end)
+        return fn.bufname('#') == 'alt'
+      ]]
+      eq(true, out)
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        vim.cmd('edit alt')
+        vim.cmd('edit new')
+        assert(fn.bufname('#') == 'alt')
+
+        -- Should work as `vim.cmd.edit('very-new')`
+        vim._with({ keepalt = true }, function()
+          vim._with({ keepalt = false }, function()
+            vim.cmd.edit('very-new')
+          end)
+        end)
+        return fn.bufname('#') == 'alt'
+      ]]
+      eq(false, out)
+    end)
+  end)
+
+  describe('`keepjumps` context', function()
+    pending('works', function()
+      local out = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'aaa', 'bbb', 'ccc' })
+        local jumplist_before = fn.getjumplist()
+        -- Should work as `vim.cmd('keepjumps normal! Ggg')`
+        vim._with({ keepjumps = true }, function()
+          vim.cmd('normal! Ggg')
+        end)
+        return vim.deep_equal(jumplist_before, fn.getjumplist())
+      ]]
+      eq(true, out)
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'aaa', 'bbb', 'ccc' })
+        local jumplist_before = fn.getjumplist()
+        vim._with({ keepjumps = true }, function()
+          vim._with({ keepjumps = false }, function()
+            vim.cmd('normal! Ggg')
+          end)
+        end)
+        return vim.deep_equal(jumplist_before, fn.getjumplist())
+      ]]
+      eq(false, out)
+    end)
+  end)
+
+  describe('`keepmarks` context', function()
+    pending('works', function()
+      local out = exec_lua [[
+        vim.cmd('set cpoptions+=R')
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'bbb', 'ccc', 'aaa' })
+        api.nvim_buf_set_mark(0, 'm', 2, 2, {})
+
+        -- Should be the same as `vim.cmd('keepmarks %!sort')`
+        vim._with({ keepmarks = true }, function()
+          vim.cmd('%!sort')
+        end)
+        return api.nvim_buf_get_mark(0, 'm')
+      ]]
+      eq({ 2, 2 }, out)
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        vim.cmd('set cpoptions+=R')
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'bbb', 'ccc', 'aaa' })
+        api.nvim_buf_set_mark(0, 'm', 2, 2, {})
+
+        vim._with({ keepmarks = true }, function()
+          vim._with({ keepmarks = false }, function()
+            vim.cmd('%!sort')
+          end)
+        end)
+        return api.nvim_buf_get_mark(0, 'm')
+      ]]
+      eq({ 0, 2 }, out)
+    end)
+  end)
+
+  describe('`keepatterns` context', function()
+    pending('works', function()
+      local out = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'aaa', 'bbb' })
+        vim.cmd('/aaa')
+        -- Should be the same as `vim.cmd('keeppatterns /bbb')`
+        vim._with({ keeppatterns = true }, function()
+          vim.cmd('/bbb')
+        end)
+        return fn.getreg('/')
+      ]]
+      eq('aaa', out)
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'aaa', 'bbb' })
+        vim.cmd('/aaa')
+        vim._with({ keeppatterns = true }, function()
+          vim._with({ keeppatterns = false }, function()
+            vim.cmd('/bbb')
+          end)
+        end)
+        return fn.getreg('/')
+      ]]
+      eq('bbb', out)
+    end)
+  end)
+
+  describe('`lockmarks` context', function()
+    it('works', function()
+      local mark = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, 0, false, { 'aaa', 'bbb', 'ccc' })
+        api.nvim_buf_set_mark(0, 'm', 2, 2, {})
+        -- Should be same as `:lockmarks lua api.nvim_buf_set_lines(...)`
+        vim._with({ lockmarks = true }, function()
+          api.nvim_buf_set_lines(0, 0, 2, false, { 'uuu', 'vvv', 'www' })
+        end)
+        return api.nvim_buf_get_mark(0, 'm')
+      ]]
+      eq({ 2, 2 }, mark)
+    end)
+
+    it('can be nested', function()
+      local mark = exec_lua [[
+        api.nvim_buf_set_lines(0, 0, 0, false, { 'aaa', 'bbb', 'ccc' })
+        api.nvim_buf_set_mark(0, 'm', 2, 2, {})
+        vim._with({ lockmarks = true }, function()
+          vim._with({ lockmarks = false }, function()
+            api.nvim_buf_set_lines(0, 0, 2, false, { 'uuu', 'vvv', 'www' })
+          end)
+        end)
+        return api.nvim_buf_get_mark(0, 'm')
+      ]]
+      eq({ 0, 2 }, mark)
+    end)
+  end)
+
+  describe('`noautocmd` context', function()
+    it('works', function()
+      local out = exec_lua [[
+        _G.n_events = 0
+        vim.cmd('au ModeChanged * lua _G.n_events = _G.n_events + 1')
+        -- Should be the same as `vim.cmd('noautocmd normal! vv')`
+        vim._with({ noautocmd = true }, function()
+          vim.cmd('normal! vv')
+        end)
+        return _G.n_events
+      ]]
+      eq(0, out)
+    end)
+
+    it('works with User events', function()
+      local out = exec_lua [[
+        _G.n_events = 0
+        vim.cmd('au User MyEvent lua _G.n_events = _G.n_events + 1')
+        -- Should be the same as `vim.cmd('noautocmd doautocmd User MyEvent')`
+        vim._with({ noautocmd = true }, function()
+          api.nvim_exec_autocmds('User', { pattern = 'MyEvent' })
+        end)
+        return _G.n_events
+      ]]
+      eq(0, out)
+    end)
+
+    pending('can be nested', function()
+      local out = exec_lua [[
+        _G.n_events = 0
+        vim.cmd('au ModeChanged * lua _G.n_events = _G.n_events + 1')
+        vim._with({ noautocmd = true }, function()
+          vim._with({ noautocmd = false }, function()
+            vim.cmd('normal! vv')
+          end)
+        end)
+        return _G.n_events
+      ]]
+      eq(2, out)
+    end)
+  end)
+
+  describe('`o` context', function()
+    before_each(function()
+      exec_lua [[
+        _G.other_win, _G.cur_win = setup_windows()
+        _G.other_buf, _G.cur_buf = setup_buffers()
+
+        vim.bo[other_buf].commentstring = '## %s'
+        vim.bo[cur_buf].commentstring = '// %s'
+        vim.go.commentstring = '$$ %s'
+
+        vim.bo[other_buf].undolevels = 100
+        vim.bo[cur_buf].undolevels = 250
+        vim.go.undolevels = 500
+
+        vim.wo[other_win].virtualedit = 'block'
+        vim.wo[cur_win].virtualedit = 'insert'
+        vim.go.virtualedit = 'none'
+
+        vim.wo[other_win].winblend = 10
+        vim.wo[cur_win].winblend = 25
+        vim.go.winblend = 50
+
+        vim.go.langmap = 'xy,yx'
+
+        _G.get_state = function()
+          return {
+            bo = {
+              cms_cur = vim.bo[cur_buf].commentstring,
+              cms_other = vim.bo[other_buf].commentstring,
+              ul_cur = vim.bo[cur_buf].undolevels,
+              ul_other = vim.bo[other_buf].undolevels,
+            },
+            wo = {
+              ve_cur = vim.wo[cur_win].virtualedit,
+              ve_other = vim.wo[other_win].virtualedit,
+              winbl_cur = vim.wo[cur_win].winblend,
+              winbl_other = vim.wo[other_win].winblend,
+            },
+            go = {
+              cms = vim.go.commentstring,
+              ul = vim.go.undolevels,
+              ve = vim.go.virtualedit,
+              winbl = vim.go.winblend,
+              lmap = vim.go.langmap,
+            },
+          }
+        end
+      ]]
+    end)
+
+    it('works', function()
+      local out = exec_lua [[
+        local context = {
+          o = {
+            commentstring = '-- %s',
+            undolevels = 0,
+            virtualedit = 'all',
+            winblend = 75,
+            langmap = 'ab,ba',
+          },
+        }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == cur_buf)
+          assert(api.nvim_get_current_win() == cur_win)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      -- Options in context are set with `vim.o`, so usually both local
+      -- and global values are affected. Yet all of them should be later
+      -- restored to pre-context values.
+      eq({
+        bo = { cms_cur = '-- %s', cms_other = '## %s', ul_cur = -123456, ul_other = 100 },
+        wo = { ve_cur = 'all', ve_other = 'block', winbl_cur = 75, winbl_other = 10 },
+        go = { cms = '-- %s', ul = 0, ve = 'all', winbl = 75, lmap = 'ab,ba' },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('sets options in `buf` context', function()
+      local out = exec_lua [[
+        local context = { buf = other_buf, o = { commentstring = '-- %s', undolevels = 0 } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == other_buf)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '// %s', cms_other = '-- %s', ul_cur = 250, ul_other = -123456 },
+        wo = { ve_cur = 'insert', ve_other = 'block', winbl_cur = 25, winbl_other = 10 },
+        -- Global `winbl` inside context ideally should be untouched and equal
+        -- to 50. It seems to be equal to 0 because `context.buf` uses
+        -- `aucmd_prepbuf` C approach which has no guarantees about window or
+        -- window option values inside context.
+        go = { cms = '-- %s', ul = 0, ve = 'none', winbl = 0, lmap = 'xy,yx' },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('sets options in `win` context', function()
+      local out = exec_lua [[
+        local context = { win = other_win, o = { winblend = 75, virtualedit = 'all' } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_win() == other_win)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '// %s', cms_other = '## %s', ul_cur = 250, ul_other = 100 },
+        wo = { winbl_cur = 25, winbl_other = 75, ve_cur = 'insert', ve_other = 'all' },
+        go = { cms = '$$ %s', ul = 500, winbl = 75, ve = 'all', lmap = 'xy,yx' },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('restores only options from context', function()
+      local out = exec_lua [[
+        local context = { o = { undolevels = 0, winblend = 75, langmap = 'ab,ba' } }
+
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_buf() == cur_buf)
+          assert(api.nvim_get_current_win() == cur_win)
+
+          vim.o.commentstring = '!! %s'
+          vim.o.undolevels = 750
+          vim.o.virtualedit = 'onemore'
+          vim.o.winblend = 99
+          vim.o.langmap = 'uv,vu'
+          return get_state()
+        end)
+
+        return { inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        bo = { cms_cur = '!! %s', cms_other = '## %s', ul_cur = -123456, ul_other = 100 },
+        wo = { ve_cur = 'onemore', ve_other = 'block', winbl_cur = 99, winbl_other = 10 },
+        go = { cms = '!! %s', ul = 750, ve = 'onemore', winbl = 99, lmap = 'uv,vu' },
+      }, out.inner)
+      eq({
+        bo = { cms_cur = '!! %s', cms_other = '## %s', ul_cur = 250, ul_other = 100 },
+        wo = { ve_cur = 'onemore', ve_other = 'block', winbl_cur = 25, winbl_other = 10 },
+        go = { cms = '!! %s', ul = 500, ve = 'onemore', winbl = 50, lmap = 'xy,yx' },
+      }, out.after)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = {
+          'BufEnter', 'BufLeave', 'WinEnter', 'WinLeave', 'BufWinEnter', 'BufWinLeave'
+        }
+        _G.test_context = { o = { undolevels = 0, winblend = 75, langmap = 'ab,ba' } }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        local before, before_inner, after_inner = get_state(), nil, nil
+        local cxt_o = { commentstring = '-- %s', winblend = 75, langmap = 'ab,ba', undolevels = 0 }
+        vim._with({ o = cxt_o }, function()
+          before_inner = get_state()
+          local inner_cxt_o = { commentstring = '!! %s', winblend = 99, langmap = 'uv,vu' }
+          inner = vim._with({ o = inner_cxt_o }, get_state)
+          after_inner = get_state()
+        end)
+        return {
+          before = before, before_inner = before_inner,
+          inner = inner,
+          after_inner = after_inner, after = get_state(),
+        }
+      ]]
+      eq('!! %s', out.inner.bo.cms_cur)
+      eq(99, out.inner.wo.winbl_cur)
+      eq('uv,vu', out.inner.go.lmap)
+      eq(0, out.inner.go.ul)
+      eq(out.before_inner, out.after_inner)
+      eq(out.before, out.after)
+    end)
+  end)
+
+  describe('`sandbox` context', function()
+    it('works', function()
+      local ok, err = pcall(
+        exec_lua,
+        [[
+          -- Should work as `vim.cmd('sandbox call append(0, "aaa")')`
+          vim._with({ sandbox = true }, function()
+            fn.append(0, 'aaa')
+          end)
+        ]]
+      )
+      eq(false, ok)
+      matches('Not allowed in sandbox', err)
+    end)
+
+    it('can NOT be nested', function()
+      -- This behavior is intentionally different from other flags as allowing
+      -- disabling `sandbox` from nested function seems to be against the point
+      -- of using `sandbox` context in the first place
+      local ok, err = pcall(
+        exec_lua,
+        [[
+          vim._with({ sandbox = true }, function()
+            vim._with({ sandbox = false }, function()
+              fn.append(0, 'aaa')
+            end)
+          end)
+        ]]
+      )
+      eq(false, ok)
+      matches('Not allowed in sandbox', err)
+    end)
+  end)
+
+  describe('`silent` context', function()
+    it('works', function()
+      exec_lua [[
+        -- Should be same as `vim.cmd('silent lua print("aaa")')`
+        vim._with({ silent = true }, function() print('aaa') end)
+      ]]
+      eq('', exec_capture('messages'))
+
+      exec_lua [[ vim._with({ silent = true }, function() vim.cmd.echomsg('"bbb"') end) ]]
+      eq('', exec_capture('messages'))
+
+      local screen = Screen.new(20, 5)
+      screen:set_default_attr_ids {
+        [1] = { bold = true, reverse = true },
+        [2] = { bold = true, foreground = Screen.colors.Blue },
+      }
+      screen:attach()
+      exec_lua [[ vim._with({ silent = true }, function() vim.cmd.echo('"ccc"') end) ]]
+      screen:expect [[
+        ^                    |
+        {2:~                   }|*3
+                            |
+      ]]
+    end)
+
+    pending('can be nested', function()
+      exec_lua [[ vim._with({ silent = true }, function()
+        vim._with({ silent = false }, function()
+          print('aaa')
+        end)
+      end)]]
+      eq('aaa', exec_capture('messages'))
+    end)
+  end)
+
+  describe('`unsilent` context', function()
+    it('works', function()
+      exec_lua [[
+        _G.f = function()
+          -- Should be same as `vim.cmd('unsilent lua print("aaa")')`
+          vim._with({ unsilent = true }, function() print('aaa') end)
+        end
+      ]]
+      command('silent lua f()')
+      eq('aaa', exec_capture('messages'))
+    end)
+
+    pending('can be nested', function()
+      exec_lua [[
+        _G.f = function()
+          vim._with({ unsilent = true }, function()
+            vim._with({ unsilent = false }, function() print('aaa') end)
+          end)
+        end
+      ]]
+      command('silent lua f()')
+      eq('', exec_capture('messages'))
+    end)
+  end)
+
+  describe('`win` context', function()
+    it('works', function()
+      local out = exec_lua [[
+        local other_win, cur_win = setup_windows()
+        local inner = vim._with({ win = other_win }, function()
+          return api.nvim_get_current_win()
+        end)
+        return { inner == other_win, api.nvim_get_current_win() == cur_win }
+      ]]
+      eq({ true, true }, out)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = { 'WinEnter', 'WinLeave', 'BufWinEnter', 'BufWinLeave' }
+        _G.test_context = { win = other_win }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can access window options', function()
+      local out = exec_lua [[
+        local other_win, cur_win = setup_windows()
+        vim.wo[other_win].winblend = 10
+        vim.wo[cur_win].winblend = 25
+
+        vim._with({ win = other_win }, function()
+          vim.cmd.setlocal('winblend=0')
+        end)
+
+        return vim.wo[other_win].winblend == 0 and vim.wo[cur_win].winblend == 25
+      ]]
+      eq(true, out)
+    end)
+
+    it('works with different kinds of windows', function()
+      exec_lua [[
+        local assert_win = function(win)
+          vim._with({ win = win }, function()
+            assert(api.nvim_get_current_win() == win)
+          end)
+        end
+
+        -- Current
+        assert_win(api.nvim_get_current_win())
+
+        -- Not visible
+        local other_win, cur_win = setup_windows()
+        vim.cmd.tabnew()
+        assert_win(other_win)
+
+        -- Floating
+        local float_win = api.nvim_open_win(
+          api.nvim_create_buf(false, true),
+          false,
+          { relative = 'editor', row = 1, col = 1, height = 5, width = 5}
+        )
+        assert_win(float_win)
+      ]]
+    end)
+
+    it('does not cause ml_get errors with invalid visual selection', function()
+      exec_lua [[
+        local feedkeys = function(keys) api.nvim_feedkeys(vim.keycode(keys), 'txn', false) end
+
+        -- Add lines to the current buffer and make another window looking into an empty buffer.
+        local win_empty, win_lines = setup_windows()
+        api.nvim_buf_set_lines(0, 0, -1, true, { 'a', 'b', 'c' })
+
+        -- Start Visual in current window, redraw in other window with fewer lines.
+        -- Should be fixed by vim-patch:8.2.4018.
+        feedkeys('G<C-V>')
+        vim._with({ win = win_empty }, function() vim.cmd.redraw() end)
+
+        -- Start Visual in current window, extend it in other window with more lines.
+        -- Fixed for win_execute by vim-patch:8.2.4026, but nvim_win_call should also not be affected.
+        feedkeys('<Esc>gg')
+        api.nvim_set_current_win(win_empty)
+        feedkeys('gg<C-V>')
+        vim._with({ win = win_lines }, function() feedkeys('G<C-V>') end)
+        vim.cmd.redraw()
+      ]]
+    end)
+
+    it('can be nested', function()
+      exec_lua [[
+        local other_win, cur_win = setup_windows()
+        vim._with({ win = other_win }, function()
+          assert(api.nvim_get_current_win() == other_win)
+          inner = vim._with({ win = cur_win }, function()
+            assert(api.nvim_get_current_win() == cur_win)
+          end)
+          assert(api.nvim_get_current_win() == other_win)
+        end)
+        assert(api.nvim_get_current_win() == cur_win)
+      ]]
+    end)
+
+    it('updates ruler if cursor moved', function()
+      local screen = Screen.new(30, 5)
+      screen:set_default_attr_ids {
+        [1] = { reverse = true },
+        [2] = { bold = true, reverse = true },
+      }
+      screen:attach()
+      exec_lua [[
+        vim.opt.ruler = true
+        local lines = {}
+        for i = 0, 499 do lines[#lines + 1] = tostring(i) end
+        api.nvim_buf_set_lines(0, 0, -1, true, lines)
+        api.nvim_win_set_cursor(0, { 20, 0 })
+        vim.cmd 'split'
+        _G.win = api.nvim_get_current_win()
+        vim.cmd "wincmd w | redraw"
+      ]]
+      screen:expect [[
+        19                            |
+        {1:[No Name] [+]  20,1         3%}|
+        ^19                            |
+        {2:[No Name] [+]  20,1         3%}|
+                                      |
+      ]]
+      exec_lua [[
+        vim._with({ win = win }, function() api.nvim_win_set_cursor(0, { 100, 0 }) end)
+        vim.cmd "redraw"
+      ]]
+      screen:expect [[
+        99                            |
+        {1:[No Name] [+]  100,1       19%}|
+        ^19                            |
+        {2:[No Name] [+]  20,1         3%}|
+                                      |
+      ]]
+    end)
+
+    it('layout in current tabpage does not affect windows in others', function()
+      command('tab split')
+      local t2_move_win = api.nvim_get_current_win()
+      command('vsplit')
+      local t2_other_win = api.nvim_get_current_win()
+      command('tabprevious')
+      matches('E36: Not enough room$', pcall_err(command, 'execute "split|"->repeat(&lines)'))
+      command('vsplit')
+
+      exec_lua('vim._with({ win = ... }, function() vim.cmd.wincmd "J" end)', t2_move_win)
+      eq({ 'col', { { 'leaf', t2_other_win }, { 'leaf', t2_move_win } } }, fn.winlayout(2))
+    end)
+  end)
+
+  describe('`wo` context', function()
+    before_each(function()
+      exec_lua [[
+        _G.other_win, _G.cur_win = setup_windows()
+
+        -- 'virtualedit' is global or local to window (global-local) and string
+        vim.wo[other_win].virtualedit = 'block'
+        vim.wo[cur_win].virtualedit = 'insert'
+        vim.go.virtualedit = 'none'
+
+        -- 'winblend' is local to window and number
+        vim.wo[other_win].winblend = 10
+        vim.wo[cur_win].winblend = 25
+        vim.go.winblend = 50
+
+        _G.get_state = function()
+          return {
+            wo = {
+              ve_cur = vim.wo[cur_win].virtualedit,
+              ve_other = vim.wo[other_win].virtualedit,
+              winbl_cur = vim.wo[cur_win].winblend,
+              winbl_other = vim.wo[other_win].winblend,
+            },
+            go = {
+              ve = vim.go.virtualedit,
+              winbl = vim.go.winblend,
+            },
+          }
+        end
+      ]]
+    end)
+
+    it('works', function()
+      local out = exec_lua [[
+        local context = { wo = { virtualedit = 'all', winblend = 75 } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_win() == cur_win)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        wo = { ve_cur = 'all', ve_other = 'block', winbl_cur = 75, winbl_other = 10 },
+        go = { ve = 'none', winbl = 75 },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('sets options in `win` context', function()
+      local out = exec_lua [[
+        local context = { win = other_win, wo = { virtualedit = 'all', winblend = 75 } }
+
+        local before = get_state()
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_win() == other_win)
+          return get_state()
+        end)
+
+        return { before = before, inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        wo = { ve_cur = 'insert', ve_other = 'all', winbl_cur = 25, winbl_other = 75 },
+        go = { ve = 'none', winbl = 75 },
+      }, out.inner)
+      eq(out.before, out.after)
+    end)
+
+    it('restores only options from context', function()
+      local out = exec_lua [[
+        local context = { wo = { winblend = 75 } }
+
+        local inner = vim._with(context, function()
+          assert(api.nvim_get_current_win() == cur_win)
+          vim.wo[cur_win].virtualedit = 'onemore'
+          vim.wo[cur_win].winblend = 99
+          return get_state()
+        end)
+
+        return { inner = inner, after = get_state() }
+      ]]
+
+      eq({
+        wo = { ve_cur = 'onemore', ve_other = 'block', winbl_cur = 99, winbl_other = 10 },
+        go = { ve = 'none', winbl = 99 },
+      }, out.inner)
+      eq({
+        wo = { ve_cur = 'onemore', ve_other = 'block', winbl_cur = 25, winbl_other = 10 },
+        go = { ve = 'none', winbl = 50 },
+      }, out.after)
+    end)
+
+    it('does not trigger events', function()
+      exec_lua [[
+        _G.test_events = { 'WinEnter', 'WinLeave', 'BufWinEnter', 'BufWinLeave' }
+        _G.test_context = { wo = { winblend = 75 } }
+        _G.test_trig_event = function() vim.cmd.new() end
+      ]]
+      assert_events_trigger()
+    end)
+
+    it('can be nested', function()
+      local out = exec_lua [[
+        local before, before_inner, after_inner = get_state(), nil, nil
+        vim._with({ wo = { winblend = 75, virtualedit = 'all' } }, function()
+          before_inner = get_state()
+          inner = vim._with({ wo = { winblend = 99 } }, get_state)
+          after_inner = get_state()
+        end)
+        return {
+          before = before, before_inner = before_inner,
+          inner = inner,
+          after_inner = after_inner, after = get_state(),
+        }
+      ]]
+      eq(99, out.inner.wo.winbl_cur)
+      eq('all', out.inner.wo.ve_cur)
+      eq(out.before_inner, out.after_inner)
+      eq(out.before, out.after)
+    end)
+  end)
+
+  it('returns what callback returns', function()
+    local out_verify = exec_lua [[
+      out = { vim._with({}, function()
+        return 'a', 2, nil, { 4 }, function() end
+      end) }
+      return {
+        out[1] == 'a', out[2] == 2, out[3] == nil,
+        vim.deep_equal(out[4], { 4 }),
+        type(out[5]) == 'function',
+        vim.tbl_count(out),
+      }
+    ]]
+    eq({ true, true, true, true, true, 4 }, out_verify)
+  end)
+
+  it('can return values by reference', function()
+    local out = exec_lua [[
+      local val = { 4, 10 }
+      local ref = vim._with({}, function() return val end)
+      ref[1] = 7
+      return val
+    ]]
+    eq({ 7, 10 }, out)
+  end)
+
+  it('can not work with conflicting `buf` and `win`', function()
+    local out = exec_lua [[
+      local other_buf, cur_buf = setup_buffers()
+      local other_win, cur_win = setup_windows()
+      assert(api.nvim_win_get_buf(other_win) ~= other_buf)
+      local _, err = pcall(vim._with, { buf = other_buf, win = other_win }, function() end)
+      return err
+    ]]
+    matches('Can not set both `buf` and `win`', out)
+  end)
+
+  it('works with several contexts at once', function()
+    local out = exec_lua [[
+      local other_buf, cur_buf = setup_buffers()
+      vim.bo[other_buf].commentstring = '## %s'
+      api.nvim_buf_set_lines(other_buf, 0, -1, false, { 'aaa', 'bbb', 'ccc' })
+      api.nvim_buf_set_mark(other_buf, 'm', 2, 2, {})
+
+      vim.go.commentstring = '// %s'
+      vim.go.langmap = 'xy,yx'
+
+      local context = {
+        buf = other_buf,
+        bo = { commentstring = '-- %s' },
+        go = { langmap = 'ab,ba' },
+        lockmarks = true,
+      }
+
+      local inner = vim._with(context, function()
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'uuu', 'vvv', 'www' })
+        return {
+          buf = api.nvim_get_current_buf(),
+          bo = { cms = vim.bo.commentstring },
+          go = { cms = vim.go.commentstring, lmap = vim.go.langmap },
+          mark = api.nvim_buf_get_mark(0, 'm')
+        }
+      end)
+
+      local after = {
+        buf = api.nvim_get_current_buf(),
+        bo = { cms = vim.bo[other_buf].commentstring },
+        go = { cms = vim.go.commentstring, lmap = vim.go.langmap },
+        mark = api.nvim_buf_get_mark(other_buf, 'm')
+      }
+
+      return {
+        context_buf = other_buf, cur_buf = cur_buf,
+        inner = inner, after = after
+      }
+    ]]
+
+    eq({
+      buf = out.context_buf,
+      bo = { cms = '-- %s' },
+      go = { cms = '// %s', lmap = 'ab,ba' },
+      mark = { 2, 2 },
+    }, out.inner)
+    eq({
+      buf = out.cur_buf,
+      bo = { cms = '## %s' },
+      go = { cms = '// %s', lmap = 'xy,yx' },
+      mark = { 2, 2 },
+    }, out.after)
+  end)
+
+  it('works with same option set in different contexts', function()
+    local out = exec_lua [[
+      local get_state = function()
+        return {
+          bo = { cms = vim.bo.commentstring },
+          wo = { ve = vim.wo.virtualedit },
+          go = { cms = vim.go.commentstring, ve = vim.go.virtualedit },
+        }
+      end
+
+      vim.bo.commentstring = '// %s'
+      vim.go.commentstring = '$$ %s'
+      vim.wo.virtualedit = 'insert'
+      vim.go.virtualedit = 'none'
+
+      local before = get_state()
+      local context_no_go = {
+        o = { commentstring = '-- %s', virtualedit = 'all' },
+        bo = { commentstring = '!! %s' },
+        wo = { virtualedit = 'onemore' },
+      }
+      local inner_no_go = vim._with(context_no_go, get_state)
+      local middle = get_state()
+      local context_with_go = {
+        o = { commentstring = '-- %s', virtualedit = 'all' },
+        bo = { commentstring = '!! %s' },
+        wo = { virtualedit = 'onemore' },
+        go = { commentstring = '@@ %s', virtualedit = 'block' },
+      }
+      local inner_with_go = vim._with(context_with_go, get_state)
+      return {
+        before = before,
+        inner_no_go = inner_no_go,
+        middle = middle,
+        inner_with_go = inner_with_go,
+        after = get_state(),
+      }
+    ]]
+
+    -- Should prefer explicit local scopes instead of `o`
+    eq({
+      bo = { cms = '!! %s' },
+      wo = { ve = 'onemore' },
+      go = { cms = '-- %s', ve = 'all' },
+    }, out.inner_no_go)
+    eq(out.before, out.middle)
+
+    -- Should prefer explicit global scopes instead of `o`
+    eq({
+      bo = { cms = '!! %s' },
+      wo = { ve = 'onemore' },
+      go = { cms = '@@ %s', ve = 'block' },
+    }, out.inner_with_go)
+    eq(out.middle, out.after)
+  end)
+
+  pending('can forward command modifiers to user command', function()
+    local out = exec_lua [[
+      local test_flags = {
+        'emsg_silent',
+        'hide',
+        'keepalt',
+        'keepjumps',
+        'keepmarks',
+        'keeppatterns',
+        'lockmarks',
+        'noautocmd',
+        'silent',
+        'unsilent',
+      }
+
+      local used_smods
+      local command = function(data)
+        used_smods = data.smods
+      end
+      api.nvim_create_user_command('DummyLog', command, {})
+
+      local res = {}
+      for _, flag in ipairs(test_flags) do
+        used_smods = nil
+        vim._with({ [flag] = true }, function() vim.cmd('DummyLog') end)
+        res[flag] = used_smods[flag]
+      end
+      return res
+    ]]
+    for k, v in pairs(out) do
+      eq({ k, true }, { k, v })
+    end
+  end)
+
+  it('handles error in callback', function()
+    -- Should still restore initial context
+    local out_buf = exec_lua [[
+      local other_buf, cur_buf = setup_buffers()
+      vim.bo[other_buf].commentstring = '## %s'
+
+      local context = { buf = other_buf, bo = { commentstring = '-- %s' } }
+      local ok, err = pcall(vim._with, context, function() error('Oops buf', 0) end)
+
+      return {
+        ok,
+        err,
+        api.nvim_get_current_buf() == cur_buf,
+        vim.bo[other_buf].commentstring,
+      }
+    ]]
+    eq({ false, 'Oops buf', true, '## %s' }, out_buf)
+
+    local out_win = exec_lua [[
+      local other_win, cur_win = setup_windows()
+      vim.wo[other_win].winblend = 25
+
+      local context = { win = other_win, wo = { winblend = 50 } }
+      local ok, err = pcall(vim._with, context, function() error('Oops win', 0) end)
+
+      return {
+        ok,
+        err,
+        api.nvim_get_current_win() == cur_win,
+        vim.wo[other_win].winblend,
+      }
+    ]]
+    eq({ false, 'Oops win', true, 25 }, out_win)
+  end)
+
+  it('handles not supported option', function()
+    local out = exec_lua [[
+      -- Should still restore initial state
+      vim.bo.commentstring = '## %s'
+
+      local context = { o = { commentstring = '-- %s' }, bo = { winblend = 10 } }
+      local ok, err = pcall(vim._with, context, function() end)
+
+      return { ok = ok, err = err, cms = vim.bo.commentstring }
+    ]]
+    eq(false, out.ok)
+    matches('window.*option.*winblend', out.err)
+    eq('## %s', out.cms)
+  end)
+
+  it('validates arguments', function()
+    exec_lua [[
+      _G.get_error = function(...)
+        local _, err = pcall(vim._with, ...)
+        return err or ''
+      end
+    ]]
+    local get_error = function(string_args)
+      return exec_lua('return get_error(' .. string_args .. ')')
+    end
+
+    matches('context.*table', get_error("'a', function() end"))
+    matches('f.*function', get_error('{}, 1'))
+
+    local assert_context = function(bad_context, expected_type)
+      local bad_field = vim.tbl_keys(bad_context)[1]
+      matches(
+        'context%.' .. bad_field .. '.*' .. expected_type,
+        get_error(vim.inspect(bad_context) .. ', function() end')
+      )
+    end
+
+    assert_context({ bo = 1 }, 'table')
+    assert_context({ buf = 'a' }, 'number')
+    assert_context({ emsg_silent = 1 }, 'boolean')
+    assert_context({ env = 1 }, 'table')
+    assert_context({ go = 1 }, 'table')
+    assert_context({ hide = 1 }, 'boolean')
+    assert_context({ keepalt = 1 }, 'boolean')
+    assert_context({ keepjumps = 1 }, 'boolean')
+    assert_context({ keepmarks = 1 }, 'boolean')
+    assert_context({ keeppatterns = 1 }, 'boolean')
+    assert_context({ lockmarks = 1 }, 'boolean')
+    assert_context({ noautocmd = 1 }, 'boolean')
+    assert_context({ o = 1 }, 'table')
+    assert_context({ sandbox = 1 }, 'boolean')
+    assert_context({ silent = 1 }, 'boolean')
+    assert_context({ unsilent = 1 }, 'boolean')
+    assert_context({ win = 'a' }, 'number')
+    assert_context({ wo = 1 }, 'table')
+
+    matches('Invalid buffer', get_error('{ buf = -1 }, function() end'))
+    matches('Invalid window', get_error('{ win = -1 }, function() end'))
+  end)
+end)
diff --git a/test/functional/lua/xdiff_spec.lua b/test/functional/lua/xdiff_spec.lua
index d5589c1f13..269dbde10a 100644
--- a/test/functional/lua/xdiff_spec.lua
+++ b/test/functional/lua/xdiff_spec.lua
@@ -12,15 +12,11 @@ describe('xdiff bindings', function()
   end)
 
   describe('can diff text', function()
-    before_each(function()
-      exec_lua [[
-        a1 = 'Hello\n'
-        b1 = 'Helli\n'
-
-        a2 = 'Hello\nbye\nfoo\n'
-        b2 = 'Helli\nbye\nbar\nbaz\n'
-      ]]
-    end)
+    local a1 = 'Hello\n'
+    local b1 = 'Helli\n'
+
+    local a2 = 'Hello\nbye\nfoo\n'
+    local b2 = 'Helli\nbye\nbar\nbaz\n'
 
     it('with no callback', function()
       eq(
@@ -30,7 +26,9 @@ describe('xdiff bindings', function()
           '+Helli',
           '',
         }, '\n'),
-        exec_lua('return vim.diff(a1, b1)')
+        exec_lua(function()
+          return vim.diff(a1, b1)
+        end)
       )
 
       eq(
@@ -44,63 +42,81 @@ describe('xdiff bindings', function()
           '+baz',
           '',
         }, '\n'),
-        exec_lua('return vim.diff(a2, b2)')
+        exec_lua(function()
+          return vim.diff(a2, b2)
+        end)
       )
     end)
 
     it('with callback', function()
-      exec_lua([[on_hunk = function(sa, ca, sb, cb)
-          exp[#exp+1] = {sa, ca, sb, cb}
-        end]])
-
       eq(
         { { 1, 1, 1, 1 } },
-        exec_lua [[
-          exp = {}
-          assert(vim.diff(a1, b1, {on_hunk = on_hunk}) == nil)
+        exec_lua(function()
+          local exp = {} --- @type table[]
+          assert(vim.diff(a1, b1, {
+            on_hunk = function(...)
+              exp[#exp + 1] = { ... }
+            end,
+          }) == nil)
           return exp
-        ]]
+        end)
       )
 
       eq(
         { { 1, 1, 1, 1 }, { 3, 1, 3, 2 } },
-        exec_lua [[
-          exp = {}
-          assert(vim.diff(a2, b2, {on_hunk = on_hunk}) == nil)
+        exec_lua(function()
+          local exp = {} --- @type table[]
+          assert(vim.diff(a2, b2, {
+            on_hunk = function(...)
+              exp[#exp + 1] = { ... }
+            end,
+          }) == nil)
           return exp
-        ]]
+        end)
       )
 
       -- gives higher precedence to on_hunk over result_type
       eq(
         { { 1, 1, 1, 1 }, { 3, 1, 3, 2 } },
-        exec_lua [[
-          exp = {}
-          assert(vim.diff(a2, b2, {on_hunk = on_hunk, result_type='indices'}) == nil)
+        exec_lua(function()
+          local exp = {} --- @type table[]
+          assert(vim.diff(a2, b2, {
+            on_hunk = function(...)
+              exp[#exp + 1] = { ... }
+            end,
+            result_type = 'indices',
+          }) == nil)
           return exp
-        ]]
+        end)
       )
     end)
 
     it('with error callback', function()
-      exec_lua [[
-        on_hunk = function(sa, ca, sb, cb)
-          error('ERROR1')
-        end
-      ]]
-
       eq(
-        [[error running function on_hunk: [string "<nvim>"]:0: ERROR1]],
-        pcall_err(exec_lua, [[vim.diff(a1, b1, {on_hunk = on_hunk})]])
+        [[.../xdiff_spec.lua:0: error running function on_hunk: .../xdiff_spec.lua:0: ERROR1]],
+        pcall_err(exec_lua, function()
+          vim.diff(a1, b1, {
+            on_hunk = function()
+              error('ERROR1')
+            end,
+          })
+        end)
       )
     end)
 
     it('with hunk_lines', function()
-      eq({ { 1, 1, 1, 1 } }, exec_lua([[return vim.diff(a1, b1, {result_type = 'indices'})]]))
+      eq(
+        { { 1, 1, 1, 1 } },
+        exec_lua(function()
+          return vim.diff(a1, b1, { result_type = 'indices' })
+        end)
+      )
 
       eq(
         { { 1, 1, 1, 1 }, { 3, 1, 3, 2 } },
-        exec_lua([[return vim.diff(a2, b2, {result_type = 'indices'})]])
+        exec_lua(function()
+          return vim.diff(a2, b2, { result_type = 'indices' })
+        end)
       )
     end)
 
@@ -143,16 +159,11 @@ describe('xdiff bindings', function()
           '+}',
           '',
         }, '\n'),
-        exec_lua(
-          [[
-          local args = {...}
-          return vim.diff(args[1], args[2], {
-            algorithm = 'patience'
+        exec_lua(function()
+          return vim.diff(a, b, {
+            algorithm = 'patience',
           })
-        ]],
-          a,
-          b
-        )
+        end)
       )
     end)
   end)
@@ -174,4 +185,13 @@ describe('xdiff bindings', function()
       pcall_err(exec_lua, [[vim.diff('a', 'b', { on_hunk = true })]])
     )
   end)
+
+  it('can handle strings with embedded NUL characters (GitHub #30305)', function()
+    eq(
+      { { 0, 0, 1, 1 }, { 1, 0, 3, 2 } },
+      exec_lua(function()
+        return vim.diff('\n', '\0\n\n\nb', { linematch = true, result_type = 'indices' })
+      end)
+    )
+  end)
 end)