local t = require('test.testutil')

local n = require('test.functional.testnvim')()

local Screen = require('test.functional.ui.screen')

local uv = vim.uv

local fmt = string.format

local dedent = t.dedent

local assert_alive = n.assert_alive

local NIL = vim.NIL

local clear, eq, neq = n.clear, t.eq, t.neq

local command = n.command

local command_output = n.api.nvim_command_output

local exec = n.exec

local exec_capture = n.exec_capture

local eval = n.eval

local expect = n.expect

local fn = n.fn

local api = n.api

local matches = t.matches

local pesc = vim.pesc

local mkdir_p = n.mkdir_p

local ok, nvim_async, feed = t.ok, n.nvim_async, n.feed

local async_meths = n.async_meths

local is_os = t.is_os

local parse_context = n.parse_context

local request = n.request

local rmdir = n.rmdir

local source = n.source

local next_msg = n.next_msg

local tmpname = t.tmpname

local write_file = t.write_file

local exec_lua = n.exec_lua

local exc_exec = n.exc_exec

local insert = n.insert

local skip = t.skip

local pcall_err = t.pcall_err

local format_string = require('test.format_string').format_string

local intchar2lua = t.intchar2lua

local mergedicts_copy = t.mergedicts_copy

local endswith = vim.endswith

describe('API', function()

before_each(clear)

it('validates requests', function()

-- RPC

matches('Invalid method: bogus$', pcall_err(request, 'bogus'))

matches('Invalid method: … の り 。…$', pcall_err(request, '… の り 。…'))

matches('Invalid method: <empty>$', pcall_err(request, ''))

-- Non-RPC: rpcrequest(v:servername) uses internal channel.

matches(

'Invalid method: … の り 。…$',

pcall_err(

request,

'nvim_eval',

[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=]

)

)

matches(

'Invalid method: bogus$',

pcall_err(

request,

'nvim_eval',

[=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=]

)

)

-- XXX: This must be the last one, else next one will fail:

-- "Packer instance already working. Use another Packer ..."

matches("can't serialize object of type .$", pcall_err(request, nil))

end)

it('handles errors in async requests', function()

local error_types = api.nvim_get_api_info()[2].error_types

nvim_async('bogus')

eq({

'notification',

'nvim_error_event',

{ error_types.Exception.id, 'Invalid method: bogus' },

}, next_msg())

-- error didn't close channel.

assert_alive()

end)

it('failed async request emits nvim_error_event', function()

local error_types = api.nvim_get_api_info()[2].error_types

async_meths.nvim_command('bogus')

eq({

'notification',

'nvim_error_event',

{ error_types.Exception.id, 'Vim:E492: Not an editor command: bogus' },

}, next_msg())

-- error didn't close channel.

assert_alive()

end)

it('input is processed first if followed immediately by non-fast events', function()

api.nvim_set_current_line('ab')

async_meths.nvim_input('x')

async_meths.nvim_exec_lua('_G.res1 = vim.api.nvim_get_current_line()', {})

async_meths.nvim_exec_lua('_G.res2 = vim.api.nvim_get_current_line()', {})

eq({ 'b', 'b' }, exec_lua('return { _G.res1, _G.res2 }'))

-- Also test with getchar()

async_meths.nvim_command('let g:getchar = 1 | call getchar() | let g:getchar = 0')

eq(1, api.nvim_get_var('getchar'))

async_meths.nvim_input('x')

async_meths.nvim_exec_lua('_G.res1 = vim.g.getchar', {})

async_meths.nvim_exec_lua('_G.res2 = vim.g.getchar', {})

eq({ 0, 0 }, exec_lua('return { _G.res1, _G.res2 }'))

end)

it('does not set CA_COMMAND_BUSY #7254', function()

command('split')

command('autocmd WinEnter * startinsert')

command('wincmd w')

eq({ mode = 'i', blocking = false }, api.nvim_get_mode())

end)

describe('nvim_exec2', function()

it('always returns table', function()

-- In built version this results into `vim.empty_dict()`

eq({}, api.nvim_exec2('echo "Hello"', {}))

eq({}, api.nvim_exec2('echo "Hello"', { output = false }))

eq({ output = 'Hello' }, api.nvim_exec2('echo "Hello"', { output = true }))

end)

it('default options', function()

-- Should be equivalent to { output = false }

api.nvim_exec2("let x0 = 'a'", {})

eq('a', api.nvim_get_var('x0'))

end)

it('one-line input', function()

api.nvim_exec2("let x1 = 'a'", { output = false })

eq('a', api.nvim_get_var('x1'))

end)

it(':verbose set {option}?', function()

api.nvim_exec2('set nowrap', { output = false })

eq(

{ output = 'nowrap\n\tLast set from anonymous :source line 1' },

api.nvim_exec2('verbose set wrap?', { output = true })

)

-- Using script var to force creation of a script item

api.nvim_exec2(

[[

let s:a = 1

set nowrap

]],

{ output = false }

)

eq(

{ output = 'nowrap\n\tLast set from anonymous :source (script id 1) line 2' },

api.nvim_exec2('verbose set wrap?', { output = true })

)

end)

it('multiline input', function()

-- Heredoc + empty lines.

api.nvim_exec2("let x2 = 'a'\n", { output = false })

eq('a', api.nvim_get_var('x2'))

api.nvim_exec2('lua <<EOF\n\n\n\ny=3\n\n\nEOF', { output = false })

eq(3, api.nvim_eval("luaeval('y')"))

eq({}, api.nvim_exec2('lua <<EOF\ny=3\nEOF', { output = false }))

eq(3, api.nvim_eval("luaeval('y')"))

-- Multiple statements

api.nvim_exec2('let x1=1\nlet x2=2\nlet x3=3\n', { output = false })

eq(1, api.nvim_eval('x1'))

eq(2, api.nvim_eval('x2'))

eq(3, api.nvim_eval('x3'))

-- Functions

api.nvim_exec2('function Foo()\ncall setline(1,["xxx"])\nendfunction', { output = false })

eq('', api.nvim_get_current_line())

api.nvim_exec2('call Foo()', { output = false })

eq('xxx', api.nvim_get_current_line())

-- Autocmds

api.nvim_exec2('autocmd BufAdd * :let x1 = "Hello"', { output = false })

command('new foo')

eq('Hello', request('nvim_eval', 'g:x1'))

-- Line continuations

api.nvim_exec2(

[[

let abc = #{

\ a: 1,

"\ b: 2,

\ c: 3

\ }]],

{ output = false }

)

eq({ a = 1, c = 3 }, request('nvim_eval', 'g:abc'))

-- try no spaces before continuations to catch off-by-one error

api.nvim_exec2('let ab = #{\n\\a: 98,\n"\\ b: 2\n\\}', { output = false })

eq({ a = 98 }, request('nvim_eval', 'g:ab'))

-- Script scope (s:)

eq(

{ output = 'ahoy! script-scoped varrrrr' },

api.nvim_exec2(

[[

let s:pirate = 'script-scoped varrrrr'

function! s:avast_ye_hades(s) abort

return a:s .. ' ' .. s:pirate

endfunction

echo <sid>avast_ye_hades('ahoy!')

]],

{ output = true }

)

)

eq(

{ output = "{'output': 'ahoy! script-scoped varrrrr'}" },

api.nvim_exec2(

[[

let s:pirate = 'script-scoped varrrrr'

function! Avast_ye_hades(s) abort

return a:s .. ' ' .. s:pirate

endfunction

echo nvim_exec2('echo Avast_ye_hades(''ahoy!'')', {'output': v:true})

]],

{ output = true }

)

)

matches(

'Vim%(echo%):E121: Undefined variable: s:pirate$',

pcall_err(

request,

'nvim_exec2',

[[

let s:pirate = 'script-scoped varrrrr'

call nvim_exec2('echo s:pirate', {'output': v:true})

]],

{ output = false }

)

)

-- Script items are created only on script var access

eq(

{ output = '1\n0' },

api.nvim_exec2(

[[

echo expand("<SID>")->empty()

let s:a = 123

echo expand("<SID>")->empty()

]],

{ output = true }

)

)

eq(

{ output = '1\n0' },

api.nvim_exec2(

[[

echo expand("<SID>")->empty()

function s:a() abort

endfunction

echo expand("<SID>")->empty()

]],

{ output = true }

)

)

end)

it('non-ASCII input', function()

api.nvim_exec2(

[=[

new

exe "normal! i ax \n Ax "

:%s/ax/--a1234--/g | :%s/Ax/--A1234--/g

]=],

{ output = false }

)

command('1')

eq(' --a1234-- ', api.nvim_get_current_line())

command('2')

eq(' --A1234-- ', api.nvim_get_current_line())

api.nvim_exec2(

[[

new

call setline(1,['xxx'])

call feedkeys('r')

call feedkeys('ñ', 'xt')

]],

{ output = false }

)

eq('ñxx', api.nvim_get_current_line())

end)

it('can use :finish', function()

api.nvim_exec2('let g:var = 123\nfinish\nlet g:var = 456', {})

eq(123, api.nvim_get_var('var'))

end)

it('execution error', function()

eq(

'nvim_exec2(), line 1: Vim:E492: Not an editor command: bogus_command',

pcall_err(request, 'nvim_exec2', 'bogus_command', {})

)

eq('', api.nvim_eval('v:errmsg')) -- v:errmsg was not updated.

eq('', eval('v:exception'))

eq(

'nvim_exec2(), line 1: Vim(buffer):E86: Buffer 23487 does not exist',

pcall_err(request, 'nvim_exec2', 'buffer 23487', {})

)

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

eq('', eval('v:exception'))

end)

it('recursion', function()

local fname = tmpname()

write_file(fname, 'let x1 = "set from :source file"\n')

-- nvim_exec2

-- :source

-- nvim_exec2

request('nvim_exec2', [[

let x2 = substitute('foo','o','X','g')

let x4 = 'should be overwritten'

call nvim_exec2("source ]] .. fname .. [[\nlet x3 = substitute('foo','foo','set by recursive nvim_exec2','g')\nlet x5='overwritten'\nlet x4=x5\n", {'output': v:false})

]], { output = false })

eq('set from :source file', request('nvim_get_var', 'x1'))

eq('fXX', request('nvim_get_var', 'x2'))

eq('set by recursive nvim_exec2', request('nvim_get_var', 'x3'))

eq('overwritten', request('nvim_get_var', 'x4'))

eq('overwritten', request('nvim_get_var', 'x5'))

os.remove(fname)

end)

it('traceback', function()

local fname = tmpname()

write_file(fname, 'echo "hello"\n')

local sourcing_fname = tmpname()

write_file(sourcing_fname, 'call nvim_exec2("source ' .. fname .. '", {"output": v:false})\n')

api.nvim_exec2('set verbose=2', { output = false })

local traceback_output = dedent([[

sourcing "nvim_exec2()"

line 1: sourcing "nvim_exec2() called at nvim_exec2():1"

line 1: sourcing "%s"

line 1: sourcing "nvim_exec2() called at %s:1"

line 1: sourcing "%s"

hello

finished sourcing %s

continuing in nvim_exec2() called at %s:1

finished sourcing nvim_exec2() called at %s:1

continuing in %s

finished sourcing %s

continuing in nvim_exec2() called at nvim_exec2():1

finished sourcing nvim_exec2() called at nvim_exec2():1

continuing in nvim_exec2()

finished sourcing nvim_exec2()]]):format(

sourcing_fname,

sourcing_fname,

fname,

fname,

sourcing_fname,

sourcing_fname,

sourcing_fname,

sourcing_fname

)

eq(

{ output = traceback_output },

api.nvim_exec2(

'call nvim_exec2("source ' .. sourcing_fname .. '", {"output": v:false})',

{ output = true }

)

)

os.remove(fname)

os.remove(sourcing_fname)

end)

it('returns output', function()

eq(

{ output = 'this is spinal tap' },

api.nvim_exec2('lua <<EOF\n\n\nprint("this is spinal tap")\n\n\nEOF', { output = true })

)

eq({ output = '' }, api.nvim_exec2('echo', { output = true }))

eq({ output = 'foo 42' }, api.nvim_exec2('echo "foo" 42', { output = true }))

end)

it('displays messages when opts.output=false', function()

local screen = Screen.new(40, 8)

api.nvim_exec2("echo 'hello'", { output = false })

screen:expect {

grid = [[

^ |

{1:~ }|*6

hello |

]],

}

end)

it("doesn't display messages when output=true", function()

local screen = Screen.new(40, 6)

api.nvim_exec2("echo 'hello'", { output = true })

screen:expect {

grid = [[

^ |

{1:~ }|*4

|

]],

}

exec([[

func Print()

call nvim_exec2('echo "hello"', { 'output': v:true })

endfunc

]])

feed([[:echon 1 | call Print() | echon 5<CR>]])

screen:expect {

grid = [[

^ |

{1:~ }|*4

15 |

]],

}

end)

it('errors properly when command too recursive', function()

exec_lua([[

_G.success = false

vim.api.nvim_create_user_command('Test', function()

vim.api.nvim_exec2('Test', {})

_G.success = true

end, {})

]])

pcall_err(command, 'Test')

assert_alive()

eq(false, exec_lua('return _G.success'))

end)

end)

describe('nvim_command', function()

it('works', function()

local fname = tmpname()

command('new')

command('edit ' .. fname)

command('normal itesting\napi')

command('w')

local f = assert(io.open(fname))

if is_os('win') then

eq('testing\r\napi\r\n', f:read('*a'))

else

eq('testing\napi\n', f:read('*a'))

end

f:close()

os.remove(fname)

end)

it('Vimscript validation error: fails with specific error', function()

local status, rv = pcall(command, 'bogus_command')

eq(false, status) -- nvim_command() failed.

eq('E492:', string.match(rv, 'E%d*:')) -- Vimscript error was returned.

eq('', api.nvim_eval('v:errmsg')) -- v:errmsg was not updated.

eq('', eval('v:exception'))

end)

it('Vimscript execution error: fails with specific error', function()

local status, rv = pcall(command, 'buffer 23487')

eq(false, status) -- nvim_command() failed.

eq('E86: Buffer 23487 does not exist', string.match(rv, 'E%d*:.*'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

eq('', eval('v:exception'))

end)

it('gives E493 instead of prompting on backwards range', function()

command('split')

eq(

'Vim(windo):E493: Backwards range given: 2,1windo echo',

pcall_err(command, '2,1windo echo')

)

end)

end)

describe('nvim_command_output', function()

it('does not induce hit-enter prompt', function()

api.nvim_ui_attach(80, 20, {})

-- Induce a hit-enter prompt use nvim_input (non-blocking).

command('set cmdheight=1')

api.nvim_input([[:echo "hi\nhi2"<CR>]])

-- Verify hit-enter prompt.

eq({ mode = 'r', blocking = true }, api.nvim_get_mode())

api.nvim_input([[<C-c>]])

-- Verify NO hit-enter prompt.

command_output([[echo "hi\nhi2"]])

eq({ mode = 'n', blocking = false }, api.nvim_get_mode())

end)

it('captures command output', function()

eq('this is\nspinal tap', command_output([[echo "this is\nspinal tap"]]))

eq('no line ending!', command_output([[echon "no line ending!"]]))

end)

it('captures empty command output', function()

eq('', command_output('echo'))

end)

it('captures single-char command output', function()

eq('x', command_output('echo "x"'))

end)

it('captures multiple commands', function()

eq('foo\n 1 %a "[No Name]" line 1', command_output('echo "foo" | ls'))

end)

it('captures nested execute()', function()

eq(

'\nnested1\nnested2\n 1 %a "[No Name]" line 1',

command_output([[echo execute('echo "nested1\nnested2"') | ls]])

)

end)

it('captures nested nvim_command_output()', function()

eq(

'nested1\nnested2\n 1 %a "[No Name]" line 1',

command_output([[echo nvim_command_output('echo "nested1\nnested2"') | ls]])

)

end)

it('returns shell |:!| output', function()

local win_lf = is_os('win') and '\r' or ''

eq(':!echo foo\r\n\nfoo' .. win_lf .. '\n', command_output([[!echo foo]]))

end)

it('Vimscript validation error: fails with specific error', function()

local status, rv = pcall(command_output, 'bogus commannnd')

eq(false, status) -- nvim_command_output() failed.

eq('E492: Not an editor command: bogus commannnd', string.match(rv, 'E%d*:.*'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

-- Verify NO hit-enter prompt.

eq({ mode = 'n', blocking = false }, api.nvim_get_mode())

end)

it('Vimscript execution error: fails with specific error', function()

local status, rv = pcall(command_output, 'buffer 42')

eq(false, status) -- nvim_command_output() failed.

eq('E86: Buffer 42 does not exist', string.match(rv, 'E%d*:.*'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

-- Verify NO hit-enter prompt.

eq({ mode = 'n', blocking = false }, api.nvim_get_mode())

end)

it('does not cause heap buffer overflow with large output', function()

eq(eval('string(range(1000000))'), command_output('echo range(1000000)'))

end)

end)

describe('nvim_eval', function()

it('works', function()

command('let g:v1 = "a"')

command('let g:v2 = [1, 2, {"v3": 3}]')

eq({ v1 = 'a', v2 = { 1, 2, { v3 = 3 } } }, api.nvim_eval('g:'))

end)

it('handles NULL-initialized strings correctly', function()

eq(1, api.nvim_eval("matcharg(1) == ['', '']"))

eq({ '', '' }, api.nvim_eval('matcharg(1)'))

end)

it('works under deprecated name', function()

eq(2, request('vim_eval', '1+1'))

end)

it('Vimscript error: returns error details, does NOT update v:errmsg', function()

eq('Vim:E121: Undefined variable: bogus', pcall_err(request, 'nvim_eval', 'bogus expression'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

end)

it('can return Lua function to Lua code', function()

eq(

[["a string with \"double quotes\" and 'single quotes'"]],

exec_lua([=[

local fun = vim.api.nvim_eval([[luaeval('string.format')]])

return fun('%q', [[a string with "double quotes" and 'single quotes']])

]=])

)

end)

end)

describe('nvim_call_function', function()

it('works', function()

api.nvim_call_function('setqflist', { { { filename = 'something', lnum = 17 } }, 'r' })

eq(17, api.nvim_call_function('getqflist', {})[1].lnum)

eq(17, api.nvim_call_function('eval', { 17 }))

eq('foo', api.nvim_call_function('simplify', { 'this/./is//redundant/../../../foo' }))

end)

it('Vimscript validation error: returns specific error, does NOT update v:errmsg', function()

eq(

'Vim:E117: Unknown function: bogus function',

pcall_err(request, 'nvim_call_function', 'bogus function', { 'arg1' })

)

eq(

'Vim:E119: Not enough arguments for function: atan',

pcall_err(request, 'nvim_call_function', 'atan', {})

)

eq('', eval('v:exception'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

end)

it('Vimscript error: returns error details, does NOT update v:errmsg', function()

eq(

'Vim:E808: Number or Float required',

pcall_err(request, 'nvim_call_function', 'atan', { 'foo' })

)

eq(

'Vim:Invalid channel stream "xxx"',

pcall_err(request, 'nvim_call_function', 'chanclose', { 999, 'xxx' })

)

eq(

'Vim:E900: Invalid channel id',

pcall_err(request, 'nvim_call_function', 'chansend', { 999, 'foo' })

)

eq('', eval('v:exception'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

end)

it('Vimscript exception: returns exception details, does NOT update v:errmsg', function()

source([[

function! Foo() abort

throw 'wtf'

endfunction

]])

eq('function Foo, line 1: wtf', pcall_err(request, 'nvim_call_function', 'Foo', {}))

eq('', eval('v:exception'))

eq('', eval('v:errmsg')) -- v:errmsg was not updated.

end)

it('validation', function()

-- stylua: ignore

local too_many_args = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' }

source([[

function! Foo(...) abort

echo a:000

endfunction

]])

-- E740

eq(

'Function called with too many arguments',

pcall_err(request, 'nvim_call_function', 'Foo', too_many_args)

)

end)

it('can return Lua function to Lua code', function()

eq(

[["a string with \"double quotes\" and 'single quotes'"]],

exec_lua([=[

local fun = vim.api.nvim_call_function('luaeval', { 'string.format' })

return fun('%q', [[a string with "double quotes" and 'single quotes']])

]=])

)

end)

end)

describe('nvim_call_dict_function', function()

it('invokes Vimscript dict function', function()

source([[

function! F(name) dict

return self.greeting.', '.a:name.'!'

endfunction

let g:test_dict_fn = { 'greeting':'Hello', 'F':function('F') }

let g:test_dict_fn2 = { 'greeting':'Hi' }

function g:test_dict_fn2.F2(name)

return self.greeting.', '.a:name.' ...'

endfunction

]])

-- :help Dictionary-function

eq('Hello, World!', api.nvim_call_dict_function('g:test_dict_fn', 'F', { 'World' }))

-- Funcref is sent as NIL over RPC.

eq({ greeting = 'Hello', F = NIL }, api.nvim_get_var('test_dict_fn'))

-- :help numbered-function

eq('Hi, Moon ...', api.nvim_call_dict_function('g:test_dict_fn2', 'F2', { 'Moon' }))

-- Funcref is sent as NIL over RPC.

eq({ greeting = 'Hi', F2 = NIL }, api.nvim_get_var('test_dict_fn2'))

-- Function specified via RPC dict.

source('function! G() dict\n return "@".(self.result)."@"\nendfunction')

eq('@it works@', api.nvim_call_dict_function({ result = 'it works', G = 'G' }, 'G', {}))

end)

it('validation', function()

command('let g:d={"baz":"zub","meep":[]}')

eq(

'Not found: bogus',

pcall_err(request, 'nvim_call_dict_function', 'g:d', 'bogus', { 1, 2 })

)

eq(

'Not a function: baz',

pcall_err(request, 'nvim_call_dict_function', 'g:d', 'baz', { 1, 2 })

)

eq(

'Not a function: meep',

pcall_err(request, 'nvim_call_dict_function', 'g:d', 'meep', { 1, 2 })

)

eq(

'Vim:E117: Unknown function: f',

pcall_err(request, 'nvim_call_dict_function', { f = '' }, 'f', { 1, 2 })

)

eq(

'Not a function: f',

pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", 'f', { 1, 2 })

)

eq(

'dict argument type must be String or Dict',

pcall_err(request, 'nvim_call_dict_function', 42, 'f', { 1, 2 })

)

eq(

'Vim:E121: Undefined variable: foo',

pcall_err(request, 'nvim_call_dict_function', 'foo', 'f', { 1, 2 })

)

eq('dict not found', pcall_err(request, 'nvim_call_dict_function', '42', 'f', { 1, 2 }))

eq(

'Invalid (empty) function name',

pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", '', { 1, 2 })

)

end)

end)

describe('nvim_set_current_dir', function()

local start_dir

before_each(function()

fn.mkdir('Xtestdir')

start_dir = fn.getcwd()

end)

after_each(function()

n.rmdir('Xtestdir')

end)

it('works', function()

api.nvim_set_current_dir('Xtestdir')

eq(start_dir .. n.get_pathsep() .. 'Xtestdir', fn.getcwd())

end)

it('sets previous directory', function()

api.nvim_set_current_dir('Xtestdir')

command('cd -')

eq(start_dir, fn.getcwd())

end)

end)

describe('nvim_exec_lua', function()

it('works', function()

api.nvim_exec_lua('vim.api.nvim_set_var("test", 3)', {})

eq(3, api.nvim_get_var('test'))

eq(17, api.nvim_exec_lua('a, b = ...\nreturn a + b', { 10, 7 }))

eq(NIL, api.nvim_exec_lua('function xx(a,b)\nreturn a..b\nend', {}))

eq('xy', api.nvim_exec_lua('return xx(...)', { 'x', 'y' }))

-- Deprecated name: nvim_execute_lua.

eq('xy', api.nvim_execute_lua('return xx(...)', { 'x', 'y' }))

end)

it('reports errors', function()

eq(

[[Error loading lua: [string "<nvim>"]:0: '=' expected near '+']],

pcall_err(api.nvim_exec_lua, 'a+*b', {})

)

eq(

[[Error loading lua: [string "<nvim>"]:0: unexpected symbol near '1']],

pcall_err(api.nvim_exec_lua, '1+2', {})

)

eq(

[[Error loading lua: [string "<nvim>"]:0: unexpected symbol]],

pcall_err(api.nvim_exec_lua, 'aa=bb\0', {})

)

eq(

[[attempt to call global 'bork' (a nil value)]],

pcall_err(api.nvim_exec_lua, 'bork()', {})

)

eq('did\nthe\nfail', pcall_err(api.nvim_exec_lua, 'error("did\\nthe\\nfail")', {}))

end)

it('uses native float values', function()

eq(2.5, api.nvim_exec_lua('return select(1, ...)', { 2.5 }))

eq('2.5', api.nvim_exec_lua('return vim.inspect(...)', { 2.5 }))

-- "special" float values are still accepted as return values.

eq(2.5, api.nvim_exec_lua("return vim.api.nvim_eval('2.5')", {}))

eq(

'{\n [false] = 2.5,\n [true] = 3\n}',

api.nvim_exec_lua("return vim.inspect(vim.api.nvim_eval('2.5'))", {})

)

end)

end)

describe('nvim_input', function()

it('Vimscript error: does NOT fail, updates v:errmsg', function()

local status, _ = pcall(api.nvim_input, ':call bogus_fn()<CR>')

local v_errnum = string.match(api.nvim_eval('v:errmsg'), 'E%d*:')

eq(true, status) -- nvim_input() did not fail.

eq('E117:', v_errnum) -- v:errmsg was updated.

end)

it('does not crash even if trans_special result is largest #11788, #12287', function()

command("call nvim_input('<M-'.nr2char(0x40000000).'>')")

eq(1, eval('1'))

end)

end)

describe('nvim_paste', function()

it('validation', function()

eq("Invalid 'phase': -2", pcall_err(request, 'nvim_paste', 'foo', true, -2))

eq("Invalid 'phase': 4", pcall_err(request, 'nvim_paste', 'foo', true, 4))

end)

local function run_streamed_paste_tests()