From b2d471ab337e56f660eb7c89ae24f447f7b7a165 Mon Sep 17 00:00:00 2001
From: Gregory Anders <8965202+gpanders@users.noreply.github.com>
Date: Thu, 7 Dec 2023 08:01:27 -0800
Subject: fix(lua): allow nil values in serialized Lua arrays (#26329)

When we convert a Lua table to an Object, we consider the table a
"dictionary" if it contains only string keys, and an array if it
contains all numeric indices with no gaps. While rare, Lua tables can
have both strictly numeric indices and gaps (e.g. { [2] = 2 }). These
currently cannot be serialized because it is not considered an array.

However, we know the maximum index of the table and as long as all of
the keys in the table are numeric, it is still possible to serialize
this table as an array. The missing indices will have nil values.
---
 test/functional/lua/api_spec.lua | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'test/functional/lua/api_spec.lua')

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index d808693a9e..8c03eb60ec 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -245,4 +245,8 @@ describe('luaeval(vim.api.…)', function()
     eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", 0, 1.5, "test")'))
     eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", true, {}, {[vim.type_idx]=vim.types.array})'))
   end)
+
+  it('serializes sparse arrays in Lua', function()
+    eq({ [1] = vim.NIL, [2] = 2 }, exec_lua [[ return { [2] = 2 } ]])
+  end)
 end)
-- 
cgit 


From 04f2f864e270e772c6326cefdf24947f0130e492 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Wed, 3 Jan 2024 02:09:18 +0100
Subject: refactor: format test/*

---
 test/functional/lua/api_spec.lua | 332 ++++++++++++++++++++++++++++-----------
 1 file changed, 240 insertions(+), 92 deletions(-)

(limited to 'test/functional/lua/api_spec.lua')

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index 8c03eb60ec..55f9ba7e13 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -17,50 +17,63 @@ describe('luaeval(vim.api.…)', function()
   describe('with channel_id and buffer handle', function()
     describe('nvim_buf_get_lines', function()
       it('works', function()
-        funcs.setline(1, {"abc", "def", "a\nb", "ttt"})
-        eq({'a\000b'},
-           funcs.luaeval('vim.api.nvim_buf_get_lines(1, 2, 3, false)'))
+        funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
+        eq({ 'a\000b' }, funcs.luaeval('vim.api.nvim_buf_get_lines(1, 2, 3, false)'))
       end)
     end)
     describe('nvim_buf_set_lines', function()
       it('works', function()
-        funcs.setline(1, {"abc", "def", "a\nb", "ttt"})
+        funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
         eq(NIL, funcs.luaeval('vim.api.nvim_buf_set_lines(1, 1, 2, false, {"b\\0a"})'))
-        eq({'abc', 'b\000a', 'a\000b', 'ttt'},
-           funcs.luaeval('vim.api.nvim_buf_get_lines(1, 0, 4, false)'))
+        eq(
+          { 'abc', 'b\000a', 'a\000b', 'ttt' },
+          funcs.luaeval('vim.api.nvim_buf_get_lines(1, 0, 4, false)')
+        )
       end)
     end)
   end)
   describe('with errors', function()
     it('transforms API error from nvim_buf_set_lines into lua error', function()
-      funcs.setline(1, {"abc", "def", "a\nb", "ttt"})
-      eq({false, "'replacement string' item contains newlines"},
-         funcs.luaeval('{pcall(vim.api.nvim_buf_set_lines, 1, 1, 2, false, {"b\\na"})}'))
+      funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
+      eq(
+        { false, "'replacement string' item contains newlines" },
+        funcs.luaeval('{pcall(vim.api.nvim_buf_set_lines, 1, 1, 2, false, {"b\\na"})}')
+      )
     end)
 
     it('transforms API error from nvim_win_set_cursor into lua error', function()
-      eq({false, 'Argument "pos" must be a [row, col] array'},
-         funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {1, 2, 3})}'))
+      eq(
+        { false, 'Argument "pos" must be a [row, col] array' },
+        funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {1, 2, 3})}')
+      )
       -- Used to produce a memory leak due to a bug in nvim_win_set_cursor
-      eq({false, 'Invalid window id: -1'},
-         funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, -1, {1, 2, 3})}'))
+      eq(
+        { false, 'Invalid window id: -1' },
+        funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, -1, {1, 2, 3})}')
+      )
     end)
 
-    it('transforms API error from nvim_win_set_cursor + same array as in first test into lua error',
-    function()
-      eq({false, 'Argument "pos" must be a [row, col] array'},
-         funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {"b\\na"})}'))
-    end)
+    it(
+      'transforms API error from nvim_win_set_cursor + same array as in first test into lua error',
+      function()
+        eq(
+          { false, 'Argument "pos" must be a [row, col] array' },
+          funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {"b\\na"})}')
+        )
+      end
+    )
   end)
 
   it('correctly evaluates API code which calls luaeval', function()
-    local str = (([===[vim.api.nvim_eval([==[
+    local str = (
+      ([===[vim.api.nvim_eval([==[
       luaeval('vim.api.nvim_eval([=[
         luaeval("vim.api.nvim_eval([[
           luaeval(1)
         ]])")
       ]=])')
-    ]==])]===]):gsub('\n', ' '))
+    ]==])]===]):gsub('\n', ' ')
+    )
     eq(1, funcs.luaeval(str))
   end)
 
@@ -86,28 +99,32 @@ describe('luaeval(vim.api.…)', function()
     eq(6, eval([[type(luaeval('vim.api.nvim_eval("v:false")'))]]))
     eq(7, eval([[type(luaeval('vim.api.nvim_eval("v:null")'))]]))
 
-    eq({foo=42}, funcs.luaeval([[vim.api.nvim_eval('{"foo": 42}')]]))
-    eq({42}, funcs.luaeval([[vim.api.nvim_eval('[42]')]]))
+    eq({ foo = 42 }, funcs.luaeval([[vim.api.nvim_eval('{"foo": 42}')]]))
+    eq({ 42 }, funcs.luaeval([[vim.api.nvim_eval('[42]')]]))
 
-    eq({foo={bar=42}, baz=50}, funcs.luaeval([[vim.api.nvim_eval('{"foo": {"bar": 42}, "baz": 50}')]]))
-    eq({{42}, {}}, funcs.luaeval([=[vim.api.nvim_eval('[[42], []]')]=]))
+    eq(
+      { foo = { bar = 42 }, baz = 50 },
+      funcs.luaeval([[vim.api.nvim_eval('{"foo": {"bar": 42}, "baz": 50}')]])
+    )
+    eq({ { 42 }, {} }, funcs.luaeval([=[vim.api.nvim_eval('[[42], []]')]=]))
   end)
 
   it('correctly converts to API objects', function()
     eq(1, funcs.luaeval('vim.api.nvim__id(1)'))
     eq('1', funcs.luaeval('vim.api.nvim__id("1")'))
-    eq({1}, funcs.luaeval('vim.api.nvim__id({1})'))
-    eq({foo=1}, funcs.luaeval('vim.api.nvim__id({foo=1})'))
+    eq({ 1 }, funcs.luaeval('vim.api.nvim__id({1})'))
+    eq({ foo = 1 }, funcs.luaeval('vim.api.nvim__id({foo=1})'))
     eq(1.5, funcs.luaeval('vim.api.nvim__id(1.5)'))
     eq(true, funcs.luaeval('vim.api.nvim__id(true)'))
     eq(false, funcs.luaeval('vim.api.nvim__id(false)'))
     eq(NIL, funcs.luaeval('vim.api.nvim__id(nil)'))
 
     -- API strings from Blobs can work as NUL-terminated C strings
-    eq('Vim(call):E5555: API call: Vim:E15: Invalid expression: ""',
-       exc_exec('call nvim_eval(v:_null_blob)'))
-    eq('Vim(call):E5555: API call: Vim:E15: Invalid expression: ""',
-       exc_exec('call nvim_eval(0z)'))
+    eq(
+      'Vim(call):E5555: API call: Vim:E15: Invalid expression: ""',
+      exc_exec('call nvim_eval(v:_null_blob)')
+    )
+    eq('Vim(call):E5555: API call: Vim:E15: Invalid expression: ""', exc_exec('call nvim_eval(0z)'))
     eq(1, eval('nvim_eval(0z31)'))
 
     eq(0, eval([[type(luaeval('vim.api.nvim__id(1)'))]]))
@@ -119,27 +136,56 @@ describe('luaeval(vim.api.…)', function()
     eq(6, eval([[type(luaeval('vim.api.nvim__id(false)'))]]))
     eq(7, eval([[type(luaeval('vim.api.nvim__id(nil)'))]]))
 
-    eq({foo=1, bar={42, {{baz=true}, 5}}}, funcs.luaeval('vim.api.nvim__id({foo=1, bar={42, {{baz=true}, 5}}})'))
+    eq(
+      { foo = 1, bar = { 42, { { baz = true }, 5 } } },
+      funcs.luaeval('vim.api.nvim__id({foo=1, bar={42, {{baz=true}, 5}}})')
+    )
 
     eq(true, funcs.luaeval('vim.api.nvim__id(vim.api.nvim__id)(true)'))
-    eq(42, exec_lua [[
+    eq(
+      42,
+      exec_lua [[
       local f = vim.api.nvim__id({42, vim.api.nvim__id})
       return f[2](f[1])
-    ]])
+    ]]
+    )
   end)
 
   it('correctly converts container objects with type_idx to API objects', function()
-    eq(5, eval('type(luaeval("vim.api.nvim__id({[vim.type_idx]=vim.types.float, [vim.val_idx]=0})"))'))
+    eq(
+      5,
+      eval('type(luaeval("vim.api.nvim__id({[vim.type_idx]=vim.types.float, [vim.val_idx]=0})"))')
+    )
     eq(4, eval([[type(luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.dictionary})'))]]))
     eq(3, eval([[type(luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array})'))]]))
 
     eq({}, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array})'))
 
     -- Presence of type_idx makes Vim ignore some keys
-    eq({42}, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'))
-    eq({foo=2}, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'))
-    eq(10, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'))
-    eq({}, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'))
+    eq(
+      { 42 },
+      funcs.luaeval(
+        'vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+      )
+    )
+    eq(
+      { foo = 2 },
+      funcs.luaeval(
+        'vim.api.nvim__id({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+      )
+    )
+    eq(
+      10,
+      funcs.luaeval(
+        'vim.api.nvim__id({[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+      )
+    )
+    eq(
+      {},
+      funcs.luaeval(
+        'vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'
+      )
+    )
   end)
 
   it('correctly converts arrays with type_idx to API objects', function()
@@ -147,24 +193,67 @@ describe('luaeval(vim.api.…)', function()
 
     eq({}, funcs.luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array})'))
 
-    eq({42}, funcs.luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'))
-    eq({{foo=2}}, funcs.luaeval('vim.api.nvim__id_array({{[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'))
-    eq({10}, funcs.luaeval('vim.api.nvim__id_array({{[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'))
-    eq({}, funcs.luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'))
+    eq(
+      { 42 },
+      funcs.luaeval(
+        'vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+      )
+    )
+    eq(
+      { { foo = 2 } },
+      funcs.luaeval(
+        'vim.api.nvim__id_array({{[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+      )
+    )
+    eq(
+      { 10 },
+      funcs.luaeval(
+        'vim.api.nvim__id_array({{[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+      )
+    )
+    eq(
+      {},
+      funcs.luaeval(
+        'vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'
+      )
+    )
 
     eq({}, funcs.luaeval('vim.api.nvim__id_array({})'))
     eq(3, eval([[type(luaeval('vim.api.nvim__id_array({})'))]]))
   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_dictionary({[vim.type_idx]=vim.types.dictionary})'))]])
+    )
 
     eq({}, funcs.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))
 
-    eq({v={42}}, funcs.luaeval('vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'))
-    eq({foo=2}, funcs.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'))
-    eq({v=10}, funcs.luaeval('vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'))
-    eq({v={}}, funcs.luaeval('vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2}})'))
+    eq(
+      { v = { 42 } },
+      funcs.luaeval(
+        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+      )
+    )
+    eq(
+      { foo = 2 },
+      funcs.luaeval(
+        'vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+      )
+    )
+    eq(
+      { v = 10 },
+      funcs.luaeval(
+        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+      )
+    )
+    eq(
+      { v = {} },
+      funcs.luaeval(
+        'vim.api.nvim__id_dictionary({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
     -- the case normally because empty table is an empty array.
@@ -173,14 +262,26 @@ describe('luaeval(vim.api.…)', function()
   end)
 
   it('converts booleans in positional args', function()
-    eq({''}, exec_lua [[ return vim.api.nvim_buf_get_lines(0, 0, 10, false) ]])
-    eq({''}, exec_lua [[ return vim.api.nvim_buf_get_lines(0, 0, 10, nil) ]])
-    eq('Index out of bounds', pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, true) ]]))
-    eq('Index out of bounds', pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, 1) ]]))
+    eq({ '' }, exec_lua [[ return vim.api.nvim_buf_get_lines(0, 0, 10, false) ]])
+    eq({ '' }, exec_lua [[ return vim.api.nvim_buf_get_lines(0, 0, 10, nil) ]])
+    eq(
+      'Index out of bounds',
+      pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, true) ]])
+    )
+    eq(
+      'Index out of bounds',
+      pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, 1) ]])
+    )
 
     -- this follows lua conventions for bools (not api convention for Boolean)
-    eq('Index out of bounds', pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, 0) ]]))
-    eq('Index out of bounds', pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, {}) ]]))
+    eq(
+      'Index out of bounds',
+      pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, 0) ]])
+    )
+    eq(
+      'Index out of bounds',
+      pcall_err(exec_lua, [[ return vim.api.nvim_buf_get_lines(0, 0, 10, {}) ]])
+    )
   end)
 
   it('converts booleans in optional args', function()
@@ -190,50 +291,92 @@ describe('luaeval(vim.api.…)', function()
     -- API conventions (not lua conventions): zero is falsy
     eq({}, exec_lua [[ return vim.api.nvim_exec2("echo 'foobar'", {output=0}) ]])
 
-    eq({output='foobar'}, exec_lua [[ return vim.api.nvim_exec2("echo 'foobar'", {output=true}) ]])
-    eq({output='foobar'}, exec_lua [[ return vim.api.nvim_exec2("echo 'foobar'", {output=1}) ]])
-    eq([[Invalid 'output': not a boolean]], pcall_err(exec_lua, [[ return vim.api.nvim_exec2("echo 'foobar'", {output={}}) ]]))
+    eq(
+      { output = 'foobar' },
+      exec_lua [[ return vim.api.nvim_exec2("echo 'foobar'", {output=true}) ]]
+    )
+    eq({ output = 'foobar' }, exec_lua [[ return vim.api.nvim_exec2("echo 'foobar'", {output=1}) ]])
+    eq(
+      [[Invalid 'output': not a boolean]],
+      pcall_err(exec_lua, [[ return vim.api.nvim_exec2("echo 'foobar'", {output={}}) ]])
+    )
   end)
 
   it('errors out correctly when working with API', function()
     -- Conversion errors
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'obj': Cannot convert given Lua table]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id({1, foo=42})")]])))
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'obj': Cannot convert given Lua table]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id({1, foo=42})")]]))
+    )
     -- Errors in number of arguments
-    eq('Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 1 argument',
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id()")]])))
-    eq('Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 1 argument',
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id(1, 2)")]])))
-    eq('Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 2 arguments',
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_var(1, 2, 3)")]])))
+    eq(
+      'Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 1 argument',
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id()")]]))
+    )
+    eq(
+      'Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 1 argument',
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id(1, 2)")]]))
+    )
+    eq(
+      'Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected 2 arguments',
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_var(1, 2, 3)")]]))
+    )
     -- Error in argument types
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'name': Expected Lua string]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_var(1, 2)")]])))
-
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'start': Expected Lua number]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_buf_get_lines(0, 'test', 1, false)")]])))
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'start': Number is not integral]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_buf_get_lines(0, 1.5, 1, false)")]])))
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'window': Expected Lua number]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_win_is_valid(nil)")]])))
-
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'flt': Expected Lua number]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_float('test')")]])))
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'flt': Expected Float-like Lua table]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_float({[vim.type_idx]=vim.types.dictionary})")]])))
-
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'arr': Expected Lua table]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_array(1)")]])))
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'arr': Expected Array-like Lua table]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_array({[vim.type_idx]=vim.types.dictionary})")]])))
-
-    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)")]])))
-    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})")]])))
-
-    eq([[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected Lua table]],
-       remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_keymap('', '', '', '')")]])))
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'name': Expected Lua string]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_var(1, 2)")]]))
+    )
+
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'start': Expected Lua number]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_buf_get_lines(0, 'test', 1, false)")]]))
+    )
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'start': Number is not integral]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_buf_get_lines(0, 1.5, 1, false)")]]))
+    )
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'window': Expected Lua number]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_win_is_valid(nil)")]]))
+    )
+
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'flt': Expected Lua number]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_float('test')")]]))
+    )
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'flt': Expected Float-like Lua table]],
+      remove_trace(
+        exc_exec([[call luaeval("vim.api.nvim__id_float({[vim.type_idx]=vim.types.dictionary})")]])
+      )
+    )
+
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'arr': Expected Lua table]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_array(1)")]]))
+    )
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'arr': Expected Array-like Lua table]],
+      remove_trace(
+        exc_exec([[call luaeval("vim.api.nvim__id_array({[vim.type_idx]=vim.types.dictionary})")]])
+      )
+    )
+
+    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)")]]))
+    )
+    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})")]])
+      )
+    )
+
+    eq(
+      [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Expected Lua table]],
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim_set_keymap('', '', '', '')")]]))
+    )
 
     -- TODO: check for errors with Tabpage argument
     -- TODO: check for errors with Window argument
@@ -243,7 +386,12 @@ describe('luaeval(vim.api.…)', function()
   it('accepts any value as API Boolean', function()
     eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", vim, false, nil)'))
     eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", 0, 1.5, "test")'))
-    eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", true, {}, {[vim.type_idx]=vim.types.array})'))
+    eq(
+      '',
+      funcs.luaeval(
+        'vim.api.nvim_replace_termcodes("", true, {}, {[vim.type_idx]=vim.types.array})'
+      )
+    )
   end)
 
   it('serializes sparse arrays in Lua', function()
-- 
cgit 


From d33e1da9b7f7e886219cfdd20b9bbfaccdc43be9 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 12 Jan 2024 11:28:20 +0000
Subject: test: do not inject vim module into global helpers

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

(limited to 'test/functional/lua/api_spec.lua')

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index 55f9ba7e13..d10802440f 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -6,7 +6,7 @@ local remove_trace = helpers.remove_trace
 local funcs = helpers.funcs
 local clear = helpers.clear
 local eval = helpers.eval
-local NIL = helpers.NIL
+local NIL = vim.NIL
 local eq = helpers.eq
 local exec_lua = helpers.exec_lua
 local pcall_err = helpers.pcall_err
-- 
cgit 


From 795f896a5772d5e0795f86642bdf90c82efac45c Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 12 Jan 2024 17:59:57 +0000
Subject: test: rename (meths, funcs) -> (api, fn)

---
 test/functional/lua/api_spec.lua | 114 +++++++++++++++++++--------------------
 1 file changed, 56 insertions(+), 58 deletions(-)

(limited to 'test/functional/lua/api_spec.lua')

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index d10802440f..acd56a0ddb 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -3,7 +3,7 @@ local helpers = require('test.functional.helpers')(after_each)
 
 local exc_exec = helpers.exc_exec
 local remove_trace = helpers.remove_trace
-local funcs = helpers.funcs
+local fn = helpers.fn
 local clear = helpers.clear
 local eval = helpers.eval
 local NIL = vim.NIL
@@ -17,39 +17,39 @@ describe('luaeval(vim.api.…)', function()
   describe('with channel_id and buffer handle', function()
     describe('nvim_buf_get_lines', function()
       it('works', function()
-        funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
-        eq({ 'a\000b' }, funcs.luaeval('vim.api.nvim_buf_get_lines(1, 2, 3, false)'))
+        fn.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
+        eq({ 'a\000b' }, fn.luaeval('vim.api.nvim_buf_get_lines(1, 2, 3, false)'))
       end)
     end)
     describe('nvim_buf_set_lines', function()
       it('works', function()
-        funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
-        eq(NIL, funcs.luaeval('vim.api.nvim_buf_set_lines(1, 1, 2, false, {"b\\0a"})'))
+        fn.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
+        eq(NIL, fn.luaeval('vim.api.nvim_buf_set_lines(1, 1, 2, false, {"b\\0a"})'))
         eq(
           { 'abc', 'b\000a', 'a\000b', 'ttt' },
-          funcs.luaeval('vim.api.nvim_buf_get_lines(1, 0, 4, false)')
+          fn.luaeval('vim.api.nvim_buf_get_lines(1, 0, 4, false)')
         )
       end)
     end)
   end)
   describe('with errors', function()
     it('transforms API error from nvim_buf_set_lines into lua error', function()
-      funcs.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
+      fn.setline(1, { 'abc', 'def', 'a\nb', 'ttt' })
       eq(
         { false, "'replacement string' item contains newlines" },
-        funcs.luaeval('{pcall(vim.api.nvim_buf_set_lines, 1, 1, 2, false, {"b\\na"})}')
+        fn.luaeval('{pcall(vim.api.nvim_buf_set_lines, 1, 1, 2, false, {"b\\na"})}')
       )
     end)
 
     it('transforms API error from nvim_win_set_cursor into lua error', function()
       eq(
         { false, 'Argument "pos" must be a [row, col] array' },
-        funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {1, 2, 3})}')
+        fn.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {1, 2, 3})}')
       )
       -- Used to produce a memory leak due to a bug in nvim_win_set_cursor
       eq(
         { false, 'Invalid window id: -1' },
-        funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, -1, {1, 2, 3})}')
+        fn.luaeval('{pcall(vim.api.nvim_win_set_cursor, -1, {1, 2, 3})}')
       )
     end)
 
@@ -58,7 +58,7 @@ describe('luaeval(vim.api.…)', function()
       function()
         eq(
           { false, 'Argument "pos" must be a [row, col] array' },
-          funcs.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {"b\\na"})}')
+          fn.luaeval('{pcall(vim.api.nvim_win_set_cursor, 0, {"b\\na"})}')
         )
       end
     )
@@ -74,20 +74,20 @@ describe('luaeval(vim.api.…)', function()
       ]=])')
     ]==])]===]):gsub('\n', ' ')
     )
-    eq(1, funcs.luaeval(str))
+    eq(1, fn.luaeval(str))
   end)
 
   it('correctly converts from API objects', function()
-    eq(1, funcs.luaeval('vim.api.nvim_eval("1")'))
-    eq('1', funcs.luaeval([[vim.api.nvim_eval('"1"')]]))
-    eq('Blobby', funcs.luaeval('vim.api.nvim_eval("0z426c6f626279")'))
-    eq({}, funcs.luaeval('vim.api.nvim_eval("[]")'))
-    eq({}, funcs.luaeval('vim.api.nvim_eval("{}")'))
-    eq(1, funcs.luaeval('vim.api.nvim_eval("1.0")'))
-    eq('\000', funcs.luaeval('vim.api.nvim_eval("0z00")'))
-    eq(true, funcs.luaeval('vim.api.nvim_eval("v:true")'))
-    eq(false, funcs.luaeval('vim.api.nvim_eval("v:false")'))
-    eq(NIL, funcs.luaeval('vim.api.nvim_eval("v:null")'))
+    eq(1, fn.luaeval('vim.api.nvim_eval("1")'))
+    eq('1', fn.luaeval([[vim.api.nvim_eval('"1"')]]))
+    eq('Blobby', fn.luaeval('vim.api.nvim_eval("0z426c6f626279")'))
+    eq({}, fn.luaeval('vim.api.nvim_eval("[]")'))
+    eq({}, fn.luaeval('vim.api.nvim_eval("{}")'))
+    eq(1, fn.luaeval('vim.api.nvim_eval("1.0")'))
+    eq('\000', fn.luaeval('vim.api.nvim_eval("0z00")'))
+    eq(true, fn.luaeval('vim.api.nvim_eval("v:true")'))
+    eq(false, fn.luaeval('vim.api.nvim_eval("v:false")'))
+    eq(NIL, fn.luaeval('vim.api.nvim_eval("v:null")'))
 
     eq(0, eval([[type(luaeval('vim.api.nvim_eval("1")'))]]))
     eq(1, eval([[type(luaeval('vim.api.nvim_eval("''1''")'))]]))
@@ -99,25 +99,25 @@ describe('luaeval(vim.api.…)', function()
     eq(6, eval([[type(luaeval('vim.api.nvim_eval("v:false")'))]]))
     eq(7, eval([[type(luaeval('vim.api.nvim_eval("v:null")'))]]))
 
-    eq({ foo = 42 }, funcs.luaeval([[vim.api.nvim_eval('{"foo": 42}')]]))
-    eq({ 42 }, funcs.luaeval([[vim.api.nvim_eval('[42]')]]))
+    eq({ foo = 42 }, fn.luaeval([[vim.api.nvim_eval('{"foo": 42}')]]))
+    eq({ 42 }, fn.luaeval([[vim.api.nvim_eval('[42]')]]))
 
     eq(
       { foo = { bar = 42 }, baz = 50 },
-      funcs.luaeval([[vim.api.nvim_eval('{"foo": {"bar": 42}, "baz": 50}')]])
+      fn.luaeval([[vim.api.nvim_eval('{"foo": {"bar": 42}, "baz": 50}')]])
     )
-    eq({ { 42 }, {} }, funcs.luaeval([=[vim.api.nvim_eval('[[42], []]')]=]))
+    eq({ { 42 }, {} }, fn.luaeval([=[vim.api.nvim_eval('[[42], []]')]=]))
   end)
 
   it('correctly converts to API objects', function()
-    eq(1, funcs.luaeval('vim.api.nvim__id(1)'))
-    eq('1', funcs.luaeval('vim.api.nvim__id("1")'))
-    eq({ 1 }, funcs.luaeval('vim.api.nvim__id({1})'))
-    eq({ foo = 1 }, funcs.luaeval('vim.api.nvim__id({foo=1})'))
-    eq(1.5, funcs.luaeval('vim.api.nvim__id(1.5)'))
-    eq(true, funcs.luaeval('vim.api.nvim__id(true)'))
-    eq(false, funcs.luaeval('vim.api.nvim__id(false)'))
-    eq(NIL, funcs.luaeval('vim.api.nvim__id(nil)'))
+    eq(1, fn.luaeval('vim.api.nvim__id(1)'))
+    eq('1', fn.luaeval('vim.api.nvim__id("1")'))
+    eq({ 1 }, fn.luaeval('vim.api.nvim__id({1})'))
+    eq({ foo = 1 }, fn.luaeval('vim.api.nvim__id({foo=1})'))
+    eq(1.5, fn.luaeval('vim.api.nvim__id(1.5)'))
+    eq(true, fn.luaeval('vim.api.nvim__id(true)'))
+    eq(false, fn.luaeval('vim.api.nvim__id(false)'))
+    eq(NIL, fn.luaeval('vim.api.nvim__id(nil)'))
 
     -- API strings from Blobs can work as NUL-terminated C strings
     eq(
@@ -138,10 +138,10 @@ describe('luaeval(vim.api.…)', function()
 
     eq(
       { foo = 1, bar = { 42, { { baz = true }, 5 } } },
-      funcs.luaeval('vim.api.nvim__id({foo=1, bar={42, {{baz=true}, 5}}})')
+      fn.luaeval('vim.api.nvim__id({foo=1, bar={42, {{baz=true}, 5}}})')
     )
 
-    eq(true, funcs.luaeval('vim.api.nvim__id(vim.api.nvim__id)(true)'))
+    eq(true, fn.luaeval('vim.api.nvim__id(vim.api.nvim__id)(true)'))
     eq(
       42,
       exec_lua [[
@@ -159,30 +159,30 @@ describe('luaeval(vim.api.…)', function()
     eq(4, eval([[type(luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.dictionary})'))]]))
     eq(3, eval([[type(luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array})'))]]))
 
-    eq({}, funcs.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array})'))
+    eq({}, fn.luaeval('vim.api.nvim__id({[vim.type_idx]=vim.types.array})'))
 
     -- Presence of type_idx makes Vim ignore some keys
     eq(
       { 42 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       { foo = 2 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       10,
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id({[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       {},
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'
       )
     )
@@ -191,34 +191,34 @@ describe('luaeval(vim.api.…)', function()
   it('correctly converts arrays with type_idx to API objects', function()
     eq(3, eval([[type(luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array})'))]]))
 
-    eq({}, funcs.luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_array({[vim.type_idx]=vim.types.array})'))
 
     eq(
       { 42 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       { { foo = 2 } },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_array({{[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { 10 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_array({{[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       {},
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_array({[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2})'
       )
     )
 
-    eq({}, funcs.luaeval('vim.api.nvim__id_array({})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_array({})'))
     eq(3, eval([[type(luaeval('vim.api.nvim__id_array({})'))]]))
   end)
 
@@ -228,36 +228,36 @@ describe('luaeval(vim.api.…)', function()
       eval([[type(luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))]])
     )
 
-    eq({}, funcs.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))
 
     eq(
       { v = { 42 } },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { foo = 2 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       { v = 10 },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { v = {} },
-      funcs.luaeval(
+      fn.luaeval(
         'vim.api.nvim__id_dictionary({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
     -- the case normally because empty table is an empty array.
-    eq({}, funcs.luaeval('vim.api.nvim__id_dictionary({})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({})'))
     eq(4, eval([[type(luaeval('vim.api.nvim__id_dictionary({})'))]]))
   end)
 
@@ -384,13 +384,11 @@ describe('luaeval(vim.api.…)', function()
   end)
 
   it('accepts any value as API Boolean', function()
-    eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", vim, false, nil)'))
-    eq('', funcs.luaeval('vim.api.nvim_replace_termcodes("", 0, 1.5, "test")'))
+    eq('', fn.luaeval('vim.api.nvim_replace_termcodes("", vim, false, nil)'))
+    eq('', fn.luaeval('vim.api.nvim_replace_termcodes("", 0, 1.5, "test")'))
     eq(
       '',
-      funcs.luaeval(
-        'vim.api.nvim_replace_termcodes("", true, {}, {[vim.type_idx]=vim.types.array})'
-      )
+      fn.luaeval('vim.api.nvim_replace_termcodes("", true, {}, {[vim.type_idx]=vim.types.array})')
     )
   end)
 
-- 
cgit