mirror of
https://github.com/neovim/neovim.git
synced 2025-02-25 18:55:25 -06:00
unittests: Do not import libnvim or headers in main process
Slows down unit tests much, but gets rid of as much preserved state as possible.
This commit is contained in:
parent
9400466282
commit
e2a578f40d
@ -19,47 +19,46 @@ local api = cimport('./src/nvim/api/private/defs.h',
|
||||
|
||||
local obj2lua
|
||||
|
||||
local obj2lua_tab = {
|
||||
[tonumber(api.kObjectTypeArray)] = function(obj)
|
||||
local ret = {[type_key]=list_type}
|
||||
for i = 1,tonumber(obj.data.array.size) do
|
||||
ret[i] = obj2lua(obj.data.array.items[i - 1])
|
||||
end
|
||||
if ret[1] then
|
||||
ret[type_key] = nil
|
||||
end
|
||||
return ret
|
||||
end,
|
||||
[tonumber(api.kObjectTypeDictionary)] = function(obj)
|
||||
local ret = {}
|
||||
for i = 1,tonumber(obj.data.dictionary.size) do
|
||||
local kv_pair = obj.data.dictionary.items[i - 1]
|
||||
ret[ffi.string(kv_pair.key.data, kv_pair.key.size)] = obj2lua(kv_pair.value)
|
||||
end
|
||||
return ret
|
||||
end,
|
||||
[tonumber(api.kObjectTypeBoolean)] = function(obj)
|
||||
if obj.data.boolean == false then
|
||||
return false
|
||||
else
|
||||
return true
|
||||
end
|
||||
end,
|
||||
[tonumber(api.kObjectTypeNil)] = function(_)
|
||||
return nil_value
|
||||
end,
|
||||
[tonumber(api.kObjectTypeFloat)] = function(obj)
|
||||
return tonumber(obj.data.floating)
|
||||
end,
|
||||
[tonumber(api.kObjectTypeInteger)] = function(obj)
|
||||
return {[type_key]=int_type, value=tonumber(obj.data.integer)}
|
||||
end,
|
||||
[tonumber(api.kObjectTypeString)] = function(obj)
|
||||
return ffi.string(obj.data.string.data, obj.data.string.size)
|
||||
end,
|
||||
}
|
||||
|
||||
obj2lua = function(obj)
|
||||
local obj2lua_tab = {
|
||||
[tonumber(api.kObjectTypeArray)] = function(obj)
|
||||
local ret = {[type_key]=list_type}
|
||||
for i = 1,tonumber(obj.data.array.size) do
|
||||
ret[i] = obj2lua(obj.data.array.items[i - 1])
|
||||
end
|
||||
if ret[1] then
|
||||
ret[type_key] = nil
|
||||
end
|
||||
return ret
|
||||
end,
|
||||
[tonumber(api.kObjectTypeDictionary)] = function(obj)
|
||||
local ret = {}
|
||||
for i = 1,tonumber(obj.data.dictionary.size) do
|
||||
local kv_pair = obj.data.dictionary.items[i - 1]
|
||||
ret[ffi.string(kv_pair.key.data, kv_pair.key.size)] = obj2lua(kv_pair.value)
|
||||
end
|
||||
return ret
|
||||
end,
|
||||
[tonumber(api.kObjectTypeBoolean)] = function(obj)
|
||||
if obj.data.boolean == false then
|
||||
return false
|
||||
else
|
||||
return true
|
||||
end
|
||||
end,
|
||||
[tonumber(api.kObjectTypeNil)] = function(_)
|
||||
return nil_value
|
||||
end,
|
||||
[tonumber(api.kObjectTypeFloat)] = function(obj)
|
||||
return tonumber(obj.data.floating)
|
||||
end,
|
||||
[tonumber(api.kObjectTypeInteger)] = function(obj)
|
||||
return {[type_key]=int_type, value=tonumber(obj.data.integer)}
|
||||
end,
|
||||
[tonumber(api.kObjectTypeString)] = function(obj)
|
||||
return ffi.string(obj.data.string.data, obj.data.string.size)
|
||||
end,
|
||||
}
|
||||
return ((obj2lua_tab[tonumber(obj['type'])] or function(obj_inner)
|
||||
assert(false, 'Converting ' .. tostring(tonumber(obj_inner['type'])) .. ' is not implementing yet')
|
||||
end)(obj))
|
||||
|
@ -12,20 +12,6 @@ local decode = cimport('./src/nvim/eval/decode.h', './src/nvim/eval_defs.h',
|
||||
'./src/nvim/message.h')
|
||||
|
||||
describe('json_decode_string()', function()
|
||||
local saved_p_enc = nil
|
||||
|
||||
before_each(function()
|
||||
saved_p_enc = decode.p_enc
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
decode.emsg_silent = 0
|
||||
decode.p_enc = saved_p_enc
|
||||
while decode.delete_first_msg() == 1 do
|
||||
-- Delete all messages
|
||||
end
|
||||
end)
|
||||
|
||||
local char = function(c)
|
||||
return ffi.gc(decode.xmemdup(c, 1), decode.xfree)
|
||||
end
|
||||
|
@ -46,12 +46,6 @@ local function list(...)
|
||||
return ret
|
||||
end
|
||||
|
||||
local special_tab = {
|
||||
[eval.kSpecialVarFalse] = false,
|
||||
[eval.kSpecialVarNull] = nil_value,
|
||||
[eval.kSpecialVarTrue] = true,
|
||||
}
|
||||
|
||||
local ptr2key = function(ptr)
|
||||
return tostring(ptr)
|
||||
end
|
||||
@ -60,64 +54,74 @@ local lst2tbl
|
||||
local dct2tbl
|
||||
|
||||
local typvalt2lua
|
||||
local typvalt2lua_tab
|
||||
local typvalt2lua_tab = nil
|
||||
|
||||
typvalt2lua_tab = {
|
||||
[tonumber(eval.VAR_SPECIAL)] = function(t)
|
||||
return special_tab[t.vval.v_special]
|
||||
end,
|
||||
[tonumber(eval.VAR_NUMBER)] = function(t)
|
||||
return {[type_key]=int_type, value=tonumber(t.vval.v_number)}
|
||||
end,
|
||||
[tonumber(eval.VAR_FLOAT)] = function(t)
|
||||
return tonumber(t.vval.v_float)
|
||||
end,
|
||||
[tonumber(eval.VAR_STRING)] = function(t)
|
||||
local str = t.vval.v_string
|
||||
if str == nil then
|
||||
return null_string
|
||||
else
|
||||
return ffi.string(str)
|
||||
end
|
||||
end,
|
||||
[tonumber(eval.VAR_LIST)] = function(t, processed)
|
||||
return lst2tbl(t.vval.v_list, processed)
|
||||
end,
|
||||
[tonumber(eval.VAR_DICT)] = function(t, processed)
|
||||
return dct2tbl(t.vval.v_dict, processed)
|
||||
end,
|
||||
[tonumber(eval.VAR_FUNC)] = function(t, processed)
|
||||
return {[type_key]=func_type, value=typvalt2lua_tab[eval.VAR_STRING](t, processed or {})}
|
||||
end,
|
||||
[tonumber(eval.VAR_PARTIAL)] = function(t, processed)
|
||||
local p_key = ptr2key(t)
|
||||
if processed[p_key] then
|
||||
return processed[p_key]
|
||||
end
|
||||
local pt = t.vval.v_partial
|
||||
local value, auto, dict, argv = nil, nil, nil, nil
|
||||
if pt ~= nil then
|
||||
value = ffi.string(pt.pt_name)
|
||||
auto = pt.pt_auto and true or nil
|
||||
argv = {}
|
||||
for i = 1, pt.pt_argc do
|
||||
argv[i] = typvalt2lua(pt.pt_argv[i - 1], processed)
|
||||
local function typvalt2lua_tab_init()
|
||||
if typvalt2lua_tab then
|
||||
return
|
||||
end
|
||||
typvalt2lua_tab = {
|
||||
[tonumber(eval.VAR_SPECIAL)] = function(t)
|
||||
return ({
|
||||
[eval.kSpecialVarFalse] = false,
|
||||
[eval.kSpecialVarNull] = nil_value,
|
||||
[eval.kSpecialVarTrue] = true,
|
||||
})[t.vval.v_special]
|
||||
end,
|
||||
[tonumber(eval.VAR_NUMBER)] = function(t)
|
||||
return {[type_key]=int_type, value=tonumber(t.vval.v_number)}
|
||||
end,
|
||||
[tonumber(eval.VAR_FLOAT)] = function(t)
|
||||
return tonumber(t.vval.v_float)
|
||||
end,
|
||||
[tonumber(eval.VAR_STRING)] = function(t)
|
||||
local str = t.vval.v_string
|
||||
if str == nil then
|
||||
return null_string
|
||||
else
|
||||
return ffi.string(str)
|
||||
end
|
||||
if pt.pt_dict ~= nil then
|
||||
dict = dct2tbl(pt.pt_dict)
|
||||
end,
|
||||
[tonumber(eval.VAR_LIST)] = function(t, processed)
|
||||
return lst2tbl(t.vval.v_list, processed)
|
||||
end,
|
||||
[tonumber(eval.VAR_DICT)] = function(t, processed)
|
||||
return dct2tbl(t.vval.v_dict, processed)
|
||||
end,
|
||||
[tonumber(eval.VAR_FUNC)] = function(t, processed)
|
||||
return {[type_key]=func_type, value=typvalt2lua_tab[eval.VAR_STRING](t, processed or {})}
|
||||
end,
|
||||
[tonumber(eval.VAR_PARTIAL)] = function(t, processed)
|
||||
local p_key = ptr2key(t)
|
||||
if processed[p_key] then
|
||||
return processed[p_key]
|
||||
end
|
||||
end
|
||||
return {
|
||||
[type_key]=func_type,
|
||||
value=value,
|
||||
auto=auto,
|
||||
args=argv,
|
||||
dict=dict,
|
||||
}
|
||||
end,
|
||||
}
|
||||
local pt = t.vval.v_partial
|
||||
local value, auto, dict, argv = nil, nil, nil, nil
|
||||
if pt ~= nil then
|
||||
value = ffi.string(pt.pt_name)
|
||||
auto = pt.pt_auto and true or nil
|
||||
argv = {}
|
||||
for i = 1, pt.pt_argc do
|
||||
argv[i] = typvalt2lua(pt.pt_argv[i - 1], processed)
|
||||
end
|
||||
if pt.pt_dict ~= nil then
|
||||
dict = dct2tbl(pt.pt_dict)
|
||||
end
|
||||
end
|
||||
return {
|
||||
[type_key]=func_type,
|
||||
value=value,
|
||||
auto=auto,
|
||||
args=argv,
|
||||
dict=dict,
|
||||
}
|
||||
end,
|
||||
}
|
||||
end
|
||||
|
||||
typvalt2lua = function(t, processed)
|
||||
typvalt2lua_tab_init()
|
||||
return ((typvalt2lua_tab[tonumber(t.v_type)] or function(t_inner)
|
||||
assert(false, 'Converting ' .. tonumber(t_inner.v_type) .. ' was not implemented yet')
|
||||
end)(t, processed or {}))
|
||||
@ -169,9 +173,10 @@ lst2tbl = function(l, processed)
|
||||
return ret
|
||||
end
|
||||
|
||||
local hi_key_removed = eval._hash_key_removed()
|
||||
local hi_key_removed = nil
|
||||
|
||||
local function dict_iter(d, return_hi)
|
||||
hi_key_removed = hi_key_removed or eval._hash_key_removed()
|
||||
local init_s = {
|
||||
todo=d.dv_hashtab.ht_used,
|
||||
hi=d.dv_hashtab.ht_array,
|
||||
@ -320,25 +325,28 @@ local lua2typvalt_type_tab = {
|
||||
end,
|
||||
}
|
||||
|
||||
local special_vals = {
|
||||
[null_string] = {eval.VAR_STRING, {v_string=ffi.cast('char_u*', nil)}},
|
||||
[null_list] = {eval.VAR_LIST, {v_list=ffi.cast('list_T*', nil)}},
|
||||
[null_dict] = {eval.VAR_DICT, {v_dict=ffi.cast('dict_T*', nil)}},
|
||||
[nil_value] = {eval.VAR_SPECIAL, {v_special=eval.kSpecialVarNull}},
|
||||
[true] = {eval.VAR_SPECIAL, {v_special=eval.kSpecialVarTrue}},
|
||||
[false] = {eval.VAR_SPECIAL, {v_special=eval.kSpecialVarFalse}},
|
||||
}
|
||||
|
||||
for k, v in pairs(special_vals) do
|
||||
local tmp = function(typ, vval)
|
||||
special_vals[k] = function()
|
||||
return typvalt(typ, vval)
|
||||
end
|
||||
end
|
||||
tmp(v[1], v[2])
|
||||
end
|
||||
local special_vals = nil
|
||||
|
||||
lua2typvalt = function(l, processed)
|
||||
if not special_vals then
|
||||
special_vals = {
|
||||
[null_string] = {'VAR_STRING', {v_string=ffi.cast('char_u*', nil)}},
|
||||
[null_list] = {'VAR_LIST', {v_list=ffi.cast('list_T*', nil)}},
|
||||
[null_dict] = {'VAR_DICT', {v_dict=ffi.cast('dict_T*', nil)}},
|
||||
[nil_value] = {'VAR_SPECIAL', {v_special=eval.kSpecialVarNull}},
|
||||
[true] = {'VAR_SPECIAL', {v_special=eval.kSpecialVarTrue}},
|
||||
[false] = {'VAR_SPECIAL', {v_special=eval.kSpecialVarFalse}},
|
||||
}
|
||||
|
||||
for k, v in pairs(special_vals) do
|
||||
local tmp = function(typ, vval)
|
||||
special_vals[k] = function()
|
||||
return typvalt(eval[typ], vval)
|
||||
end
|
||||
end
|
||||
tmp(v[1], v[2])
|
||||
end
|
||||
end
|
||||
processed = processed or {}
|
||||
if l == nil or l == nil_value then
|
||||
return special_vals[nil_value]()
|
||||
@ -360,7 +368,7 @@ lua2typvalt = function(l, processed)
|
||||
return typvalt(eval.VAR_STRING, {v_string=eval.xmemdupz(to_cstr(l), #l)})
|
||||
elseif type(l) == 'cdata' then
|
||||
local tv = typvalt(eval.VAR_UNKNOWN)
|
||||
eval.tv_copy(l, tv)
|
||||
eval.copy_tv(l, tv)
|
||||
return tv
|
||||
end
|
||||
end
|
||||
|
@ -9,7 +9,7 @@ local ffi = helpers.ffi
|
||||
local to_cstr = helpers.to_cstr
|
||||
local NULL = helpers.NULL
|
||||
|
||||
local garray = cimport('stdlib.h', './src/nvim/garray.h')
|
||||
local garray = cimport('./src/nvim/garray.h')
|
||||
|
||||
local itemsize = 14
|
||||
local growsize = 95
|
||||
@ -157,7 +157,7 @@ local ga_append_ints = function(garr, ...)
|
||||
end
|
||||
|
||||
-- enhanced constructors
|
||||
local garray_ctype = ffi.typeof('garray_T[1]')
|
||||
local garray_ctype = function(...) return ffi.typeof('garray_T[1]')(...) end
|
||||
local new_garray = function()
|
||||
local garr = garray_ctype()
|
||||
return ffi.gc(garr, ga_clear)
|
||||
|
@ -13,6 +13,7 @@ local syscall = nil
|
||||
local check_cores = global_helpers.check_cores
|
||||
local which = global_helpers.which
|
||||
local neq = global_helpers.neq
|
||||
local map = global_helpers.map
|
||||
local eq = global_helpers.eq
|
||||
local ok = global_helpers.ok
|
||||
|
||||
@ -22,13 +23,82 @@ local NULL = ffi.cast('void*', 0)
|
||||
local OK = 1
|
||||
local FAIL = 0
|
||||
|
||||
local cimport
|
||||
|
||||
-- add some standard header locations
|
||||
for _, p in ipairs(Paths.include_paths) do
|
||||
Preprocess.add_to_include_path(p)
|
||||
end
|
||||
|
||||
-- load neovim shared library
|
||||
local libnvim = ffi.load(Paths.test_libnvim_path)
|
||||
local pid = nil
|
||||
local function only_separate(func)
|
||||
return function(...)
|
||||
if pid ~= 0 then
|
||||
eq(0, 'This function must be run in a separate process only')
|
||||
end
|
||||
return func(...)
|
||||
end
|
||||
end
|
||||
local deferred_calls_init = {}
|
||||
local deferred_calls_mod = nil
|
||||
local function deferred_call(func, ret)
|
||||
return function(...)
|
||||
local deferred_calls = deferred_calls_mod or deferred_calls_init
|
||||
if pid ~= 0 then
|
||||
deferred_calls[#deferred_calls + 1] = {func=func, args={...}}
|
||||
return ret
|
||||
else
|
||||
return func(...)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local separate_cleanups_mod = nil
|
||||
local function separate_cleanup(func)
|
||||
return function(...)
|
||||
local separate_cleanups = separate_cleanups_mod
|
||||
if pid ~= 0 then
|
||||
separate_cleanups[#separate_cleanups + 1] = {args={...}}
|
||||
else
|
||||
func(...)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local libnvim = nil
|
||||
|
||||
local lib = setmetatable({}, {
|
||||
__index = only_separate(function(tbl, idx)
|
||||
return libnvim[idx]
|
||||
end),
|
||||
__newindex = deferred_call(function(tbl, idx, val)
|
||||
libnvim[idx] = val
|
||||
end),
|
||||
})
|
||||
|
||||
local init = only_separate(function()
|
||||
-- load neovim shared library
|
||||
libnvim = ffi.load(Paths.test_libnvim_path)
|
||||
for _, c in ipairs(deferred_calls_init) do
|
||||
c.func(unpack(c.args))
|
||||
end
|
||||
libnvim.time_init()
|
||||
libnvim.early_init()
|
||||
libnvim.event_init()
|
||||
if deferred_calls_mod then
|
||||
for _, c in ipairs(deferred_calls_mod) do
|
||||
c.func(unpack(c.args))
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
local deinit = only_separate(function()
|
||||
if separate_cleanups_mod then
|
||||
for _, c in ipairs(separate_cleanups_mod) do
|
||||
c.func(unpack(c.args))
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
local function trim(s)
|
||||
return s:match('^%s*(.*%S)') or ''
|
||||
@ -58,52 +128,74 @@ local function filter_complex_blocks(body)
|
||||
return table.concat(result, "\n")
|
||||
end
|
||||
|
||||
local previous_defines = ''
|
||||
|
||||
local cdef = ffi.cdef
|
||||
|
||||
local cimportstr
|
||||
|
||||
local previous_defines_init = ''
|
||||
local preprocess_cache_init = {}
|
||||
local previous_defines_mod = ''
|
||||
local preprocess_cache_mod = nil
|
||||
|
||||
-- use this helper to import C files, you can pass multiple paths at once,
|
||||
-- this helper will return the C namespace of the nvim library.
|
||||
local function cimport(...)
|
||||
local paths = {}
|
||||
local args = {...}
|
||||
|
||||
-- filter out paths we've already imported
|
||||
for _,path in pairs(args) do
|
||||
if path ~= nil and not imported:contains(path) then
|
||||
paths[#paths + 1] = path
|
||||
cimport = function(...)
|
||||
local previous_defines, preprocess_cache
|
||||
if preprocess_cache_mod then
|
||||
preprocess_cache = preprocess_cache_mod
|
||||
previous_defines = previous_defines_mod
|
||||
else
|
||||
preprocess_cache = preprocess_cache_init
|
||||
previous_defines = previous_defines_init
|
||||
end
|
||||
for _, path in ipairs({...}) do
|
||||
if not (path:sub(1, 1) == '/' or path:sub(1, 1) == '.'
|
||||
or path:sub(2, 2) == ':') then
|
||||
path = './' .. path
|
||||
end
|
||||
local body
|
||||
if preprocess_cache[path] then
|
||||
body = preprocess_cache[path]
|
||||
else
|
||||
body, previous_defines = Preprocess.preprocess(previous_defines, path)
|
||||
-- format it (so that the lines are "unique" statements), also filter out
|
||||
-- Objective-C blocks
|
||||
if os.getenv('NVIM_TEST_PRINT_I') == '1' then
|
||||
local lnum = 0
|
||||
for line in body:gmatch('[^\n]+') do
|
||||
lnum = lnum + 1
|
||||
print(lnum, line)
|
||||
end
|
||||
end
|
||||
body = formatc(body)
|
||||
body = filter_complex_blocks(body)
|
||||
preprocess_cache[path] = body
|
||||
end
|
||||
cimportstr(preprocess_cache, path)
|
||||
end
|
||||
|
||||
for _,path in pairs(paths) do
|
||||
imported:add(path)
|
||||
end
|
||||
|
||||
if #paths == 0 then
|
||||
return libnvim
|
||||
end
|
||||
|
||||
local body
|
||||
body, previous_defines = Preprocess.preprocess(previous_defines, unpack(paths))
|
||||
|
||||
return cimportstr(body)
|
||||
return lib
|
||||
end
|
||||
|
||||
cimportstr = function(body)
|
||||
-- format it (so that the lines are "unique" statements), also filter out
|
||||
-- Objective-C blocks
|
||||
if os.getenv('NVIM_TEST_PRINT_I') == '1' then
|
||||
local lnum = 0
|
||||
for line in body:gmatch('[^\n]+') do
|
||||
lnum = lnum + 1
|
||||
print(lnum, line)
|
||||
end
|
||||
local cimport_immediate = function(...)
|
||||
local saved_pid = pid
|
||||
pid = 0
|
||||
local err, emsg = pcall(cimport, ...)
|
||||
pid = saved_pid
|
||||
if not err then
|
||||
emsg = tostring(emsg)
|
||||
io.stderr:write(emsg .. '\n')
|
||||
assert(false)
|
||||
else
|
||||
return lib
|
||||
end
|
||||
body = formatc(body)
|
||||
body = filter_complex_blocks(body)
|
||||
end
|
||||
|
||||
cimportstr = deferred_call(function(preprocess_cache, path)
|
||||
if imported:contains(path) then
|
||||
return lib
|
||||
end
|
||||
local body = preprocess_cache[path]
|
||||
-- add the formatted lines to a set
|
||||
local new_cdefs = Set:new()
|
||||
for line in body:gmatch("[^\r\n]+") do
|
||||
@ -126,7 +218,7 @@ cimportstr = function(body)
|
||||
|
||||
if new_cdefs:size() == 0 then
|
||||
-- if there's no new lines, just return
|
||||
return libnvim
|
||||
return lib
|
||||
end
|
||||
|
||||
-- request a sorted version of the new lines (same relative order as the
|
||||
@ -138,13 +230,10 @@ cimportstr = function(body)
|
||||
end
|
||||
end
|
||||
cdef(table.concat(new_lines, "\n"))
|
||||
imported:add(path)
|
||||
|
||||
return libnvim
|
||||
end
|
||||
|
||||
local function cppimport(path)
|
||||
return cimport(Paths.test_include_path .. '/' .. path)
|
||||
end
|
||||
return lib
|
||||
end, lib)
|
||||
|
||||
local function alloc_log_new()
|
||||
local log = {
|
||||
@ -156,9 +245,12 @@ local function alloc_log_new()
|
||||
local allocator_functions = {'malloc', 'free', 'calloc', 'realloc'}
|
||||
function log:save_original_functions()
|
||||
for _, funcname in ipairs(allocator_functions) do
|
||||
self.original_functions[funcname] = self.lib['mem_' .. funcname]
|
||||
if not self.original_functions[funcname] then
|
||||
self.original_functions[funcname] = self.lib['mem_' .. funcname]
|
||||
end
|
||||
end
|
||||
end
|
||||
log.save_original_functions = deferred_call(log.save_original_functions)
|
||||
function log:set_mocks()
|
||||
for _, k in ipairs(allocator_functions) do
|
||||
do
|
||||
@ -185,6 +277,7 @@ local function alloc_log_new()
|
||||
end
|
||||
end
|
||||
end
|
||||
log.set_mocks = deferred_call(log.set_mocks)
|
||||
function log:clear()
|
||||
self.log = {}
|
||||
end
|
||||
@ -193,22 +286,28 @@ local function alloc_log_new()
|
||||
self:clear()
|
||||
end
|
||||
function log:restore_original_functions()
|
||||
for k, v in pairs(self.original_functions) do
|
||||
self.lib['mem_' .. k] = v
|
||||
end
|
||||
-- Do nothing: set mocks live in a separate process
|
||||
return
|
||||
--[[
|
||||
[ for k, v in pairs(self.original_functions) do
|
||||
[ self.lib['mem_' .. k] = v
|
||||
[ end
|
||||
]]
|
||||
end
|
||||
function log:before_each()
|
||||
function log:setup()
|
||||
log:save_original_functions()
|
||||
log:set_mocks()
|
||||
end
|
||||
function log:before_each()
|
||||
return
|
||||
end
|
||||
function log:after_each()
|
||||
log:restore_original_functions()
|
||||
end
|
||||
log:setup()
|
||||
return log
|
||||
end
|
||||
|
||||
cimport('./src/nvim/types.h')
|
||||
|
||||
-- take a pointer to a C-allocated string and return an interned
|
||||
-- version while also freeing the memory
|
||||
local function internalize(cdata, len)
|
||||
@ -221,16 +320,6 @@ local function to_cstr(string)
|
||||
return cstr(#string + 1, string)
|
||||
end
|
||||
|
||||
-- initialize some global variables, this is still necessary to unit test
|
||||
-- functions that rely on global state.
|
||||
do
|
||||
local main = cimport('./src/nvim/main.h')
|
||||
local time = cimport('./src/nvim/os/time.h')
|
||||
time.time_init()
|
||||
main.early_init()
|
||||
main.event_init()
|
||||
end
|
||||
|
||||
local sc
|
||||
|
||||
if posix ~= nil then
|
||||
@ -263,7 +352,7 @@ elseif syscall ~= nil then
|
||||
exit = syscall.exit,
|
||||
}
|
||||
else
|
||||
cimport('./test/unit/fixtures/posix.h')
|
||||
cimport_immediate('./test/unit/fixtures/posix.h')
|
||||
sc = {
|
||||
fork = function()
|
||||
return tonumber(ffi.C.fork())
|
||||
@ -291,7 +380,7 @@ else
|
||||
len - total_bytes_read))
|
||||
if bytes_read == -1 then
|
||||
local err = ffi.errno(0)
|
||||
if err ~= libnvim.kPOSIXErrnoEINTR then
|
||||
if err ~= ffi.C.kPOSIXErrnoEINTR then
|
||||
assert(false, ("read() error: %u: %s"):format(
|
||||
err, ffi.string(ffi.C.strerror(err))))
|
||||
end
|
||||
@ -314,7 +403,7 @@ else
|
||||
#s - total_bytes_written))
|
||||
if bytes_written == -1 then
|
||||
local err = ffi.errno(0)
|
||||
if err ~= libnvim.kPOSIXErrnoEINTR then
|
||||
if err ~= ffi.C.kPOSIXErrnoEINTR then
|
||||
assert(false, ("write() error: %u: %s"):format(
|
||||
err, ffi.string(ffi.C.strerror(err))))
|
||||
end
|
||||
@ -330,12 +419,12 @@ else
|
||||
wait = function(pid)
|
||||
ffi.errno(0)
|
||||
while true do
|
||||
local r = ffi.C.waitpid(pid, nil, libnvim.kPOSIXWaitWUNTRACED)
|
||||
local r = ffi.C.waitpid(pid, nil, ffi.C.kPOSIXWaitWUNTRACED)
|
||||
if r == -1 then
|
||||
local err = ffi.errno(0)
|
||||
if err == libnvim.kPOSIXErrnoECHILD then
|
||||
if err == ffi.C.kPOSIXErrnoECHILD then
|
||||
break
|
||||
elseif err ~= libnvim.kPOSIXErrnoEINTR then
|
||||
elseif err ~= ffi.C.kPOSIXErrnoEINTR then
|
||||
assert(false, ("waitpid() error: %u: %s"):format(
|
||||
err, ffi.string(ffi.C.strerror(err))))
|
||||
end
|
||||
@ -371,6 +460,10 @@ if os.getenv('NVIM_TEST_PRINT_SYSCALLS') == '1' then
|
||||
end
|
||||
|
||||
local function gen_itp(it)
|
||||
deferred_calls_mod = {}
|
||||
deferred_cleanups_mod = {}
|
||||
preprocess_cache_mod = map(function(v) return v end, preprocess_cache_init)
|
||||
previous_defines_mod = previous_defines_init
|
||||
local function just_fail(_)
|
||||
return false
|
||||
end
|
||||
@ -386,8 +479,9 @@ local function gen_itp(it)
|
||||
end
|
||||
it(name, function()
|
||||
local rd, wr = sc.pipe()
|
||||
local pid = sc.fork()
|
||||
pid = sc.fork()
|
||||
if pid == 0 then
|
||||
init()
|
||||
sc.close(rd)
|
||||
collectgarbage('stop')
|
||||
local err, emsg = pcall(func)
|
||||
@ -395,16 +489,19 @@ local function gen_itp(it)
|
||||
emsg = tostring(emsg)
|
||||
if not err then
|
||||
sc.write(wr, ('-\n%05u\n%s'):format(#emsg, emsg))
|
||||
deinit()
|
||||
sc.close(wr)
|
||||
sc.exit(1)
|
||||
else
|
||||
sc.write(wr, '+\n')
|
||||
deinit()
|
||||
sc.close(wr)
|
||||
sc.exit(0)
|
||||
end
|
||||
else
|
||||
sc.close(wr)
|
||||
sc.wait(pid)
|
||||
pid = nil
|
||||
local function check()
|
||||
local res = sc.read(rd, 2)
|
||||
eq(2, #res)
|
||||
@ -433,6 +530,12 @@ local function gen_itp(it)
|
||||
return itp
|
||||
end
|
||||
|
||||
local function cppimport(path)
|
||||
return cimport(Paths.test_include_path .. '/' .. path)
|
||||
end
|
||||
|
||||
cimport('./src/nvim/types.h', './src/nvim/main.h', './src/nvim/os/time.h')
|
||||
|
||||
local module = {
|
||||
cimport = cimport,
|
||||
cppimport = cppimport,
|
||||
@ -441,7 +544,7 @@ local module = {
|
||||
eq = eq,
|
||||
neq = neq,
|
||||
ffi = ffi,
|
||||
lib = libnvim,
|
||||
lib = lib,
|
||||
cstr = cstr,
|
||||
to_cstr = to_cstr,
|
||||
NULL = NULL,
|
||||
@ -449,6 +552,9 @@ local module = {
|
||||
FAIL = FAIL,
|
||||
alloc_log_new = alloc_log_new,
|
||||
gen_itp = gen_itp,
|
||||
only_separate = only_separate,
|
||||
deferred_call = deferred_call,
|
||||
separate_cleanup = separate_cleanup,
|
||||
}
|
||||
return function(after_each)
|
||||
if after_each then
|
||||
|
@ -1,10 +1,12 @@
|
||||
local helpers = require("test.unit.helpers")(after_each)
|
||||
local itp = helpers.gen_itp(it)
|
||||
|
||||
local ffi = helpers.ffi
|
||||
local eq = helpers.eq
|
||||
local deferred_call = helpers.deferred_call
|
||||
local cimport = helpers.cimport
|
||||
local ffi = helpers.ffi
|
||||
local eq = helpers.eq
|
||||
|
||||
local multiqueue = helpers.cimport("./test/unit/fixtures/multiqueue.h")
|
||||
local multiqueue = cimport("./test/unit/fixtures/multiqueue.h")
|
||||
|
||||
describe("multiqueue (multi-level event-queue)", function()
|
||||
local parent, child1, child2, child3
|
||||
@ -21,7 +23,7 @@ describe("multiqueue (multi-level event-queue)", function()
|
||||
multiqueue.multiqueue_free(q)
|
||||
end
|
||||
|
||||
before_each(function()
|
||||
before_each(deferred_call(function()
|
||||
parent = multiqueue.multiqueue_new_parent(ffi.NULL, ffi.NULL)
|
||||
child1 = multiqueue.multiqueue_new_child(parent)
|
||||
child2 = multiqueue.multiqueue_new_child(parent)
|
||||
@ -35,7 +37,7 @@ describe("multiqueue (multi-level event-queue)", function()
|
||||
put(child2, 'c2i4')
|
||||
put(child3, 'c3i1')
|
||||
put(child3, 'c3i2')
|
||||
end)
|
||||
end))
|
||||
|
||||
itp('keeps count of added events', function()
|
||||
eq(3, multiqueue.multiqueue_size(child1))
|
||||
|
@ -16,10 +16,10 @@ local to_cstr = helpers.to_cstr
|
||||
local OK = helpers.OK
|
||||
local FAIL = helpers.FAIL
|
||||
local NULL = helpers.NULL
|
||||
|
||||
local NODE_NORMAL = 0
|
||||
local NODE_WRITABLE = 1
|
||||
|
||||
cimport('unistd.h')
|
||||
cimport('./src/nvim/os/shell.h')
|
||||
cimport('./src/nvim/option_defs.h')
|
||||
cimport('./src/nvim/main.h')
|
||||
@ -66,13 +66,10 @@ local function os_getperm(filename)
|
||||
end
|
||||
|
||||
describe('fs function', function()
|
||||
local orig_test_file_perm
|
||||
|
||||
setup(function()
|
||||
before_each(function()
|
||||
lfs.mkdir('unit-test-directory');
|
||||
|
||||
io.open('unit-test-directory/test.file', 'w').close()
|
||||
orig_test_file_perm = os_getperm('unit-test-directory/test.file')
|
||||
|
||||
io.open('unit-test-directory/test_2.file', 'w').close()
|
||||
lfs.link('test.file', 'unit-test-directory/test_link.file', true)
|
||||
@ -84,7 +81,7 @@ describe('fs function', function()
|
||||
directory, executable_name = string.match(absolute_executable, '^(.*)/(.*)$')
|
||||
end)
|
||||
|
||||
teardown(function()
|
||||
after_each(function()
|
||||
os.remove('unit-test-directory/test.file')
|
||||
os.remove('unit-test-directory/test_2.file')
|
||||
os.remove('unit-test-directory/test_link.file')
|
||||
@ -217,10 +214,6 @@ describe('fs function', function()
|
||||
end)
|
||||
|
||||
describe('file permissions', function()
|
||||
before_each(function()
|
||||
os_setperm('unit-test-directory/test.file', orig_test_file_perm)
|
||||
end)
|
||||
|
||||
local function os_fchown(filename, user_id, group_id)
|
||||
local fd = ffi.C.open(filename, 0)
|
||||
local res = fs.os_fchown(fd, user_id, group_id)
|
||||
|
@ -11,6 +11,7 @@ local ffi, eq = helpers.ffi, helpers.eq
|
||||
local intern = helpers.internalize
|
||||
local to_cstr = helpers.to_cstr
|
||||
local NULL = ffi.cast('void *', 0)
|
||||
local deferred_call = deferred_call
|
||||
|
||||
describe('shell functions', function()
|
||||
before_each(function()
|
||||
@ -73,25 +74,13 @@ describe('shell functions', function()
|
||||
eq(0, status)
|
||||
end)
|
||||
|
||||
it ('returns non-zero exit code', function()
|
||||
itp('returns non-zero exit code', function()
|
||||
local status = os_system('exit 2')
|
||||
eq(2, status)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('shell_build_argv', function()
|
||||
local saved_opts = {}
|
||||
|
||||
setup(function()
|
||||
saved_opts.p_sh = cimported.p_sh
|
||||
saved_opts.p_shcf = cimported.p_shcf
|
||||
end)
|
||||
|
||||
teardown(function()
|
||||
cimported.p_sh = saved_opts.p_sh
|
||||
cimported.p_shcf = saved_opts.p_shcf
|
||||
end)
|
||||
|
||||
itp('works with NULL arguments', function()
|
||||
eq({'/bin/bash'}, shell_build_argv(nil, nil))
|
||||
end)
|
||||
|
@ -15,13 +15,6 @@ local FAIL = helpers.FAIL
|
||||
cimport('string.h')
|
||||
local path = cimport('./src/nvim/path.h')
|
||||
|
||||
-- import constants parsed by ffi
|
||||
local kEqualFiles = path.kEqualFiles
|
||||
local kDifferentFiles = path.kDifferentFiles
|
||||
local kBothFilesMissing = path.kBothFilesMissing
|
||||
local kOneFileMissing = path.kOneFileMissing
|
||||
local kEqualFileNames = path.kEqualFileNames
|
||||
|
||||
local length = 0
|
||||
local buffer = nil
|
||||
|
||||
@ -93,25 +86,25 @@ describe('path function', function()
|
||||
end)
|
||||
|
||||
itp('returns kEqualFiles when passed the same file', function()
|
||||
eq(kEqualFiles, (path_full_compare(f1, f1)))
|
||||
eq(path.kEqualFiles, (path_full_compare(f1, f1)))
|
||||
end)
|
||||
|
||||
itp('returns kEqualFileNames when files that dont exist and have same name', function()
|
||||
eq(kEqualFileNames, (path_full_compare('null.txt', 'null.txt', true)))
|
||||
eq(path.kEqualFileNames, (path_full_compare('null.txt', 'null.txt', true)))
|
||||
end)
|
||||
|
||||
itp('returns kBothFilesMissing when files that dont exist', function()
|
||||
eq(kBothFilesMissing, (path_full_compare('null.txt', 'null.txt')))
|
||||
eq(path.kBothFilesMissing, (path_full_compare('null.txt', 'null.txt')))
|
||||
end)
|
||||
|
||||
itp('returns kDifferentFiles when passed different files', function()
|
||||
eq(kDifferentFiles, (path_full_compare(f1, f2)))
|
||||
eq(kDifferentFiles, (path_full_compare(f2, f1)))
|
||||
eq(path.kDifferentFiles, (path_full_compare(f1, f2)))
|
||||
eq(path.kDifferentFiles, (path_full_compare(f2, f1)))
|
||||
end)
|
||||
|
||||
itp('returns kOneFileMissing if only one does not exist', function()
|
||||
eq(kOneFileMissing, (path_full_compare(f1, 'null.txt')))
|
||||
eq(kOneFileMissing, (path_full_compare('null.txt', f1)))
|
||||
eq(path.kOneFileMissing, (path_full_compare(f1, 'null.txt')))
|
||||
eq(path.kOneFileMissing, (path_full_compare('null.txt', f1)))
|
||||
end)
|
||||
end)
|
||||
|
||||
|
@ -1,11 +1,13 @@
|
||||
local helpers = require 'test.unit.helpers'
|
||||
local helpers = require('test.unit.helpers')(after_each)
|
||||
local itp = helpers.gen_itp(it)
|
||||
|
||||
local prof = helpers.cimport './src/nvim/profile.h'
|
||||
local cimport = helpers.cimport
|
||||
local ffi = helpers.ffi
|
||||
local eq = helpers.eq
|
||||
local neq = helpers.neq
|
||||
|
||||
local prof = cimport('./src/nvim/profile.h')
|
||||
|
||||
local function split(inputstr, sep)
|
||||
if sep == nil then
|
||||
sep = "%s"
|
||||
|
@ -1,10 +1,11 @@
|
||||
local helpers = require("test.unit.helpers")(after_each)
|
||||
local itp = helpers.gen_itp(it)
|
||||
|
||||
local ffi = helpers.ffi
|
||||
local eq = helpers.eq
|
||||
local cstr = helpers.cstr
|
||||
local eq = helpers.eq
|
||||
local ffi = helpers.ffi
|
||||
local cstr = helpers.cstr
|
||||
local to_cstr = helpers.to_cstr
|
||||
local deferred_call = helpers.deferred_call
|
||||
|
||||
local rbuffer = helpers.cimport("./test/unit/fixtures/rbuffer.h")
|
||||
|
||||
@ -31,11 +32,11 @@ describe('rbuffer functions', function()
|
||||
return ffi.string(rbuffer.rbuffer_get(rbuf, idx), 1)
|
||||
end
|
||||
|
||||
before_each(function()
|
||||
before_each(deferred_call(function()
|
||||
rbuf = ffi.gc(rbuffer.rbuffer_new(capacity), rbuffer.rbuffer_free)
|
||||
-- fill the internal buffer with the character '0' to simplify inspecting
|
||||
ffi.C.memset(rbuf.start_ptr, string.byte('0'), capacity)
|
||||
end)
|
||||
end))
|
||||
|
||||
describe('RBUFFER_UNTIL_FULL', function()
|
||||
local chunks
|
||||
@ -58,59 +59,44 @@ describe('rbuffer functions', function()
|
||||
end)
|
||||
|
||||
describe('with partially empty buffer in one contiguous chunk', function()
|
||||
before_each(function()
|
||||
write('string')
|
||||
end)
|
||||
|
||||
itp('is called once with the empty chunk', function()
|
||||
write('string')
|
||||
collect_write_chunks()
|
||||
eq({'0000000000'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with filled buffer in one contiguous chunk', function()
|
||||
before_each(function()
|
||||
write('abcdefghijklmnopq')
|
||||
end)
|
||||
|
||||
itp('is not called', function()
|
||||
write('abcdefghijklmnopq')
|
||||
collect_write_chunks()
|
||||
eq({}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with buffer partially empty in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('is called twice with each filled chunk', function()
|
||||
write('1234567890')
|
||||
read(8)
|
||||
end)
|
||||
|
||||
itp('is called twice with each filled chunk', function()
|
||||
collect_write_chunks()
|
||||
eq({'000000', '12345678'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with buffer empty in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('is called twice with each filled chunk', function()
|
||||
write('12345678')
|
||||
read(8)
|
||||
end)
|
||||
|
||||
itp('is called twice with each filled chunk', function()
|
||||
collect_write_chunks()
|
||||
eq({'00000000', '12345678'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with buffer filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('is not called', function()
|
||||
write('12345678')
|
||||
read(8)
|
||||
write('abcdefghijklmnopq')
|
||||
end)
|
||||
|
||||
itp('is not called', function()
|
||||
collect_write_chunks()
|
||||
eq({}, chunks)
|
||||
end)
|
||||
@ -138,48 +124,36 @@ describe('rbuffer functions', function()
|
||||
end)
|
||||
|
||||
describe('with partially filled buffer in one contiguous chunk', function()
|
||||
before_each(function()
|
||||
write('string')
|
||||
end)
|
||||
|
||||
itp('is called once with the filled chunk', function()
|
||||
write('string')
|
||||
collect_read_chunks()
|
||||
eq({'string'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with filled buffer in one contiguous chunk', function()
|
||||
before_each(function()
|
||||
write('abcdefghijklmnopq')
|
||||
end)
|
||||
|
||||
itp('is called once with the filled chunk', function()
|
||||
write('abcdefghijklmnopq')
|
||||
collect_read_chunks()
|
||||
eq({'abcdefghijklmnop'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with buffer partially filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('is called twice with each filled chunk', function()
|
||||
write('1234567890')
|
||||
read(10)
|
||||
write('long string')
|
||||
end)
|
||||
|
||||
itp('is called twice with each filled chunk', function()
|
||||
collect_read_chunks()
|
||||
eq({'long s', 'tring'}, chunks)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('with buffer filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('is called twice with each filled chunk', function()
|
||||
write('12345678')
|
||||
read(8)
|
||||
write('abcdefghijklmnopq')
|
||||
end)
|
||||
|
||||
itp('is called twice with each filled chunk', function()
|
||||
collect_read_chunks()
|
||||
eq({'abcdefgh', 'ijklmnop'}, chunks)
|
||||
end)
|
||||
@ -206,13 +180,10 @@ describe('rbuffer functions', function()
|
||||
end)
|
||||
|
||||
describe('with buffer filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('collects each character and index', function()
|
||||
write('1234567890')
|
||||
read(10)
|
||||
write('long string')
|
||||
end)
|
||||
|
||||
itp('collects each character and index', function()
|
||||
collect_chars()
|
||||
eq({{'l', 0}, {'o', 1}, {'n', 2}, {'g', 3}, {' ', 4}, {'s', 5},
|
||||
{'t', 6}, {'r', 7}, {'i', 8}, {'n', 9}, {'g', 10}}, chars)
|
||||
@ -240,13 +211,10 @@ describe('rbuffer functions', function()
|
||||
end)
|
||||
|
||||
describe('with buffer filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('collects each character and index', function()
|
||||
write('1234567890')
|
||||
read(10)
|
||||
write('long string')
|
||||
end)
|
||||
|
||||
itp('collects each character and index', function()
|
||||
collect_chars()
|
||||
eq({{'g', 10}, {'n', 9}, {'i', 8}, {'r', 7}, {'t', 6}, {'s', 5},
|
||||
{' ', 4}, {'g', 3}, {'n', 2}, {'o', 1}, {'l', 0}}, chars)
|
||||
@ -265,13 +233,10 @@ describe('rbuffer functions', function()
|
||||
end
|
||||
|
||||
describe('with buffer filled in two contiguous chunks', function()
|
||||
before_each(function()
|
||||
itp('compares the common longest sequence', function()
|
||||
write('1234567890')
|
||||
read(10)
|
||||
write('long string')
|
||||
end)
|
||||
|
||||
itp('compares the common longest sequence', function()
|
||||
eq(0, cmp('long string'))
|
||||
eq(0, cmp('long strin'))
|
||||
eq(-1, cmp('long striM'))
|
||||
|
@ -1,20 +1,25 @@
|
||||
local lfs = require 'lfs'
|
||||
local helpers = require 'test.unit.helpers'
|
||||
local lfs = require('lfs')
|
||||
local helpers = require('test.unit.helpers')(after_each)
|
||||
local itp = helpers.gen_itp(it)
|
||||
|
||||
local os = helpers.cimport './src/nvim/os/os.h'
|
||||
local tempfile = helpers.cimport './src/nvim/fileio.h'
|
||||
local eq = helpers.eq
|
||||
local neq = helpers.neq
|
||||
local cimport = helpers.cimport
|
||||
local deferred_call = helpers.deferred_call
|
||||
local separate_cleanup = helpers.separate_cleanup
|
||||
|
||||
local lib = cimport('./src/nvim/os/os.h', './src/nvim/fileio.h')
|
||||
|
||||
describe('tempfile related functions', function()
|
||||
before_each(function()
|
||||
tempfile.vim_deltempdir()
|
||||
end)
|
||||
after_each(function()
|
||||
tempfile.vim_deltempdir()
|
||||
before_each(deferred_call(function()
|
||||
lib.vim_deltempdir()
|
||||
end))
|
||||
separate_cleanup(function()
|
||||
lib.vim_deltempdir()
|
||||
end)
|
||||
|
||||
local vim_gettempdir = function()
|
||||
return helpers.ffi.string(tempfile.vim_gettempdir())
|
||||
return helpers.ffi.string(lib.vim_gettempdir())
|
||||
end
|
||||
|
||||
describe('vim_gettempdir', function()
|
||||
@ -23,7 +28,7 @@ describe('tempfile related functions', function()
|
||||
assert.True(dir ~= nil and dir:len() > 0)
|
||||
-- os_file_is_writable returns 2 for a directory which we have rights
|
||||
-- to write into.
|
||||
assert.equals(os.os_file_is_writable(helpers.to_cstr(dir)), 2)
|
||||
eq(lib.os_file_is_writable(helpers.to_cstr(dir)), 2)
|
||||
for entry in lfs.dir(dir) do
|
||||
assert.True(entry == '.' or entry == '..')
|
||||
end
|
||||
@ -32,25 +37,25 @@ describe('tempfile related functions', function()
|
||||
itp('returns the same directory on each call', function()
|
||||
local dir1 = vim_gettempdir()
|
||||
local dir2 = vim_gettempdir()
|
||||
assert.equals(dir1, dir2)
|
||||
eq(dir1, dir2)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('vim_tempname', function()
|
||||
local vim_tempname = function()
|
||||
return helpers.ffi.string(tempfile.vim_tempname())
|
||||
return helpers.ffi.string(lib.vim_tempname())
|
||||
end
|
||||
|
||||
itp('generate name of non-existing file', function()
|
||||
local file = vim_tempname()
|
||||
assert.truthy(file)
|
||||
assert.False(os.os_path_exists(file))
|
||||
assert.False(lib.os_path_exists(file))
|
||||
end)
|
||||
|
||||
itp('generate different names on each call', function()
|
||||
local fst = vim_tempname()
|
||||
local snd = vim_tempname()
|
||||
assert.not_equals(fst, snd)
|
||||
neq(fst, snd)
|
||||
end)
|
||||
|
||||
itp('generate file name in Neovim own temp directory', function()
|
||||
|
Loading…
Reference in New Issue
Block a user