mirror of
https://github.com/neovim/neovim.git
synced 2024-09-17 20:58:20 -04:00
refactor(lua): "module" => "M" #28426
Most of the codebase uses the `M` convention for Lua module. Update the last remaining cases.
This commit is contained in:
parent
f190f758ac
commit
8886b1807c
@ -1,6 +1,6 @@
|
||||
local bit = require 'bit'
|
||||
|
||||
local module = {}
|
||||
local M = {}
|
||||
|
||||
-- Description of the values below is contained in ex_cmds_defs.h file.
|
||||
-- "EX_" prefix is omitted.
|
||||
@ -32,14 +32,14 @@ local FILES = bit.bor(XFILE, EXTRA)
|
||||
local WORD1 = bit.bor(EXTRA, NOSPC)
|
||||
local FILE1 = bit.bor(FILES, NOSPC)
|
||||
|
||||
module.flags = {
|
||||
M.flags = {
|
||||
RANGE = RANGE,
|
||||
DFLALL = DFLALL,
|
||||
PREVIEW = PREVIEW,
|
||||
}
|
||||
|
||||
-- The following table is described in ex_cmds_defs.h file.
|
||||
module.cmds = {
|
||||
M.cmds = {
|
||||
{
|
||||
command = 'append',
|
||||
flags = bit.bor(BANG, RANGE, ZEROR, TRLBAR, CMDWIN, LOCK_OK, MODIFY),
|
||||
@ -3359,4 +3359,4 @@ module.cmds = {
|
||||
},
|
||||
}
|
||||
|
||||
return module
|
||||
return M
|
||||
|
@ -1,22 +1,22 @@
|
||||
local module = {}
|
||||
local M = {}
|
||||
|
||||
module.include_paths = {}
|
||||
M.include_paths = {}
|
||||
for p in ("${TEST_INCLUDE_DIRS}" .. ";"):gmatch("[^;]+") do
|
||||
table.insert(module.include_paths, p)
|
||||
table.insert(M.include_paths, p)
|
||||
end
|
||||
|
||||
module.test_build_dir = "${CMAKE_BINARY_DIR}"
|
||||
module.test_source_path = "${CMAKE_SOURCE_DIR}"
|
||||
module.test_lua_prg = "${LUA_PRG}"
|
||||
module.test_luajit_prg = ""
|
||||
if module.test_luajit_prg == '' then
|
||||
if module.test_lua_prg:sub(-6) == 'luajit' then
|
||||
module.test_luajit_prg = module.test_lua_prg
|
||||
M.test_build_dir = "${CMAKE_BINARY_DIR}"
|
||||
M.test_source_path = "${CMAKE_SOURCE_DIR}"
|
||||
M.test_lua_prg = "${LUA_PRG}"
|
||||
M.test_luajit_prg = ""
|
||||
if M.test_luajit_prg == '' then
|
||||
if M.test_lua_prg:sub(-6) == 'luajit' then
|
||||
M.test_luajit_prg = M.test_lua_prg
|
||||
else
|
||||
module.test_luajit_prg = nil
|
||||
M.test_luajit_prg = nil
|
||||
end
|
||||
end
|
||||
table.insert(module.include_paths, "${CMAKE_BINARY_DIR}/include")
|
||||
table.insert(module.include_paths, "${CMAKE_BINARY_DIR}/src/nvim/auto")
|
||||
table.insert(M.include_paths, "${CMAKE_BINARY_DIR}/include")
|
||||
table.insert(M.include_paths, "${CMAKE_BINARY_DIR}/src/nvim/auto")
|
||||
|
||||
return module
|
||||
return M
|
||||
|
@ -16,18 +16,18 @@ local sleep = uv.sleep
|
||||
local fail = t_global.fail
|
||||
|
||||
--- @class test.functional.testutil: test.testutil
|
||||
local module = vim.deepcopy(t_global)
|
||||
local M = vim.deepcopy(t_global)
|
||||
|
||||
local runtime_set = 'set runtimepath^=./build/lib/nvim/'
|
||||
module.nvim_prog = (os.getenv('NVIM_PRG') or t_global.paths.test_build_dir .. '/bin/nvim')
|
||||
M.nvim_prog = (os.getenv('NVIM_PRG') or t_global.paths.test_build_dir .. '/bin/nvim')
|
||||
-- Default settings for the test session.
|
||||
module.nvim_set = (
|
||||
M.nvim_set = (
|
||||
'set shortmess+=IS background=light termguicolors noswapfile noautoindent startofline'
|
||||
.. ' laststatus=1 undodir=. directory=. viewdir=. backupdir=.'
|
||||
.. ' belloff= wildoptions-=pum joinspaces noshowcmd noruler nomore redrawdebug=invalid'
|
||||
)
|
||||
module.nvim_argv = {
|
||||
module.nvim_prog,
|
||||
M.nvim_argv = {
|
||||
M.nvim_prog,
|
||||
'-u',
|
||||
'NONE',
|
||||
'-i',
|
||||
@ -36,7 +36,7 @@ module.nvim_argv = {
|
||||
'--cmd',
|
||||
runtime_set,
|
||||
'--cmd',
|
||||
module.nvim_set,
|
||||
M.nvim_set,
|
||||
-- Remove default user commands and mappings.
|
||||
'--cmd',
|
||||
'comclear | mapclear | mapclear!',
|
||||
@ -51,9 +51,9 @@ module.nvim_argv = {
|
||||
}
|
||||
|
||||
-- Directory containing nvim.
|
||||
module.nvim_dir = module.nvim_prog:gsub('[/\\][^/\\]+$', '')
|
||||
if module.nvim_dir == module.nvim_prog then
|
||||
module.nvim_dir = '.'
|
||||
M.nvim_dir = M.nvim_prog:gsub('[/\\][^/\\]+$', '')
|
||||
if M.nvim_dir == M.nvim_prog then
|
||||
M.nvim_dir = '.'
|
||||
end
|
||||
|
||||
local prepend_argv --- @type string[]?
|
||||
@ -85,11 +85,11 @@ if prepend_argv then
|
||||
for i = 1, len do
|
||||
new_nvim_argv[i] = prepend_argv[i]
|
||||
end
|
||||
for i = 1, #module.nvim_argv do
|
||||
new_nvim_argv[i + len] = module.nvim_argv[i]
|
||||
for i = 1, #M.nvim_argv do
|
||||
new_nvim_argv[i + len] = M.nvim_argv[i]
|
||||
end
|
||||
module.nvim_argv = new_nvim_argv
|
||||
module.prepend_argv = prepend_argv
|
||||
M.nvim_argv = new_nvim_argv
|
||||
M.prepend_argv = prepend_argv
|
||||
end
|
||||
|
||||
local session --- @type test.Session?
|
||||
@ -104,18 +104,18 @@ if not is_os('win') then
|
||||
end)
|
||||
end
|
||||
|
||||
function module.get_session()
|
||||
function M.get_session()
|
||||
return session
|
||||
end
|
||||
|
||||
function module.set_session(s)
|
||||
function M.set_session(s)
|
||||
session = s
|
||||
end
|
||||
|
||||
--- @param method string
|
||||
--- @param ... any
|
||||
--- @return any
|
||||
function module.request(method, ...)
|
||||
function M.request(method, ...)
|
||||
assert(session)
|
||||
local status, rv = session:request(method, ...)
|
||||
if not status then
|
||||
@ -133,21 +133,21 @@ end
|
||||
--- @param method string
|
||||
--- @param ... any
|
||||
--- @return any
|
||||
function module.request_lua(method, ...)
|
||||
return module.exec_lua([[return vim.api[...](select(2, ...))]], method, ...)
|
||||
function M.request_lua(method, ...)
|
||||
return M.exec_lua([[return vim.api[...](select(2, ...))]], method, ...)
|
||||
end
|
||||
|
||||
--- @param timeout? integer
|
||||
--- @return string?
|
||||
function module.next_msg(timeout)
|
||||
function M.next_msg(timeout)
|
||||
assert(session)
|
||||
return session:next_message(timeout or 10000)
|
||||
end
|
||||
|
||||
function module.expect_twostreams(msgs1, msgs2)
|
||||
function M.expect_twostreams(msgs1, msgs2)
|
||||
local pos1, pos2 = 1, 1
|
||||
while pos1 <= #msgs1 or pos2 <= #msgs2 do
|
||||
local msg = module.next_msg()
|
||||
local msg = M.next_msg()
|
||||
if pos1 <= #msgs1 and pcall(eq, msgs1[pos1], msg) then
|
||||
pos1 = pos1 + 1
|
||||
elseif pos2 <= #msgs2 then
|
||||
@ -170,7 +170,7 @@ end
|
||||
--
|
||||
-- ignore: List of ignored event names.
|
||||
-- seqs: List of one or more potential event sequences.
|
||||
function module.expect_msg_seq(...)
|
||||
function M.expect_msg_seq(...)
|
||||
if select('#', ...) < 1 then
|
||||
error('need at least 1 argument')
|
||||
end
|
||||
@ -197,12 +197,12 @@ function module.expect_msg_seq(...)
|
||||
end
|
||||
return string.format('%s\n%s\n%s', err1, string.rep('=', 78), err2)
|
||||
end
|
||||
local msg_timeout = module.load_adjust(10000) -- Big timeout for ASAN/valgrind.
|
||||
local msg_timeout = M.load_adjust(10000) -- Big timeout for ASAN/valgrind.
|
||||
for anum = 1, #seqs do
|
||||
local expected_seq = seqs[anum]
|
||||
-- Collect enough messages to compare the next expected sequence.
|
||||
while #actual_seq < #expected_seq do
|
||||
local msg = module.next_msg(msg_timeout)
|
||||
local msg = M.next_msg(msg_timeout)
|
||||
local msg_type = msg and msg[2] or nil
|
||||
if msg == nil then
|
||||
error(
|
||||
@ -247,7 +247,7 @@ local function call_and_stop_on_error(lsession, ...)
|
||||
return result
|
||||
end
|
||||
|
||||
function module.set_method_error(err)
|
||||
function M.set_method_error(err)
|
||||
method_error = err
|
||||
end
|
||||
|
||||
@ -257,7 +257,7 @@ end
|
||||
--- @param setup_cb function?
|
||||
--- @param timeout integer
|
||||
--- @return {[1]: integer, [2]: string}
|
||||
function module.run_session(lsession, request_cb, notification_cb, setup_cb, timeout)
|
||||
function M.run_session(lsession, request_cb, notification_cb, setup_cb, timeout)
|
||||
local on_request --- @type function?
|
||||
local on_notification --- @type function?
|
||||
local on_setup --- @type function?
|
||||
@ -297,35 +297,35 @@ function module.run_session(lsession, request_cb, notification_cb, setup_cb, tim
|
||||
return lsession.eof_err
|
||||
end
|
||||
|
||||
function module.run(request_cb, notification_cb, setup_cb, timeout)
|
||||
function M.run(request_cb, notification_cb, setup_cb, timeout)
|
||||
assert(session)
|
||||
return module.run_session(session, request_cb, notification_cb, setup_cb, timeout)
|
||||
return M.run_session(session, request_cb, notification_cb, setup_cb, timeout)
|
||||
end
|
||||
|
||||
function module.stop()
|
||||
function M.stop()
|
||||
assert(session):stop()
|
||||
end
|
||||
|
||||
function module.nvim_prog_abs()
|
||||
function M.nvim_prog_abs()
|
||||
-- system(['build/bin/nvim']) does not work for whatever reason. It must
|
||||
-- be executable searched in $PATH or something starting with / or ./.
|
||||
if module.nvim_prog:match('[/\\]') then
|
||||
return module.request('nvim_call_function', 'fnamemodify', { module.nvim_prog, ':p' })
|
||||
if M.nvim_prog:match('[/\\]') then
|
||||
return M.request('nvim_call_function', 'fnamemodify', { M.nvim_prog, ':p' })
|
||||
else
|
||||
return module.nvim_prog
|
||||
return M.nvim_prog
|
||||
end
|
||||
end
|
||||
|
||||
-- Use for commands which expect nvim to quit.
|
||||
-- The first argument can also be a timeout.
|
||||
function module.expect_exit(fn_or_timeout, ...)
|
||||
function M.expect_exit(fn_or_timeout, ...)
|
||||
local eof_err_msg = 'EOF was received from Nvim. Likely the Nvim process crashed.'
|
||||
if type(fn_or_timeout) == 'function' then
|
||||
eq(eof_err_msg, module.pcall_err(fn_or_timeout, ...))
|
||||
eq(eof_err_msg, M.pcall_err(fn_or_timeout, ...))
|
||||
else
|
||||
eq(
|
||||
eof_err_msg,
|
||||
module.pcall_err(function(timeout, fn, ...)
|
||||
M.pcall_err(function(timeout, fn, ...)
|
||||
fn(...)
|
||||
assert(session)
|
||||
while session:next_message(timeout) do
|
||||
@ -343,8 +343,8 @@ end
|
||||
--- @param name string
|
||||
--- @param ... any
|
||||
--- @return any
|
||||
function module.call_lua(name, ...)
|
||||
return module.exec_lua([[return vim.call(...)]], name, ...)
|
||||
function M.call_lua(name, ...)
|
||||
return M.exec_lua([[return vim.call(...)]], name, ...)
|
||||
end
|
||||
|
||||
--- Sends user input to Nvim.
|
||||
@ -352,9 +352,9 @@ end
|
||||
--- @param input string
|
||||
local function nvim_feed(input)
|
||||
while #input > 0 do
|
||||
local written = module.request('nvim_input', input)
|
||||
local written = M.request('nvim_input', input)
|
||||
if written == nil then
|
||||
module.assert_alive()
|
||||
M.assert_alive()
|
||||
error('crash? (nvim_input returned nil)')
|
||||
end
|
||||
input = input:sub(written + 1)
|
||||
@ -362,7 +362,7 @@ local function nvim_feed(input)
|
||||
end
|
||||
|
||||
--- @param ... string
|
||||
function module.feed(...)
|
||||
function M.feed(...)
|
||||
for _, v in ipairs({ ... }) do
|
||||
nvim_feed(dedent(v))
|
||||
end
|
||||
@ -370,7 +370,7 @@ end
|
||||
|
||||
---@param ... string[]?
|
||||
---@return string[]
|
||||
function module.merge_args(...)
|
||||
function M.merge_args(...)
|
||||
local i = 1
|
||||
local argv = {} --- @type string[]
|
||||
for anum = 1, select('#', ...) do
|
||||
@ -432,7 +432,7 @@ local function remove_args(args, args_rm)
|
||||
return new_args
|
||||
end
|
||||
|
||||
function module.check_close()
|
||||
function M.check_close()
|
||||
if not session then
|
||||
return
|
||||
end
|
||||
@ -459,18 +459,18 @@ end
|
||||
--- @param keep boolean
|
||||
--- @param io_extra uv.uv_pipe_t? used for stdin_fd, see :help ui-option
|
||||
--- @return test.Session
|
||||
function module.spawn(argv, merge, env, keep, io_extra)
|
||||
function M.spawn(argv, merge, env, keep, io_extra)
|
||||
if not keep then
|
||||
module.check_close()
|
||||
M.check_close()
|
||||
end
|
||||
|
||||
local child_stream =
|
||||
ChildProcessStream.spawn(merge and module.merge_args(prepend_argv, argv) or argv, env, io_extra)
|
||||
ChildProcessStream.spawn(merge and M.merge_args(prepend_argv, argv) or argv, env, io_extra)
|
||||
return Session.new(child_stream)
|
||||
end
|
||||
|
||||
-- Creates a new Session connected by domain socket (named pipe) or TCP.
|
||||
function module.connect(file_or_address)
|
||||
function M.connect(file_or_address)
|
||||
local addr, port = string.match(file_or_address, '(.*):(%d+)')
|
||||
local stream = (addr and port) and SocketStream.connect(addr, port)
|
||||
or SocketStream.open(file_or_address)
|
||||
@ -489,17 +489,17 @@ end
|
||||
-- Example:
|
||||
-- clear('-e')
|
||||
-- clear{args={'-e'}, args_rm={'-i'}, env={TERM=term}}
|
||||
function module.clear(...)
|
||||
module.set_session(module.spawn_argv(false, ...))
|
||||
return module.get_session()
|
||||
function M.clear(...)
|
||||
M.set_session(M.spawn_argv(false, ...))
|
||||
return M.get_session()
|
||||
end
|
||||
|
||||
--- same params as clear, but does returns the session instead
|
||||
--- of replacing the default session
|
||||
--- @return test.Session
|
||||
function module.spawn_argv(keep, ...)
|
||||
local argv, env, io_extra = module.new_argv(...)
|
||||
return module.spawn(argv, nil, env, keep, io_extra)
|
||||
function M.spawn_argv(keep, ...)
|
||||
local argv, env, io_extra = M.new_argv(...)
|
||||
return M.spawn(argv, nil, env, keep, io_extra)
|
||||
end
|
||||
|
||||
--- @class test.new_argv.Opts
|
||||
@ -515,8 +515,8 @@ end
|
||||
--- @return string[]
|
||||
--- @return string[]?
|
||||
--- @return uv.uv_pipe_t?
|
||||
function module.new_argv(...)
|
||||
local args = { unpack(module.nvim_argv) }
|
||||
function M.new_argv(...)
|
||||
local args = { unpack(M.nvim_argv) }
|
||||
table.insert(args, '--headless')
|
||||
if _G._nvim_test_id then
|
||||
-- Set the server name to the test-id for logging. #8519
|
||||
@ -573,11 +573,11 @@ function module.new_argv(...)
|
||||
end
|
||||
|
||||
--- @param ... string
|
||||
function module.insert(...)
|
||||
function M.insert(...)
|
||||
nvim_feed('i')
|
||||
for _, v in ipairs({ ... }) do
|
||||
local escaped = v:gsub('<', '<lt>')
|
||||
module.feed(escaped)
|
||||
M.feed(escaped)
|
||||
end
|
||||
nvim_feed('<ESC>')
|
||||
end
|
||||
@ -585,7 +585,7 @@ end
|
||||
--- Executes an ex-command by user input. Because nvim_input() is used, Vimscript
|
||||
--- errors will not manifest as client (lua) errors. Use command() for that.
|
||||
--- @param ... string
|
||||
function module.feed_command(...)
|
||||
function M.feed_command(...)
|
||||
for _, v in ipairs({ ... }) do
|
||||
if v:sub(1, 1) ~= '/' then
|
||||
-- not a search command, prefix with colon
|
||||
@ -597,12 +597,12 @@ function module.feed_command(...)
|
||||
end
|
||||
|
||||
-- @deprecated use nvim_exec2()
|
||||
function module.source(code)
|
||||
module.exec(dedent(code))
|
||||
function M.source(code)
|
||||
M.exec(dedent(code))
|
||||
end
|
||||
|
||||
function module.has_powershell()
|
||||
return module.eval('executable("' .. (is_os('win') and 'powershell' or 'pwsh') .. '")') == 1
|
||||
function M.has_powershell()
|
||||
return M.eval('executable("' .. (is_os('win') and 'powershell' or 'pwsh') .. '")') == 1
|
||||
end
|
||||
|
||||
--- Sets Nvim shell to powershell.
|
||||
@ -610,12 +610,12 @@ end
|
||||
--- @param fake (boolean) If true, a fake will be used if powershell is not
|
||||
--- found on the system.
|
||||
--- @returns true if powershell was found on the system, else false.
|
||||
function module.set_shell_powershell(fake)
|
||||
local found = module.has_powershell()
|
||||
function M.set_shell_powershell(fake)
|
||||
local found = M.has_powershell()
|
||||
if not fake then
|
||||
assert(found)
|
||||
end
|
||||
local shell = found and (is_os('win') and 'powershell' or 'pwsh') or module.testprg('pwsh-test')
|
||||
local shell = found and (is_os('win') and 'powershell' or 'pwsh') or M.testprg('pwsh-test')
|
||||
local cmd = 'Remove-Item -Force '
|
||||
.. table.concat(
|
||||
is_os('win') and { 'alias:cat', 'alias:echo', 'alias:sleep', 'alias:sort', 'alias:tee' }
|
||||
@ -623,7 +623,7 @@ function module.set_shell_powershell(fake)
|
||||
','
|
||||
)
|
||||
.. ';'
|
||||
module.exec([[
|
||||
M.exec([[
|
||||
let &shell = ']] .. shell .. [['
|
||||
set shellquote= shellxquote=
|
||||
let &shellcmdflag = '-NoLogo -NoProfile -ExecutionPolicy RemoteSigned -Command '
|
||||
@ -638,7 +638,7 @@ end
|
||||
|
||||
---@param func function
|
||||
---@return table<string,function>
|
||||
function module.create_callindex(func)
|
||||
function M.create_callindex(func)
|
||||
return setmetatable({}, {
|
||||
--- @param tbl table<any,function>
|
||||
--- @param arg1 string
|
||||
@ -655,7 +655,7 @@ end
|
||||
|
||||
--- @param method string
|
||||
--- @param ... any
|
||||
function module.nvim_async(method, ...)
|
||||
function M.nvim_async(method, ...)
|
||||
assert(session):notify(method, ...)
|
||||
end
|
||||
|
||||
@ -664,27 +664,27 @@ end
|
||||
--- @param name string
|
||||
--- @param ... any
|
||||
--- @return any
|
||||
function module.call(name, ...)
|
||||
return module.request('nvim_call_function', name, { ... })
|
||||
function M.call(name, ...)
|
||||
return M.request('nvim_call_function', name, { ... })
|
||||
end
|
||||
|
||||
module.async_meths = module.create_callindex(module.nvim_async)
|
||||
M.async_meths = M.create_callindex(M.nvim_async)
|
||||
|
||||
module.rpc = {
|
||||
fn = module.create_callindex(module.call),
|
||||
api = module.create_callindex(module.request),
|
||||
M.rpc = {
|
||||
fn = M.create_callindex(M.call),
|
||||
api = M.create_callindex(M.request),
|
||||
}
|
||||
|
||||
module.lua = {
|
||||
fn = module.create_callindex(module.call_lua),
|
||||
api = module.create_callindex(module.request_lua),
|
||||
M.lua = {
|
||||
fn = M.create_callindex(M.call_lua),
|
||||
api = M.create_callindex(M.request_lua),
|
||||
}
|
||||
|
||||
module.describe_lua_and_rpc = function(describe)
|
||||
M.describe_lua_and_rpc = function(describe)
|
||||
return function(what, tests)
|
||||
local function d(flavour)
|
||||
describe(string.format('%s (%s)', what, flavour), function(...)
|
||||
return tests(module[flavour].api, ...)
|
||||
return tests(M[flavour].api, ...)
|
||||
end)
|
||||
end
|
||||
|
||||
@ -694,52 +694,52 @@ module.describe_lua_and_rpc = function(describe)
|
||||
end
|
||||
|
||||
--- add for typing. The for loop after will overwrite this
|
||||
module.api = vim.api
|
||||
module.fn = vim.fn
|
||||
M.api = vim.api
|
||||
M.fn = vim.fn
|
||||
|
||||
for name, fns in pairs(module.rpc) do
|
||||
for name, fns in pairs(M.rpc) do
|
||||
--- @diagnostic disable-next-line:no-unknown
|
||||
module[name] = fns
|
||||
M[name] = fns
|
||||
end
|
||||
|
||||
-- Executes an ex-command. Vimscript errors manifest as client (lua) errors, but
|
||||
-- v:errmsg will not be updated.
|
||||
module.command = module.api.nvim_command
|
||||
M.command = M.api.nvim_command
|
||||
|
||||
-- Evaluates a Vimscript expression.
|
||||
-- Fails on Vimscript error, but does not update v:errmsg.
|
||||
module.eval = module.api.nvim_eval
|
||||
M.eval = M.api.nvim_eval
|
||||
|
||||
function module.poke_eventloop()
|
||||
function M.poke_eventloop()
|
||||
-- Execute 'nvim_eval' (a deferred function) to
|
||||
-- force at least one main_loop iteration
|
||||
module.api.nvim_eval('1')
|
||||
M.api.nvim_eval('1')
|
||||
end
|
||||
|
||||
function module.buf_lines(bufnr)
|
||||
return module.exec_lua('return vim.api.nvim_buf_get_lines((...), 0, -1, false)', bufnr)
|
||||
function M.buf_lines(bufnr)
|
||||
return M.exec_lua('return vim.api.nvim_buf_get_lines((...), 0, -1, false)', bufnr)
|
||||
end
|
||||
|
||||
---@see buf_lines()
|
||||
function module.curbuf_contents()
|
||||
module.poke_eventloop() -- Before inspecting the buffer, do whatever.
|
||||
return table.concat(module.api.nvim_buf_get_lines(0, 0, -1, true), '\n')
|
||||
function M.curbuf_contents()
|
||||
M.poke_eventloop() -- Before inspecting the buffer, do whatever.
|
||||
return table.concat(M.api.nvim_buf_get_lines(0, 0, -1, true), '\n')
|
||||
end
|
||||
|
||||
function module.expect(contents)
|
||||
return eq(dedent(contents), module.curbuf_contents())
|
||||
function M.expect(contents)
|
||||
return eq(dedent(contents), M.curbuf_contents())
|
||||
end
|
||||
|
||||
function module.expect_any(contents)
|
||||
function M.expect_any(contents)
|
||||
contents = dedent(contents)
|
||||
return ok(nil ~= string.find(module.curbuf_contents(), contents, 1, true))
|
||||
return ok(nil ~= string.find(M.curbuf_contents(), contents, 1, true))
|
||||
end
|
||||
|
||||
--- @param expected any[]
|
||||
--- @param received any[]
|
||||
--- @param kind string
|
||||
--- @return any
|
||||
function module.expect_events(expected, received, kind)
|
||||
function M.expect_events(expected, received, kind)
|
||||
if not pcall(eq, expected, received) then
|
||||
local msg = 'unexpected ' .. kind .. ' received.\n\n'
|
||||
|
||||
@ -757,22 +757,22 @@ function module.expect_events(expected, received, kind)
|
||||
end
|
||||
|
||||
-- Checks that the Nvim session did not terminate.
|
||||
function module.assert_alive()
|
||||
assert(2 == module.eval('1+1'), 'crash? request failed')
|
||||
function M.assert_alive()
|
||||
assert(2 == M.eval('1+1'), 'crash? request failed')
|
||||
end
|
||||
|
||||
-- Asserts that buffer is loaded and visible in the current tabpage.
|
||||
function module.assert_visible(bufnr, visible)
|
||||
function M.assert_visible(bufnr, visible)
|
||||
assert(type(visible) == 'boolean')
|
||||
eq(visible, module.api.nvim_buf_is_loaded(bufnr))
|
||||
eq(visible, M.api.nvim_buf_is_loaded(bufnr))
|
||||
if visible then
|
||||
assert(
|
||||
-1 ~= module.fn.bufwinnr(bufnr),
|
||||
-1 ~= M.fn.bufwinnr(bufnr),
|
||||
'expected buffer to be visible in current tabpage: ' .. tostring(bufnr)
|
||||
)
|
||||
else
|
||||
assert(
|
||||
-1 == module.fn.bufwinnr(bufnr),
|
||||
-1 == M.fn.bufwinnr(bufnr),
|
||||
'expected buffer NOT visible in current tabpage: ' .. tostring(bufnr)
|
||||
)
|
||||
end
|
||||
@ -800,7 +800,7 @@ local function do_rmdir(path)
|
||||
else
|
||||
-- Try Nvim delete(): it handles `readonly` attribute on Windows,
|
||||
-- and avoids Lua cross-version/platform incompatibilities.
|
||||
if -1 == module.call('delete', abspath) then
|
||||
if -1 == M.call('delete', abspath) then
|
||||
local hint = (is_os('win') and ' (hint: try :%bwipeout! before rmdir())' or '')
|
||||
error('delete() failed' .. hint .. ': ' .. abspath)
|
||||
end
|
||||
@ -817,12 +817,12 @@ end
|
||||
|
||||
local start_dir = uv.cwd()
|
||||
|
||||
function module.rmdir(path)
|
||||
function M.rmdir(path)
|
||||
local ret, _ = pcall(do_rmdir, path)
|
||||
if not ret and is_os('win') then
|
||||
-- Maybe "Permission denied"; try again after changing the nvim
|
||||
-- process to the top-level directory.
|
||||
module.command([[exe 'cd '.fnameescape(']] .. start_dir .. "')")
|
||||
M.command([[exe 'cd '.fnameescape(']] .. start_dir .. "')")
|
||||
ret, _ = pcall(do_rmdir, path)
|
||||
end
|
||||
-- During teardown, the nvim process may not exit quickly enough, then rmdir()
|
||||
@ -833,23 +833,23 @@ function module.rmdir(path)
|
||||
end
|
||||
end
|
||||
|
||||
function module.exc_exec(cmd)
|
||||
module.command(([[
|
||||
function M.exc_exec(cmd)
|
||||
M.command(([[
|
||||
try
|
||||
execute "%s"
|
||||
catch
|
||||
let g:__exception = v:exception
|
||||
endtry
|
||||
]]):format(cmd:gsub('\n', '\\n'):gsub('[\\"]', '\\%0')))
|
||||
local ret = module.eval('get(g:, "__exception", 0)')
|
||||
module.command('unlet! g:__exception')
|
||||
local ret = M.eval('get(g:, "__exception", 0)')
|
||||
M.command('unlet! g:__exception')
|
||||
return ret
|
||||
end
|
||||
|
||||
--- @param cond boolean
|
||||
--- @param reason? string
|
||||
--- @return boolean
|
||||
function module.skip(cond, reason)
|
||||
function M.skip(cond, reason)
|
||||
if cond then
|
||||
--- @type fun(reason: string)
|
||||
local pending = getfenv(2).pending
|
||||
@ -861,7 +861,7 @@ end
|
||||
|
||||
-- Calls pending() and returns `true` if the system is too slow to
|
||||
-- run fragile or expensive tests. Else returns `false`.
|
||||
function module.skip_fragile(pending_fn, cond)
|
||||
function M.skip_fragile(pending_fn, cond)
|
||||
if pending_fn == nil or type(pending_fn) ~= type(function() end) then
|
||||
error('invalid pending_fn')
|
||||
end
|
||||
@ -875,52 +875,52 @@ function module.skip_fragile(pending_fn, cond)
|
||||
return false
|
||||
end
|
||||
|
||||
function module.exec(code)
|
||||
module.api.nvim_exec2(code, {})
|
||||
function M.exec(code)
|
||||
M.api.nvim_exec2(code, {})
|
||||
end
|
||||
|
||||
--- @param code string
|
||||
--- @return string
|
||||
function module.exec_capture(code)
|
||||
return module.api.nvim_exec2(code, { output = true }).output
|
||||
function M.exec_capture(code)
|
||||
return M.api.nvim_exec2(code, { output = true }).output
|
||||
end
|
||||
|
||||
--- @param code string
|
||||
--- @return any
|
||||
function module.exec_lua(code, ...)
|
||||
return module.api.nvim_exec_lua(code, { ... })
|
||||
function M.exec_lua(code, ...)
|
||||
return M.api.nvim_exec_lua(code, { ... })
|
||||
end
|
||||
|
||||
function module.get_pathsep()
|
||||
function M.get_pathsep()
|
||||
return is_os('win') and '\\' or '/'
|
||||
end
|
||||
|
||||
--- Gets the filesystem root dir, namely "/" or "C:/".
|
||||
function module.pathroot()
|
||||
function M.pathroot()
|
||||
local pathsep = package.config:sub(1, 1)
|
||||
return is_os('win') and (module.nvim_dir:sub(1, 2) .. pathsep) or '/'
|
||||
return is_os('win') and (M.nvim_dir:sub(1, 2) .. pathsep) or '/'
|
||||
end
|
||||
|
||||
--- Gets the full `…/build/bin/{name}` path of a test program produced by
|
||||
--- `test/functional/fixtures/CMakeLists.txt`.
|
||||
---
|
||||
--- @param name (string) Name of the test program.
|
||||
function module.testprg(name)
|
||||
local ext = module.is_os('win') and '.exe' or ''
|
||||
return ('%s/%s%s'):format(module.nvim_dir, name, ext)
|
||||
function M.testprg(name)
|
||||
local ext = M.is_os('win') and '.exe' or ''
|
||||
return ('%s/%s%s'):format(M.nvim_dir, name, ext)
|
||||
end
|
||||
|
||||
function module.is_asan()
|
||||
local version = module.eval('execute("verbose version")')
|
||||
function M.is_asan()
|
||||
local version = M.eval('execute("verbose version")')
|
||||
return version:match('-fsanitize=[a-z,]*address')
|
||||
end
|
||||
|
||||
-- Returns a valid, platform-independent Nvim listen address.
|
||||
-- Useful for communicating with child instances.
|
||||
function module.new_pipename()
|
||||
function M.new_pipename()
|
||||
-- HACK: Start a server temporarily, get the name, then stop it.
|
||||
local pipename = module.eval('serverstart()')
|
||||
module.fn.serverstop(pipename)
|
||||
local pipename = M.eval('serverstart()')
|
||||
M.fn.serverstop(pipename)
|
||||
-- Remove the pipe so that trying to connect to it without a server listening
|
||||
-- will be an error instead of a hang.
|
||||
os.remove(pipename)
|
||||
@ -929,24 +929,24 @@ end
|
||||
|
||||
--- @param provider string
|
||||
--- @return string|boolean?
|
||||
function module.missing_provider(provider)
|
||||
function M.missing_provider(provider)
|
||||
if provider == 'ruby' or provider == 'perl' then
|
||||
--- @type string?
|
||||
local e = module.exec_lua("return {require('vim.provider." .. provider .. "').detect()}")[2]
|
||||
local e = M.exec_lua("return {require('vim.provider." .. provider .. "').detect()}")[2]
|
||||
return e ~= '' and e or false
|
||||
elseif provider == 'node' then
|
||||
--- @type string?
|
||||
local e = module.fn['provider#node#Detect']()[2]
|
||||
local e = M.fn['provider#node#Detect']()[2]
|
||||
return e ~= '' and e or false
|
||||
elseif provider == 'python' then
|
||||
return module.exec_lua([[return {require('vim.provider.python').detect_by_module('neovim')}]])[2]
|
||||
return M.exec_lua([[return {require('vim.provider.python').detect_by_module('neovim')}]])[2]
|
||||
end
|
||||
assert(false, 'Unknown provider: ' .. provider)
|
||||
end
|
||||
|
||||
--- @param obj string|table
|
||||
--- @return any
|
||||
function module.alter_slashes(obj)
|
||||
function M.alter_slashes(obj)
|
||||
if not is_os('win') then
|
||||
return obj
|
||||
end
|
||||
@ -957,7 +957,7 @@ function module.alter_slashes(obj)
|
||||
--- @cast obj table<any,any>
|
||||
local ret = {} --- @type table<any,any>
|
||||
for k, v in pairs(obj) do
|
||||
ret[k] = module.alter_slashes(v)
|
||||
ret[k] = M.alter_slashes(v)
|
||||
end
|
||||
return ret
|
||||
end
|
||||
@ -967,26 +967,26 @@ end
|
||||
local load_factor = 1
|
||||
if t_global.is_ci() then
|
||||
-- Compute load factor only once (but outside of any tests).
|
||||
module.clear()
|
||||
module.request('nvim_command', 'source test/old/testdir/load.vim')
|
||||
load_factor = module.request('nvim_eval', 'g:test_load_factor')
|
||||
M.clear()
|
||||
M.request('nvim_command', 'source test/old/testdir/load.vim')
|
||||
load_factor = M.request('nvim_eval', 'g:test_load_factor')
|
||||
end
|
||||
|
||||
--- @param num number
|
||||
--- @return number
|
||||
function module.load_adjust(num)
|
||||
function M.load_adjust(num)
|
||||
return math.ceil(num * load_factor)
|
||||
end
|
||||
|
||||
--- @param ctx table<string,any>
|
||||
--- @return table
|
||||
function module.parse_context(ctx)
|
||||
function M.parse_context(ctx)
|
||||
local parsed = {} --- @type table<string,any>
|
||||
for _, item in ipairs({ 'regs', 'jumps', 'bufs', 'gvars' }) do
|
||||
--- @param v any
|
||||
parsed[item] = vim.tbl_filter(function(v)
|
||||
return type(v) == 'table'
|
||||
end, module.call('msgpackparse', ctx[item]))
|
||||
end, M.call('msgpackparse', ctx[item]))
|
||||
end
|
||||
parsed['bufs'] = parsed['bufs'][1]
|
||||
--- @param v any
|
||||
@ -998,15 +998,15 @@ function module.parse_context(ctx)
|
||||
end, parsed)
|
||||
end
|
||||
|
||||
function module.add_builddir_to_rtp()
|
||||
function M.add_builddir_to_rtp()
|
||||
-- Add runtime from build dir for doc/tags (used with :help).
|
||||
module.command(string.format([[set rtp+=%s/runtime]], module.paths.test_build_dir))
|
||||
M.command(string.format([[set rtp+=%s/runtime]], M.paths.test_build_dir))
|
||||
end
|
||||
|
||||
--- Kill (reap) a process by PID.
|
||||
--- @param pid string
|
||||
--- @return boolean?
|
||||
function module.os_kill(pid)
|
||||
function M.os_kill(pid)
|
||||
return os.execute(
|
||||
(
|
||||
is_os('win') and 'taskkill /f /t /pid ' .. pid .. ' > nul'
|
||||
@ -1018,7 +1018,7 @@ end
|
||||
--- Create folder with non existing parents
|
||||
--- @param path string
|
||||
--- @return boolean?
|
||||
function module.mkdir_p(path)
|
||||
function M.mkdir_p(path)
|
||||
return os.execute((is_os('win') and 'mkdir ' .. path or 'mkdir -p ' .. path))
|
||||
end
|
||||
|
||||
@ -1059,5 +1059,5 @@ return function()
|
||||
end
|
||||
end)
|
||||
end
|
||||
return module
|
||||
return M
|
||||
end
|
||||
|
@ -17,7 +17,7 @@ local function shell_quote(str)
|
||||
end
|
||||
|
||||
--- @class test.testutil
|
||||
local module = {
|
||||
local M = {
|
||||
paths = Paths,
|
||||
}
|
||||
|
||||
@ -30,7 +30,7 @@ end
|
||||
|
||||
--- @param path string
|
||||
--- @return boolean
|
||||
function module.isdir(path)
|
||||
function M.isdir(path)
|
||||
if not path then
|
||||
return false
|
||||
end
|
||||
@ -43,7 +43,7 @@ end
|
||||
|
||||
--- @param ... string|string[]
|
||||
--- @return string
|
||||
function module.argss_to_cmd(...)
|
||||
function M.argss_to_cmd(...)
|
||||
local cmd = {} --- @type string[]
|
||||
for i = 1, select('#', ...) do
|
||||
local arg = select(i, ...)
|
||||
@ -59,8 +59,8 @@ function module.argss_to_cmd(...)
|
||||
return table.concat(cmd, ' ')
|
||||
end
|
||||
|
||||
function module.popen_r(...)
|
||||
return io.popen(module.argss_to_cmd(...), 'r')
|
||||
function M.popen_r(...)
|
||||
return io.popen(M.argss_to_cmd(...), 'r')
|
||||
end
|
||||
|
||||
--- Calls fn() until it succeeds, up to `max` times or until `max_ms`
|
||||
@ -69,7 +69,7 @@ end
|
||||
--- @param max_ms integer?
|
||||
--- @param fn function
|
||||
--- @return any
|
||||
function module.retry(max, max_ms, fn)
|
||||
function M.retry(max, max_ms, fn)
|
||||
luaassert(max == nil or max > 0)
|
||||
luaassert(max_ms == nil or max_ms > 0)
|
||||
local tries = 1
|
||||
@ -96,10 +96,10 @@ local check_logs_useless_lines = {
|
||||
['See README_MISSING_SYSCALL_OR_IOCTL for guidance'] = 3,
|
||||
}
|
||||
|
||||
function module.eq(expected, actual, context)
|
||||
function M.eq(expected, actual, context)
|
||||
return luaassert.are.same(expected, actual, context)
|
||||
end
|
||||
function module.neq(expected, actual, context)
|
||||
function M.neq(expected, actual, context)
|
||||
return luaassert.are_not.same(expected, actual, context)
|
||||
end
|
||||
|
||||
@ -108,7 +108,7 @@ end
|
||||
--- @param cond (boolean) expression to assert
|
||||
--- @param expected (any) description of expected result
|
||||
--- @param actual (any) description of actual result
|
||||
function module.ok(cond, expected, actual)
|
||||
function M.ok(cond, expected, actual)
|
||||
luaassert(
|
||||
(not expected and not actual) or (expected and actual),
|
||||
'if "expected" is given, "actual" is also required'
|
||||
@ -122,14 +122,14 @@ local function epicfail(state, arguments, _)
|
||||
return false
|
||||
end
|
||||
luaassert:register('assertion', 'epicfail', epicfail)
|
||||
function module.fail(msg)
|
||||
function M.fail(msg)
|
||||
return luaassert.epicfail(msg)
|
||||
end
|
||||
|
||||
--- @param pat string
|
||||
--- @param actual string
|
||||
--- @return boolean
|
||||
function module.matches(pat, actual)
|
||||
function M.matches(pat, actual)
|
||||
if nil ~= string.match(actual, pat) then
|
||||
return true
|
||||
end
|
||||
@ -144,14 +144,14 @@ end
|
||||
---@param logfile? (string) Full path to log file (default=$NVIM_LOG_FILE)
|
||||
---@param nrlines? (number) Search up to this many log lines
|
||||
---@param inverse? (boolean) Assert that the pattern does NOT match.
|
||||
function module.assert_log(pat, logfile, nrlines, inverse)
|
||||
function M.assert_log(pat, logfile, nrlines, inverse)
|
||||
logfile = logfile or os.getenv('NVIM_LOG_FILE') or '.nvimlog'
|
||||
luaassert(logfile ~= nil, 'no logfile')
|
||||
nrlines = nrlines or 10
|
||||
inverse = inverse or false
|
||||
|
||||
module.retry(nil, 1000, function()
|
||||
local lines = module.read_file_list(logfile, -nrlines) or {}
|
||||
M.retry(nil, 1000, function()
|
||||
local lines = M.read_file_list(logfile, -nrlines) or {}
|
||||
local msg = string.format(
|
||||
'Pattern %q %sfound in log (last %d lines): %s:\n%s',
|
||||
pat,
|
||||
@ -181,14 +181,14 @@ end
|
||||
--- @param pat (string) Lua pattern to match lines in the log file
|
||||
--- @param logfile? (string) Full path to log file (default=$NVIM_LOG_FILE)
|
||||
--- @param nrlines? (number) Search up to this many log lines
|
||||
function module.assert_nolog(pat, logfile, nrlines)
|
||||
return module.assert_log(pat, logfile, nrlines, true)
|
||||
function M.assert_nolog(pat, logfile, nrlines)
|
||||
return M.assert_log(pat, logfile, nrlines, true)
|
||||
end
|
||||
|
||||
--- @param fn fun(...): any
|
||||
--- @param ... any
|
||||
--- @return boolean, any
|
||||
function module.pcall(fn, ...)
|
||||
function M.pcall(fn, ...)
|
||||
luaassert(type(fn) == 'function')
|
||||
local status, rv = pcall(fn, ...)
|
||||
if status then
|
||||
@ -237,9 +237,9 @@ end
|
||||
--
|
||||
--- @param fn function
|
||||
--- @return string
|
||||
function module.pcall_err_withfile(fn, ...)
|
||||
function M.pcall_err_withfile(fn, ...)
|
||||
luaassert(type(fn) == 'function')
|
||||
local status, rv = module.pcall(fn, ...)
|
||||
local status, rv = M.pcall(fn, ...)
|
||||
if status == true then
|
||||
error('expected failure, but got success')
|
||||
end
|
||||
@ -249,8 +249,8 @@ end
|
||||
--- @param fn function
|
||||
--- @param ... any
|
||||
--- @return string
|
||||
function module.pcall_err_withtrace(fn, ...)
|
||||
local errmsg = module.pcall_err_withfile(fn, ...)
|
||||
function M.pcall_err_withtrace(fn, ...)
|
||||
local errmsg = M.pcall_err_withfile(fn, ...)
|
||||
|
||||
return (
|
||||
errmsg
|
||||
@ -263,20 +263,20 @@ end
|
||||
--- @param fn function
|
||||
--- @param ... any
|
||||
--- @return string
|
||||
function module.pcall_err(fn, ...)
|
||||
return module.remove_trace(module.pcall_err_withtrace(fn, ...))
|
||||
function M.pcall_err(fn, ...)
|
||||
return M.remove_trace(M.pcall_err_withtrace(fn, ...))
|
||||
end
|
||||
|
||||
--- @param s string
|
||||
--- @return string
|
||||
function module.remove_trace(s)
|
||||
function M.remove_trace(s)
|
||||
return (s:gsub('\n%s*stack traceback:.*', ''))
|
||||
end
|
||||
|
||||
-- initial_path: directory to recurse into
|
||||
-- re: include pattern (string)
|
||||
-- exc_re: exclude pattern(s) (string or table)
|
||||
function module.glob(initial_path, re, exc_re)
|
||||
function M.glob(initial_path, re, exc_re)
|
||||
exc_re = type(exc_re) == 'table' and exc_re or { exc_re }
|
||||
local paths_to_check = { initial_path } --- @type string[]
|
||||
local ret = {} --- @type string[]
|
||||
@ -318,10 +318,10 @@ function module.glob(initial_path, re, exc_re)
|
||||
return ret
|
||||
end
|
||||
|
||||
function module.check_logs()
|
||||
function M.check_logs()
|
||||
local log_dir = os.getenv('LOG_DIR')
|
||||
local runtime_errors = {}
|
||||
if log_dir and module.isdir(log_dir) then
|
||||
if log_dir and M.isdir(log_dir) then
|
||||
for tail in vim.fs.dir(log_dir) do
|
||||
if tail:sub(1, 30) == 'valgrind-' or tail:find('san%.') then
|
||||
local file = log_dir .. '/' .. tail
|
||||
@ -343,7 +343,7 @@ function module.check_logs()
|
||||
local status, f
|
||||
local out = io.stdout
|
||||
if os.getenv('SYMBOLIZER') then
|
||||
status, f = pcall(module.popen_r, os.getenv('SYMBOLIZER'), '-l', file)
|
||||
status, f = pcall(M.popen_r, os.getenv('SYMBOLIZER'), '-l', file)
|
||||
end
|
||||
out:write(start_msg .. '\n')
|
||||
if status then
|
||||
@ -368,22 +368,22 @@ function module.check_logs()
|
||||
)
|
||||
end
|
||||
|
||||
function module.sysname()
|
||||
function M.sysname()
|
||||
return uv.os_uname().sysname:lower()
|
||||
end
|
||||
|
||||
--- @param s 'win'|'mac'|'freebsd'|'openbsd'|'bsd'
|
||||
--- @return boolean
|
||||
function module.is_os(s)
|
||||
function M.is_os(s)
|
||||
if not (s == 'win' or s == 'mac' or s == 'freebsd' or s == 'openbsd' or s == 'bsd') then
|
||||
error('unknown platform: ' .. tostring(s))
|
||||
end
|
||||
return not not (
|
||||
(s == 'win' and (module.sysname():find('windows') or module.sysname():find('mingw')))
|
||||
or (s == 'mac' and module.sysname() == 'darwin')
|
||||
or (s == 'freebsd' and module.sysname() == 'freebsd')
|
||||
or (s == 'openbsd' and module.sysname() == 'openbsd')
|
||||
or (s == 'bsd' and module.sysname():find('bsd'))
|
||||
(s == 'win' and (M.sysname():find('windows') or M.sysname():find('mingw')))
|
||||
or (s == 'mac' and M.sysname() == 'darwin')
|
||||
or (s == 'freebsd' and M.sysname() == 'freebsd')
|
||||
or (s == 'openbsd' and M.sysname() == 'openbsd')
|
||||
or (s == 'bsd' and M.sysname():find('bsd'))
|
||||
)
|
||||
end
|
||||
|
||||
@ -402,7 +402,7 @@ local tmpname_id = 0
|
||||
local tmpdir = tmpdir_get()
|
||||
|
||||
--- Creates a new temporary file for use by tests.
|
||||
function module.tmpname()
|
||||
function M.tmpname()
|
||||
if tmpdir_is_local(tmpdir) then
|
||||
-- Cannot control os.tmpname() dir, so hack our own tmpname() impl.
|
||||
tmpname_id = tmpname_id + 1
|
||||
@ -413,11 +413,11 @@ function module.tmpname()
|
||||
end
|
||||
|
||||
local fname = os.tmpname()
|
||||
if module.is_os('win') and fname:sub(1, 2) == '\\s' then
|
||||
if M.is_os('win') and fname:sub(1, 2) == '\\s' then
|
||||
-- In Windows tmpname() returns a filename starting with
|
||||
-- special sequence \s, prepend $TEMP path
|
||||
return tmpdir .. fname
|
||||
elseif module.is_os('mac') and fname:match('^/tmp') then
|
||||
elseif M.is_os('mac') and fname:match('^/tmp') then
|
||||
-- In OS X /tmp links to /private/tmp
|
||||
return '/private' .. fname
|
||||
end
|
||||
@ -432,7 +432,7 @@ end
|
||||
|
||||
local tests_skipped = 0
|
||||
|
||||
function module.check_cores(app, force) -- luacheck: ignore
|
||||
function M.check_cores(app, force) -- luacheck: ignore
|
||||
-- Temporary workaround: skip core check as it interferes with CI.
|
||||
if true then
|
||||
return
|
||||
@ -459,14 +459,14 @@ function module.check_cores(app, force) -- luacheck: ignore
|
||||
exc_re = { os.getenv('NVIM_TEST_CORE_EXC_RE'), local_tmpdir }
|
||||
db_cmd = os.getenv('NVIM_TEST_CORE_DB_CMD') or gdb_db_cmd
|
||||
random_skip = os.getenv('NVIM_TEST_CORE_RANDOM_SKIP') ~= ''
|
||||
elseif module.is_os('mac') then
|
||||
elseif M.is_os('mac') then
|
||||
initial_path = '/cores'
|
||||
re = nil
|
||||
exc_re = { local_tmpdir }
|
||||
db_cmd = lldb_db_cmd
|
||||
else
|
||||
initial_path = '.'
|
||||
if module.is_os('freebsd') then
|
||||
if M.is_os('freebsd') then
|
||||
re = '/nvim.core$'
|
||||
else
|
||||
re = '/core[^/]*$'
|
||||
@ -480,7 +480,7 @@ function module.check_cores(app, force) -- luacheck: ignore
|
||||
tests_skipped = tests_skipped + 1
|
||||
return
|
||||
end
|
||||
local cores = module.glob(initial_path, re, exc_re)
|
||||
local cores = M.glob(initial_path, re, exc_re)
|
||||
local found_cores = 0
|
||||
local out = io.stdout
|
||||
for _, core in ipairs(cores) do
|
||||
@ -503,23 +503,23 @@ function module.check_cores(app, force) -- luacheck: ignore
|
||||
end
|
||||
|
||||
--- @return string?
|
||||
function module.repeated_read_cmd(...)
|
||||
function M.repeated_read_cmd(...)
|
||||
for _ = 1, 10 do
|
||||
local stream = module.popen_r(...)
|
||||
local stream = M.popen_r(...)
|
||||
local ret = stream:read('*a')
|
||||
stream:close()
|
||||
if ret then
|
||||
return ret
|
||||
end
|
||||
end
|
||||
print('ERROR: Failed to execute ' .. module.argss_to_cmd(...) .. ': nil return after 10 attempts')
|
||||
print('ERROR: Failed to execute ' .. M.argss_to_cmd(...) .. ': nil return after 10 attempts')
|
||||
return nil
|
||||
end
|
||||
|
||||
--- @generic T
|
||||
--- @param orig T
|
||||
--- @return T
|
||||
function module.shallowcopy(orig)
|
||||
function M.shallowcopy(orig)
|
||||
if type(orig) ~= 'table' then
|
||||
return orig
|
||||
end
|
||||
@ -534,13 +534,13 @@ end
|
||||
--- @param d1 table<any,any>
|
||||
--- @param d2 table<any,any>
|
||||
--- @return table<any,any>
|
||||
function module.mergedicts_copy(d1, d2)
|
||||
local ret = module.shallowcopy(d1)
|
||||
function M.mergedicts_copy(d1, d2)
|
||||
local ret = M.shallowcopy(d1)
|
||||
for k, v in pairs(d2) do
|
||||
if d2[k] == vim.NIL then
|
||||
ret[k] = nil
|
||||
elseif type(d1[k]) == 'table' and type(v) == 'table' then
|
||||
ret[k] = module.mergedicts_copy(d1[k], v)
|
||||
ret[k] = M.mergedicts_copy(d1[k], v)
|
||||
else
|
||||
ret[k] = v
|
||||
end
|
||||
@ -553,7 +553,7 @@ end
|
||||
--- Note: does not do copies of d2 values used.
|
||||
--- @param d1 table<any,any>
|
||||
--- @param d2 table<any,any>
|
||||
function module.dictdiff(d1, d2)
|
||||
function M.dictdiff(d1, d2)
|
||||
local ret = {} --- @type table<any,any>
|
||||
local hasdiff = false
|
||||
for k, v in pairs(d1) do
|
||||
@ -562,7 +562,7 @@ function module.dictdiff(d1, d2)
|
||||
ret[k] = vim.NIL
|
||||
elseif type(v) == type(d2[k]) then
|
||||
if type(v) == 'table' then
|
||||
local subdiff = module.dictdiff(v, d2[k])
|
||||
local subdiff = M.dictdiff(v, d2[k])
|
||||
if subdiff ~= nil then
|
||||
hasdiff = true
|
||||
ret[k] = subdiff
|
||||
@ -576,7 +576,7 @@ function module.dictdiff(d1, d2)
|
||||
hasdiff = true
|
||||
end
|
||||
end
|
||||
local shallowcopy = module.shallowcopy
|
||||
local shallowcopy = M.shallowcopy
|
||||
for k, v in pairs(d2) do
|
||||
if d1[k] == nil then
|
||||
ret[k] = shallowcopy(v)
|
||||
@ -591,7 +591,7 @@ function module.dictdiff(d1, d2)
|
||||
end
|
||||
|
||||
-- Concat list-like tables.
|
||||
function module.concat_tables(...)
|
||||
function M.concat_tables(...)
|
||||
local ret = {} --- @type table<any,any>
|
||||
for i = 1, select('#', ...) do
|
||||
--- @type table<any,any>
|
||||
@ -608,7 +608,7 @@ end
|
||||
--- @param str string
|
||||
--- @param leave_indent? integer
|
||||
--- @return string
|
||||
function module.dedent(str, leave_indent)
|
||||
function M.dedent(str, leave_indent)
|
||||
-- find minimum common indent across lines
|
||||
local indent --- @type string?
|
||||
for line in str:gmatch('[^\n]+') do
|
||||
@ -633,14 +633,14 @@ function module.dedent(str, leave_indent)
|
||||
return str
|
||||
end
|
||||
|
||||
function module.intchar2lua(ch)
|
||||
function M.intchar2lua(ch)
|
||||
ch = tonumber(ch)
|
||||
return (20 <= ch and ch < 127) and ('%c'):format(ch) or ch
|
||||
end
|
||||
|
||||
--- @param str string
|
||||
--- @return string
|
||||
function module.hexdump(str)
|
||||
function M.hexdump(str)
|
||||
local len = string.len(str)
|
||||
local dump = ''
|
||||
local hex = ''
|
||||
@ -669,7 +669,7 @@ end
|
||||
--- @param filename string path to file
|
||||
--- @param start? integer start line (1-indexed), negative means "lines before end" (tail)
|
||||
--- @return string[]?
|
||||
function module.read_file_list(filename, start)
|
||||
function M.read_file_list(filename, start)
|
||||
local lnum = (start ~= nil and type(start) == 'number') and start or 1
|
||||
local tail = (lnum < 0)
|
||||
local maxlines = tail and math.abs(lnum) or nil
|
||||
@ -707,7 +707,7 @@ end
|
||||
--- Reads the entire contents of `filename` into a string.
|
||||
--- @param filename string
|
||||
--- @return string?
|
||||
function module.read_file(filename)
|
||||
function M.read_file(filename)
|
||||
local file = io.open(filename, 'r')
|
||||
if not file then
|
||||
return nil
|
||||
@ -718,7 +718,7 @@ function module.read_file(filename)
|
||||
end
|
||||
|
||||
-- Dedent the given text and write it to the file name.
|
||||
function module.write_file(name, text, no_dedent, append)
|
||||
function M.write_file(name, text, no_dedent, append)
|
||||
local file = assert(io.open(name, (append and 'a' or 'w')))
|
||||
if type(text) == 'table' then
|
||||
-- Byte blob
|
||||
@ -729,7 +729,7 @@ function module.write_file(name, text, no_dedent, append)
|
||||
text = ('%s%c'):format(text, char)
|
||||
end
|
||||
elseif not no_dedent then
|
||||
text = module.dedent(text)
|
||||
text = M.dedent(text)
|
||||
end
|
||||
file:write(text)
|
||||
file:flush()
|
||||
@ -738,7 +738,7 @@ end
|
||||
|
||||
--- @param name? 'cirrus'|'github'
|
||||
--- @return boolean
|
||||
function module.is_ci(name)
|
||||
function M.is_ci(name)
|
||||
local any = (name == nil)
|
||||
luaassert(any or name == 'github' or name == 'cirrus')
|
||||
local gh = ((any or name == 'github') and nil ~= os.getenv('GITHUB_ACTIONS'))
|
||||
@ -748,11 +748,11 @@ end
|
||||
|
||||
-- Gets the (tail) contents of `logfile`.
|
||||
-- Also moves the file to "${NVIM_LOG_FILE}.displayed" on CI environments.
|
||||
function module.read_nvim_log(logfile, ci_rename)
|
||||
function M.read_nvim_log(logfile, ci_rename)
|
||||
logfile = logfile or os.getenv('NVIM_LOG_FILE') or '.nvimlog'
|
||||
local is_ci = module.is_ci()
|
||||
local is_ci = M.is_ci()
|
||||
local keep = is_ci and 100 or 10
|
||||
local lines = module.read_file_list(logfile, -keep) or {}
|
||||
local lines = M.read_file_list(logfile, -keep) or {}
|
||||
local log = (
|
||||
('-'):rep(78)
|
||||
.. '\n'
|
||||
@ -771,9 +771,9 @@ end
|
||||
|
||||
--- @param path string
|
||||
--- @return boolean?
|
||||
function module.mkdir(path)
|
||||
function M.mkdir(path)
|
||||
-- 493 is 0755 in decimal
|
||||
return (uv.fs_mkdir(path, 493))
|
||||
end
|
||||
|
||||
return module
|
||||
return M
|
||||
|
@ -877,7 +877,7 @@ local function is_asan()
|
||||
end
|
||||
|
||||
--- @class test.unit.testutil.module
|
||||
local module = {
|
||||
local M = {
|
||||
cimport = cimport,
|
||||
cppimport = cppimport,
|
||||
internalize = internalize,
|
||||
@ -907,6 +907,6 @@ local module = {
|
||||
is_asan = is_asan,
|
||||
}
|
||||
--- @class test.unit.testutil: test.unit.testutil.module, test.testutil
|
||||
module = vim.tbl_extend('error', module, t_global)
|
||||
M = vim.tbl_extend('error', M, t_global)
|
||||
|
||||
return module
|
||||
return M
|
||||
|
Loading…
Reference in New Issue
Block a user