aboutsummaryrefslogtreecommitdiff
path: root/test/unit
diff options
context:
space:
mode:
Diffstat (limited to 'test/unit')
-rw-r--r--test/unit/api/helpers.lua156
-rw-r--r--test/unit/api/private_helpers_spec.lua88
-rw-r--r--test/unit/buffer_spec.lua310
-rw-r--r--test/unit/eval/encode_spec.lua34
-rw-r--r--test/unit/eval/helpers.lua165
-rw-r--r--test/unit/helpers.lua18
-rw-r--r--test/unit/os/fileio_spec.lua365
-rw-r--r--test/unit/os/fs_spec.lua278
-rw-r--r--test/unit/os/shell_spec.lua4
-rw-r--r--test/unit/strings_spec.lua32
-rw-r--r--test/unit/tempfile_spec.lua2
11 files changed, 1305 insertions, 147 deletions
diff --git a/test/unit/api/helpers.lua b/test/unit/api/helpers.lua
new file mode 100644
index 0000000000..883e1c6c19
--- /dev/null
+++ b/test/unit/api/helpers.lua
@@ -0,0 +1,156 @@
+local helpers = require('test.unit.helpers')
+local eval_helpers = require('test.unit.eval.helpers')
+
+local cimport = helpers.cimport
+local to_cstr = helpers.to_cstr
+local ffi = helpers.ffi
+
+local list_type = eval_helpers.list_type
+local dict_type = eval_helpers.dict_type
+local func_type = eval_helpers.func_type
+local nil_value = eval_helpers.nil_value
+local int_type = eval_helpers.int_type
+local flt_type = eval_helpers.flt_type
+local type_key = eval_helpers.type_key
+
+local api = cimport('./src/nvim/api/private/defs.h',
+ './src/nvim/api/private/helpers.h',
+ './src/nvim/memory.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)
+ return ((obj2lua_tab[tonumber(obj['type'])] or function(obj_inner)
+ assert(false, 'Converting ' .. tostring(tonumber(obj_inner['type'])) .. ' is not implementing yet')
+ end)(obj))
+end
+
+local obj = function(typ, data)
+ return ffi.gc(ffi.new('Object', {['type']=typ, data=data}),
+ api.api_free_object)
+end
+
+local lua2obj
+
+local lua2obj_type_tab = {
+ [int_type] = function(l)
+ return obj(api.kObjectTypeInteger, {integer=l.value})
+ end,
+ [flt_type] = function(l)
+ return obj(api.kObjectTypeFloat, {floating=l})
+ end,
+ [list_type] = function(l)
+ local len = #l
+ local arr = obj(api.kObjectTypeArray, {array={
+ size=len,
+ capacity=len,
+ items=ffi.cast('Object *', api.xmalloc(len * ffi.sizeof('Object'))),
+ }})
+ for i = 1, len do
+ arr.data.array.items[i - 1] = ffi.gc(lua2obj(l[i]), nil)
+ end
+ return arr
+ end,
+ [dict_type] = function(l)
+ local kvs = {}
+ for k, v in pairs(l) do
+ if type(k) == 'string' then
+ kvs[#kvs + 1] = {k, v}
+ end
+ end
+ local len = #kvs
+ local dct = obj(api.kObjectTypeDictionary, {dictionary={
+ size=len,
+ capacity=len,
+ items=ffi.cast('KeyValuePair *',
+ api.xmalloc(len * ffi.sizeof('KeyValuePair'))),
+ }})
+ for i = 1, len do
+ local key, val = table.unpack(kvs[i])
+ dct.data.dictionary.items[i - 1] = ffi.new(
+ 'KeyValuePair', {key=ffi.gc(lua2obj(key), nil).data.string,
+ value=ffi.gc(lua2obj(val), nil)})
+ end
+ return dct
+ end,
+}
+
+lua2obj = function(l)
+ if type(l) == 'table' then
+ if l[type_key] then
+ return lua2obj_type_tab[l[type_key]](l)
+ else
+ if l[1] then
+ return lua2obj_type_tab[list_type](l)
+ else
+ return lua2obj_type_tab[dict_type](l)
+ end
+ end
+ elseif type(l) == 'number' then
+ return lua2obj_type_tab[flt_type](l)
+ elseif type(l) == 'boolean' then
+ return obj(api.kObjectTypeBoolean, {boolean=l})
+ elseif type(l) == 'string' then
+ return obj(api.kObjectTypeString, {string={
+ size=#l,
+ data=api.xmemdupz(to_cstr(l), #l),
+ }})
+ elseif l == nil or l == nil_value then
+ return obj(api.kObjectTypeNil, {integer=0})
+ end
+end
+
+return {
+ list_type=list_type,
+ dict_type=dict_type,
+ func_type=func_type,
+ int_type=int_type,
+ flt_type=flt_type,
+
+ nil_value=nil_value,
+
+ type_key=type_key,
+
+ obj2lua=obj2lua,
+ lua2obj=lua2obj,
+}
diff --git a/test/unit/api/private_helpers_spec.lua b/test/unit/api/private_helpers_spec.lua
new file mode 100644
index 0000000000..1d7c03787b
--- /dev/null
+++ b/test/unit/api/private_helpers_spec.lua
@@ -0,0 +1,88 @@
+local helpers = require('test.unit.helpers')
+local eval_helpers = require('test.unit.eval.helpers')
+local api_helpers = require('test.unit.api.helpers')
+
+local cimport = helpers.cimport
+local NULL = helpers.NULL
+local eq = helpers.eq
+
+local lua2typvalt = eval_helpers.lua2typvalt
+local typvalt = eval_helpers.typvalt
+
+local nil_value = api_helpers.nil_value
+local list_type = api_helpers.list_type
+local int_type = api_helpers.int_type
+local type_key = api_helpers.type_key
+local obj2lua = api_helpers.obj2lua
+
+local api = cimport('./src/nvim/api/private/helpers.h')
+
+describe('vim_to_object', function()
+ local vim_to_object = function(l)
+ return obj2lua(api.vim_to_object(lua2typvalt(l)))
+ end
+
+ local different_output_test = function(name, input, output)
+ it(name, function()
+ eq(output, vim_to_object(input))
+ end)
+ end
+
+ local simple_test = function(name, l)
+ different_output_test(name, l, l)
+ end
+
+ simple_test('converts true', true)
+ simple_test('converts false', false)
+ simple_test('converts nil', nil_value)
+ simple_test('converts 1', 1)
+ simple_test('converts -1.5', -1.5)
+ simple_test('converts empty string', '')
+ simple_test('converts non-empty string', 'foobar')
+ simple_test('converts integer 10', {[type_key]=int_type, value=10})
+ simple_test('converts empty dictionary', {})
+ simple_test('converts dictionary with scalar values', {test=10, test2=true, test3='test'})
+ simple_test('converts dictionary with containers inside', {test={}, test2={1, 2}})
+ simple_test('converts empty list', {[type_key]=list_type})
+ simple_test('converts list with scalar values', {1, 2, 'test', 'foo'})
+ simple_test('converts list with containers inside', {{}, {test={}, test3={test4=true}}})
+
+ local dct = {}
+ dct.dct = dct
+ different_output_test('outputs nil for nested dictionaries (1 level)', dct, {dct=nil_value})
+
+ local lst = {}
+ lst[1] = lst
+ different_output_test('outputs nil for nested lists (1 level)', lst, {nil_value})
+
+ local dct2 = {test=true, dict=nil_value}
+ dct2.dct = {dct2}
+ different_output_test('outputs nil for nested dictionaries (2 level, in list)',
+ dct2, {dct={nil_value}, test=true, dict=nil_value})
+
+ local dct3 = {test=true, dict=nil_value}
+ dct3.dct = {dctin=dct3}
+ different_output_test('outputs nil for nested dictionaries (2 level, in dict)',
+ dct3, {dct={dctin=nil_value}, test=true, dict=nil_value})
+
+ local lst2 = {}
+ lst2[1] = {lst2}
+ different_output_test('outputs nil for nested lists (2 level, in list)', lst2, {{nil_value}})
+
+ local lst3 = {nil, true, false, 'ttest'}
+ lst3[1] = {lst=lst3}
+ different_output_test('outputs nil for nested lists (2 level, in dict)',
+ lst3, {{lst=nil_value}, true, false, 'ttest'})
+
+ it('outputs empty list for NULL list', function()
+ local tt = typvalt('VAR_LIST', {v_list=NULL})
+ eq(nil, tt.vval.v_list)
+ eq({[type_key]=list_type}, obj2lua(api.vim_to_object(tt)))
+ end)
+
+ it('outputs empty dict for NULL dict', function()
+ local tt = typvalt('VAR_DICT', {v_dict=NULL})
+ eq(nil, tt.vval.v_dict)
+ eq({}, obj2lua(api.vim_to_object(tt)))
+ end)
+end)
diff --git a/test/unit/buffer_spec.lua b/test/unit/buffer_spec.lua
index b7f82064d7..317c9be6e7 100644
--- a/test/unit/buffer_spec.lua
+++ b/test/unit/buffer_spec.lua
@@ -1,10 +1,9 @@
-local assert = require("luassert")
local helpers = require("test.unit.helpers")
local to_cstr = helpers.to_cstr
+local get_str = helpers.ffi.string
local eq = helpers.eq
-local neq = helpers.neq
local NULL = helpers.NULL
local globals = helpers.cimport("./src/nvim/globals.h")
@@ -211,93 +210,246 @@ describe('buffer functions', function()
end)
describe('build_stl_str_hl', function()
+ local buffer_byte_size = 100
+ local STL_MAX_ITEM = 80
+ local output_buffer = ''
+
+ -- This function builds the statusline
+ --
+ -- @param arg Optional arguments are:
+ -- .pat The statusline format string
+ -- .fillchar The fill character used in the statusline
+ -- .maximum_cell_count The number of cells available in the statusline
+ local function build_stl_str_hl(arg)
+ output_buffer = to_cstr(string.rep(" ", buffer_byte_size))
+
+ local pat = arg.pat or ''
+ local fillchar = arg.fillchar or (' '):byte()
+ local maximum_cell_count = arg.maximum_cell_count or buffer_byte_size
- local output_buffer = to_cstr(string.rep(" ", 100))
-
- local build_stl_str_hl = function(pat)
return buffer.build_stl_str_hl(globals.curwin,
output_buffer,
- 100,
+ buffer_byte_size,
to_cstr(pat),
false,
- 32,
- 80,
+ fillchar,
+ maximum_cell_count,
NULL,
NULL)
end
- it('should copy plain text', function()
- local width = build_stl_str_hl("this is a test")
-
- eq(14, width)
- eq("this is a test", helpers.ffi.string(output_buffer, width))
-
- end)
-
- it('should print no file name', function()
- local width = build_stl_str_hl("%f")
-
- eq(9, width)
- eq("[No Name]", helpers.ffi.string(output_buffer, width))
-
- end)
-
- it('should print the relative file name', function()
- buffer.setfname(globals.curbuf, to_cstr("Makefile"), NULL, 1)
- local width = build_stl_str_hl("%f")
-
- eq(8, width)
- eq("Makefile", helpers.ffi.string(output_buffer, width))
-
- end)
-
- it('should print the full file name', function()
- buffer.setfname(globals.curbuf, to_cstr("Makefile"), NULL, 1)
-
- local width = build_stl_str_hl("%F")
-
- assert.is_true(8 < width)
- neq(NULL, string.find(helpers.ffi.string(output_buffer, width), "Makefile"))
-
- end)
-
- it('should print the tail file name', function()
- buffer.setfname(globals.curbuf, to_cstr("src/nvim/buffer.c"), NULL, 1)
-
- local width = build_stl_str_hl("%t")
-
- eq(8, width)
- eq("buffer.c", helpers.ffi.string(output_buffer, width))
-
- end)
-
- it('should print the buffer number', function()
- buffer.setfname(globals.curbuf, to_cstr("src/nvim/buffer.c"), NULL, 1)
-
- local width = build_stl_str_hl("%n")
-
- eq(1, width)
- eq("1", helpers.ffi.string(output_buffer, width))
- end)
-
- it('should print the current line number in the buffer', function()
- buffer.setfname(globals.curbuf, to_cstr("test/unit/buffer_spec.lua"), NULL, 1)
-
- local width = build_stl_str_hl("%l")
-
- eq(1, width)
- eq("0", helpers.ffi.string(output_buffer, width))
-
- end)
-
- it('should print the number of lines in the buffer', function()
- buffer.setfname(globals.curbuf, to_cstr("test/unit/buffer_spec.lua"), NULL, 1)
-
- local width = build_stl_str_hl("%L")
+ -- Use this function to simplify testing the comparison between
+ -- the format string and the resulting statusline.
+ --
+ -- @param description The description of what the test should be doing
+ -- @param statusline_cell_count The number of cells available in the statusline
+ -- @param input_stl The format string for the statusline
+ -- @param expected_stl The expected result string for the statusline
+ --
+ -- @param arg Options can be placed in an optional dictionary as the last parameter
+ -- .expected_cell_count The expected number of cells build_stl_str_hl will return
+ -- .expected_byte_length The expected byte length of the string
+ -- .file_name The name of the file to be tested (useful in %f type tests)
+ -- .fillchar The character that will be used to fill any 'extra' space in the stl
+ local function statusline_test (description,
+ statusline_cell_count,
+ input_stl,
+ expected_stl,
+ arg)
+
+ -- arg is the optional parameter
+ -- so we either fill in option with arg or an empty dictionary
+ local option = arg or {}
+
+ local fillchar = option.fillchar or (' '):byte()
+ local expected_cell_count = option.expected_cell_count or statusline_cell_count
+ local expected_byte_length = option.expected_byte_length or expected_cell_count
+
+ it(description, function()
+ if option.file_name then
+ buffer.setfname(globals.curbuf, to_cstr(option.file_name), NULL, 1)
+ else
+ buffer.setfname(globals.curbuf, nil, NULL, 1)
+ end
+
+ local result_cell_count = build_stl_str_hl{pat=input_stl,
+ maximum_cell_count=statusline_cell_count,
+ fillchar=fillchar}
+
+ eq(expected_stl, get_str(output_buffer, expected_byte_length))
+ eq(expected_cell_count, result_cell_count)
+ end)
+ end
- eq(1, width)
- eq("1", helpers.ffi.string(output_buffer, width))
+ -- file name testing
+ statusline_test('should print no file name', 10,
+ '%f', '[No Name]',
+ {expected_cell_count=9})
+ statusline_test('should print the relative file name', 30,
+ '%f', 'test/unit/buffer_spec.lua',
+ {file_name='test/unit/buffer_spec.lua', expected_cell_count=25})
+ statusline_test('should print the full file name', 40,
+ '%F', '/test/unit/buffer_spec.lua',
+ {file_name='/test/unit/buffer_spec.lua', expected_cell_count=26})
+
+ -- fillchar testing
+ statusline_test('should handle `!` as a fillchar', 10,
+ 'abcde%=', 'abcde!!!!!',
+ {fillchar=('!'):byte()})
+ statusline_test('should handle `~` as a fillchar', 10,
+ '%=abcde', '~~~~~abcde',
+ {fillchar=('~'):byte()})
+ statusline_test('should put fillchar `!` in between text', 10,
+ 'abc%=def', 'abc!!!!def',
+ {fillchar=('!'):byte()})
+ statusline_test('should put fillchar `~` in between text', 10,
+ 'abc%=def', 'abc~~~~def',
+ {fillchar=('~'):byte()})
+ statusline_test('should print the tail file name', 80,
+ '%t', 'buffer_spec.lua',
+ {file_name='test/unit/buffer_spec.lua', expected_cell_count=15})
+
+ -- standard text testing
+ statusline_test('should copy plain text', 80,
+ 'this is a test', 'this is a test',
+ {expected_cell_count=14})
+
+ -- line number testing
+ statusline_test('should print the buffer number', 80,
+ '%n', '1',
+ {expected_cell_count=1})
+ statusline_test('should print the current line number in the buffer', 80,
+ '%l', '0',
+ {expected_cell_count=1})
+ statusline_test('should print the number of lines in the buffer', 80,
+ '%L', '1',
+ {expected_cell_count=1})
+
+ -- truncation testing
+ statusline_test('should truncate when standard text pattern is too long', 10,
+ '0123456789abcde', '<6789abcde')
+ statusline_test('should truncate when using =', 10,
+ 'abcdef%=ghijkl', 'abcdef<jkl')
+ statusline_test('should truncate centered text when using ==', 10,
+ 'abcde%=gone%=fghij', 'abcde<ghij')
+ statusline_test('should respect the `<` marker', 10,
+ 'abc%<defghijkl', 'abc<ghijkl')
+ statusline_test('should truncate at `<` with one `=`, test 1', 10,
+ 'abc%<def%=ghijklmno', 'abc<jklmno')
+ statusline_test('should truncate at `<` with one `=`, test 2', 10,
+ 'abcdef%=ghijkl%<mno', 'abcdefghi>')
+ statusline_test('should truncate at `<` with one `=`, test 3', 10,
+ 'abc%<def%=ghijklmno', 'abc<jklmno')
+ statusline_test('should truncate at `<` with one `=`, test 4', 10,
+ 'abc%<def%=ghij', 'abcdefghij')
+ statusline_test('should truncate at `<` with one `=`, test 4', 10,
+ 'abc%<def%=ghijk', 'abc<fghijk')
+
+ statusline_test('should truncate at `<` with many `=`, test 4', 10,
+ 'ab%<cdef%=g%=h%=ijk', 'ab<efghijk')
+
+ statusline_test('should truncate at the first `<`', 10,
+ 'abc%<def%<ghijklm', 'abc<hijklm')
+
+ -- alignment testing
+ statusline_test('should right align when using =', 20,
+ 'neo%=vim', 'neo vim')
+ statusline_test('should, when possible, center text when using %=text%=', 20,
+ 'abc%=neovim%=def', 'abc neovim def')
+ statusline_test('should handle uneven spacing in the buffer when using %=text%=', 20,
+ 'abc%=neo_vim%=def', 'abc neo_vim def')
+ statusline_test('should have equal spaces even with non-equal sides when using =', 20,
+ 'foobar%=test%=baz', 'foobar test baz')
+ statusline_test('should have equal spaces even with longer right side when using =', 20,
+ 'a%=test%=longtext', 'a test longtext')
+ statusline_test('should handle an empty left side when using ==', 20,
+ '%=test%=baz', ' test baz')
+ statusline_test('should handle an empty right side when using ==', 20,
+ 'foobar%=test%=', 'foobar test ')
+ statusline_test('should handle consecutive empty ==', 20,
+ '%=%=test%=', ' test ')
+ statusline_test('should handle an = alone', 20,
+ '%=', ' ')
+ statusline_test('should right align text when it is alone with =', 20,
+ '%=foo', ' foo')
+ statusline_test('should left align text when it is alone with =', 20,
+ 'foo%=', 'foo ')
+
+ statusline_test('should approximately center text when using %=text%=', 21,
+ 'abc%=neovim%=def', 'abc neovim def')
+ statusline_test('should completely fill the buffer when using %=text%=', 21,
+ 'abc%=neo_vim%=def', 'abc neo_vim def')
+ statusline_test('should have equal spaces even with non-equal sides when using =', 21,
+ 'foobar%=test%=baz', 'foobar test baz')
+ statusline_test('should have equal spaces even with longer right side when using =', 21,
+ 'a%=test%=longtext', 'a test longtext')
+ statusline_test('should handle an empty left side when using ==', 21,
+ '%=test%=baz', ' test baz')
+ statusline_test('should handle an empty right side when using ==', 21,
+ 'foobar%=test%=', 'foobar test ')
+
+ statusline_test('should quadrant the text when using 3 %=', 40,
+ 'abcd%=n%=eovim%=ef', 'abcd n eovim ef')
+ statusline_test('should work well with %t', 40,
+ '%t%=right_aligned', 'buffer_spec.lua right_aligned',
+ {file_name='test/unit/buffer_spec.lua'})
+ statusline_test('should work well with %t and regular text', 40,
+ 'l%=m_l %t m_r%=r', 'l m_l buffer_spec.lua m_r r',
+ {file_name='test/unit/buffer_spec.lua'})
+ statusline_test('should work well with %=, %t, %L, and %l', 40,
+ '%t %= %L %= %l', 'buffer_spec.lua 1 0',
+ {file_name='test/unit/buffer_spec.lua'})
+
+ statusline_test('should quadrant the text when using 3 %=', 41,
+ 'abcd%=n%=eovim%=ef', 'abcd n eovim ef')
+ statusline_test('should work well with %t', 41,
+ '%t%=right_aligned', 'buffer_spec.lua right_aligned',
+ {file_name='test/unit/buffer_spec.lua'})
+ statusline_test('should work well with %t and regular text', 41,
+ 'l%=m_l %t m_r%=r', 'l m_l buffer_spec.lua m_r r',
+ {file_name='test/unit/buffer_spec.lua'})
+ statusline_test('should work well with %=, %t, %L, and %l', 41,
+ '%t %= %L %= %l', 'buffer_spec.lua 1 0',
+ {file_name='test/unit/buffer_spec.lua'})
+
+ statusline_test('should work with 10 %=', 50,
+ 'aaaa%=b%=c%=d%=e%=fg%=hi%=jk%=lmnop%=qrstuv%=wxyz',
+ 'aaaa b c d e fg hi jk lmnop qrstuv wxyz')
+
+ -- maximum stl item testing
+ statusline_test('should handle a much larger amount of = than buffer locations', 20,
+ ('%='):rep(STL_MAX_ITEM - 1),
+ ' ') -- Should be fine, because within limit
+ statusline_test('should handle a much larger amount of = than stl max item', 20,
+ ('%='):rep(STL_MAX_ITEM + 1),
+ ' E541') -- Should show the VIM error
+ statusline_test('should handle many extra characters', 20,
+ 'a' .. ('a'):rep(STL_MAX_ITEM * 4),
+ '<aaaaaaaaaaaaaaaaaaa') -- Does not show the error because there are no items
+ statusline_test('should handle almost maximum of characters and flags', 20,
+ 'a' .. ('%=a'):rep(STL_MAX_ITEM - 1),
+ 'a<aaaaaaaaaaaaaaaaaa') -- Should not show the VIM error
+ statusline_test('should handle many extra characters and flags', 20,
+ 'a' .. ('%=a'):rep(STL_MAX_ITEM),
+ 'a<aaaaaaaaaaaaa E541') -- Should show the VIM error
+ statusline_test('should handle many extra characters and flags', 20,
+ 'a' .. ('%=a'):rep(STL_MAX_ITEM * 2),
+ 'a<aaaaaaaaaaaaa E541') -- Should show the VIM error
+ statusline_test('should handle many extra characters and flags with truncation', 20,
+ 'aaa%<' .. ('%=a'):rep(STL_MAX_ITEM),
+ 'aaa<aaaaaaaaaaa E541') -- Should show the VIM error
+ statusline_test('should handle many characters and flags before and after truncation', 20,
+ 'a%=a%=a%<' .. ('%=a'):rep(STL_MAX_ITEM),
+ 'aaa<aaaaaaaaaaa E541') -- Should show the VIM error
+
+
+ -- multi-byte testing
+ statusline_test('should handle multibyte characters', 10,
+ 'Ĉ%=x', 'Ĉ x',
+ {expected_byte_length=11})
+ statusline_test('should handle multibyte characters and different fillchars', 10,
+ 'Ą%=mid%=end', 'Ą@mid@@end',
+ {fillchar=('@'):byte(), expected_byte_length=11})
- end)
end)
end)
diff --git a/test/unit/eval/encode_spec.lua b/test/unit/eval/encode_spec.lua
index f151a191fb..98fc8305e0 100644
--- a/test/unit/eval/encode_spec.lua
+++ b/test/unit/eval/encode_spec.lua
@@ -27,74 +27,74 @@ describe('encode_list_write()', function()
it('writes ASCII string literal with printable characters', function()
local l = list()
eq(0, encode_list_write(l, 'abc'))
- eq({[type_key]=list_type, 'abc'}, lst2tbl(l))
+ eq({'abc'}, lst2tbl(l))
end)
it('writes string starting with NL', function()
local l = list()
eq(0, encode_list_write(l, '\nabc'))
- eq({[type_key]=list_type, null_string, 'abc'}, lst2tbl(l))
+ eq({null_string, 'abc'}, lst2tbl(l))
end)
it('writes string starting with NL twice', function()
local l = list()
eq(0, encode_list_write(l, '\nabc'))
- eq({[type_key]=list_type, null_string, 'abc'}, lst2tbl(l))
+ eq({null_string, 'abc'}, lst2tbl(l))
eq(0, encode_list_write(l, '\nabc'))
- eq({[type_key]=list_type, null_string, 'abc', 'abc'}, lst2tbl(l))
+ eq({null_string, 'abc', 'abc'}, lst2tbl(l))
end)
it('writes string ending with NL', function()
local l = list()
eq(0, encode_list_write(l, 'abc\n'))
- eq({[type_key]=list_type, 'abc', null_string}, lst2tbl(l))
+ eq({'abc', null_string}, lst2tbl(l))
end)
it('writes string ending with NL twice', function()
local l = list()
eq(0, encode_list_write(l, 'abc\n'))
- eq({[type_key]=list_type, 'abc', null_string}, lst2tbl(l))
+ eq({'abc', null_string}, lst2tbl(l))
eq(0, encode_list_write(l, 'abc\n'))
- eq({[type_key]=list_type, 'abc', 'abc', null_string}, lst2tbl(l))
+ eq({'abc', 'abc', null_string}, lst2tbl(l))
end)
it('writes string starting, ending and containing NL twice', function()
local l = list()
eq(0, encode_list_write(l, '\na\nb\n'))
- eq({[type_key]=list_type, null_string, 'a', 'b', null_string}, lst2tbl(l))
+ eq({null_string, 'a', 'b', null_string}, lst2tbl(l))
eq(0, encode_list_write(l, '\na\nb\n'))
- eq({[type_key]=list_type, null_string, 'a', 'b', null_string, 'a', 'b', null_string}, lst2tbl(l))
+ eq({null_string, 'a', 'b', null_string, 'a', 'b', null_string}, lst2tbl(l))
end)
it('writes string starting, ending and containing NUL with NL between twice', function()
local l = list()
eq(0, encode_list_write(l, '\0\n\0\n\0'))
- eq({[type_key]=list_type, '\n', '\n', '\n'}, lst2tbl(l))
+ eq({'\n', '\n', '\n'}, lst2tbl(l))
eq(0, encode_list_write(l, '\0\n\0\n\0'))
- eq({[type_key]=list_type, '\n', '\n', '\n\n', '\n', '\n'}, lst2tbl(l))
+ eq({'\n', '\n', '\n\n', '\n', '\n'}, lst2tbl(l))
end)
it('writes string starting, ending and containing NL with NUL between twice', function()
local l = list()
eq(0, encode_list_write(l, '\n\0\n\0\n'))
- eq({[type_key]=list_type, null_string, '\n', '\n', null_string}, lst2tbl(l))
+ eq({null_string, '\n', '\n', null_string}, lst2tbl(l))
eq(0, encode_list_write(l, '\n\0\n\0\n'))
- eq({[type_key]=list_type, null_string, '\n', '\n', null_string, '\n', '\n', null_string}, lst2tbl(l))
+ eq({null_string, '\n', '\n', null_string, '\n', '\n', null_string}, lst2tbl(l))
end)
it('writes string containing a single NL twice', function()
local l = list()
eq(0, encode_list_write(l, '\n'))
- eq({[type_key]=list_type, null_string, null_string}, lst2tbl(l))
+ eq({null_string, null_string}, lst2tbl(l))
eq(0, encode_list_write(l, '\n'))
- eq({[type_key]=list_type, null_string, null_string, null_string}, lst2tbl(l))
+ eq({null_string, null_string, null_string}, lst2tbl(l))
end)
it('writes string containing a few NLs twice', function()
local l = list()
eq(0, encode_list_write(l, '\n\n\n'))
- eq({[type_key]=list_type, null_string, null_string, null_string, null_string}, lst2tbl(l))
+ eq({null_string, null_string, null_string, null_string}, lst2tbl(l))
eq(0, encode_list_write(l, '\n\n\n'))
- eq({[type_key]=list_type, null_string, null_string, null_string, null_string, null_string, null_string, null_string}, lst2tbl(l))
+ eq({null_string, null_string, null_string, null_string, null_string, null_string, null_string}, lst2tbl(l))
end)
end)
diff --git a/test/unit/eval/helpers.lua b/test/unit/eval/helpers.lua
index 2367f03e0d..45fbf8da5c 100644
--- a/test/unit/eval/helpers.lua
+++ b/test/unit/eval/helpers.lua
@@ -11,6 +11,12 @@ local null_string = {[true]='NULL string'}
local null_list = {[true]='NULL list'}
local type_key = {[true]='type key'}
local list_type = {[true]='list type'}
+local dict_type = {[true]='dict type'}
+local func_type = {[true]='func type'}
+local int_type = {[true]='int type'}
+local flt_type = {[true]='flt type'}
+
+local nil_value = {[true]='nil'}
local function list(...)
local ret = ffi.gc(eval.list_alloc(), eval.list_unref)
@@ -37,7 +43,53 @@ local function list(...)
return ret
end
-local lst2tbl = function(l)
+local special_tab = {
+ [eval.kSpecialVarFalse] = false,
+ [eval.kSpecialVarNull] = nil_value,
+ [eval.kSpecialVarTrue] = true,
+}
+
+local lst2tbl
+local dct2tbl
+
+local typvalt2lua_tab
+
+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)
+ return lst2tbl(t.vval.v_list)
+ end,
+ [tonumber(eval.VAR_DICT)] = function(t)
+ return dct2tbl(t.vval.v_dict)
+ end,
+ [tonumber(eval.VAR_FUNC)] = function(t)
+ return {[type_key]=func_type, value=typvalt2lua_tab[eval.VAR_STRING](t)}
+ end,
+}
+
+local typvalt2lua = function(t)
+ 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))
+end
+
+lst2tbl = function(l)
local ret = {[type_key]=list_type}
if l == nil then
return ret
@@ -45,28 +97,119 @@ local lst2tbl = function(l)
local li = l.lv_first
-- (listitem_T *) NULL is equal to nil, but yet it is not false.
while li ~= nil do
- local typ = li.li_tv.v_type
- if typ == eval.VAR_STRING then
- local str = li.li_tv.vval.v_string
- if str == nil then
- ret[#ret + 1] = null_string
- else
- ret[#ret + 1] = ffi.string(str)
+ ret[#ret + 1] = typvalt2lua(li.li_tv)
+ li = li.li_next
+ end
+ if ret[1] then
+ ret[type_key] = nil
+ end
+ return ret
+end
+
+dct2tbl = function(d)
+ local ret = {d=d}
+ assert(false, 'Converting dictionaries is not implemented yet')
+ return ret
+end
+
+local lua2typvalt
+
+local typvalt = function(typ, vval)
+ if type(typ) == 'string' then
+ typ = eval[typ]
+ end
+ return ffi.gc(ffi.new('typval_T', {v_type=typ, vval=vval}), eval.clear_tv)
+end
+
+local lua2typvalt_type_tab = {
+ [int_type] = function(l, _)
+ return typvalt(eval.VAR_NUMBER, {v_number=l.value})
+ end,
+ [flt_type] = function(l, processed)
+ return lua2typvalt(l.value, processed)
+ end,
+ [list_type] = function(l, processed)
+ if processed[l] then
+ processed[l].lv_refcount = processed[l].lv_refcount + 1
+ return typvalt(eval.VAR_LIST, {v_list=processed[l]})
+ end
+ local lst = eval.list_alloc()
+ lst.lv_refcount = 1
+ processed[l] = lst
+ local ret = typvalt(eval.VAR_LIST, {v_list=lst})
+ for i = 1, #l do
+ local item_tv = ffi.gc(lua2typvalt(l[i], processed), nil)
+ eval.list_append_tv(lst, item_tv)
+ eval.clear_tv(item_tv)
+ end
+ return ret
+ end,
+ [dict_type] = function(l, processed)
+ if processed[l] then
+ processed[l].dv_refcount = processed[l].dv_refcount + 1
+ return typvalt(eval.VAR_DICT, {v_dict=processed[l]})
+ end
+ local dct = eval.dict_alloc()
+ dct.dv_refcount = 1
+ processed[l] = dct
+ local ret = typvalt(eval.VAR_DICT, {v_dict=dct})
+ for k, v in pairs(l) do
+ if type(k) == 'string' then
+ local di = eval.dictitem_alloc(to_cstr(k))
+ local val_tv = ffi.gc(lua2typvalt(v, processed), nil)
+ eval.copy_tv(val_tv, di.di_tv)
+ eval.clear_tv(val_tv)
+ eval.dict_add(dct, di)
end
+ end
+ return ret
+ end,
+}
+
+lua2typvalt = function(l, processed)
+ processed = processed or {}
+ if l == nil or l == nil_value then
+ return typvalt(eval.VAR_SPECIAL, {v_special=eval.kSpecialVarNull})
+ elseif type(l) == 'table' then
+ if l[type_key] then
+ return lua2typvalt_type_tab[l[type_key]](l, processed)
else
- assert(false, 'Not implemented yet')
+ if l[1] then
+ return lua2typvalt_type_tab[list_type](l, processed)
+ else
+ return lua2typvalt_type_tab[dict_type](l, processed)
+ end
end
- li = li.li_next
+ elseif type(l) == 'number' then
+ return typvalt(eval.VAR_FLOAT, {v_float=l})
+ elseif type(l) == 'boolean' then
+ return typvalt(eval.VAR_SPECIAL, {
+ v_special=(l and eval.kSpecialVarTrue or eval.kSpecialVarFalse)
+ })
+ elseif type(l) == 'string' then
+ return typvalt(eval.VAR_STRING, {v_string=eval.xmemdupz(to_cstr(l), #l)})
end
- return ret
end
return {
null_string=null_string,
null_list=null_list,
list_type=list_type,
+ dict_type=dict_type,
+ func_type=func_type,
+ int_type=int_type,
+ flt_type=flt_type,
+
+ nil_value=nil_value,
+
type_key=type_key,
list=list,
lst2tbl=lst2tbl,
+ dct2tbl=dct2tbl,
+
+ lua2typvalt=lua2typvalt,
+ typvalt2lua=typvalt2lua,
+
+ typvalt=typvalt,
}
diff --git a/test/unit/helpers.lua b/test/unit/helpers.lua
index 426ae2d9e0..91da459393 100644
--- a/test/unit/helpers.lua
+++ b/test/unit/helpers.lua
@@ -1,9 +1,13 @@
-local assert = require('luassert')
local ffi = require('ffi')
local formatc = require('test.unit.formatc')
local Set = require('test.unit.set')
local Preprocess = require('test.unit.preprocess')
local Paths = require('test.config.paths')
+local global_helpers = require('test.helpers')
+
+local neq = global_helpers.neq
+local eq = global_helpers.eq
+local ok = global_helpers.ok
-- add some standard header locations
for _, p in ipairs(Paths.include_paths) do
@@ -31,7 +35,8 @@ local function filter_complex_blocks(body)
if not (string.find(line, "(^)", 1, true) ~= nil
or string.find(line, "_ISwupper", 1, true)
or string.find(line, "msgpack_zone_push_finalizer")
- or string.find(line, "msgpack_unpacker_reserve_buffer")) then
+ or string.find(line, "msgpack_unpacker_reserve_buffer")
+ or string.find(line, "inline _Bool")) then
result[#result + 1] = line
end
end
@@ -153,12 +158,9 @@ return {
cimport = cimport,
cppimport = cppimport,
internalize = internalize,
- eq = function(expected, actual)
- return assert.are.same(expected, actual)
- end,
- neq = function(expected, actual)
- return assert.are_not.same(expected, actual)
- end,
+ ok = ok,
+ eq = eq,
+ neq = neq,
ffi = ffi,
lib = libnvim,
cstr = cstr,
diff --git a/test/unit/os/fileio_spec.lua b/test/unit/os/fileio_spec.lua
new file mode 100644
index 0000000000..5358022422
--- /dev/null
+++ b/test/unit/os/fileio_spec.lua
@@ -0,0 +1,365 @@
+local lfs = require('lfs')
+
+local helpers = require('test.unit.helpers')
+
+local eq = helpers.eq
+local ffi = helpers.ffi
+local cimport = helpers.cimport
+
+local m = cimport('./src/nvim/os/fileio.h')
+
+local fcontents = ''
+for i = 0, 255 do
+ fcontents = fcontents .. (i == 0 and '\0' or ('%c'):format(i))
+end
+fcontents = fcontents:rep(16)
+
+local dir = 'Xtest-unit-file_spec.d'
+local file1 = dir .. '/file1.dat'
+local file2 = dir .. '/file2.dat'
+local linkf = dir .. '/file.lnk'
+local linkb = dir .. '/broken.lnk'
+local filec = dir .. '/created-file.dat'
+
+before_each(function()
+ lfs.mkdir(dir);
+
+ local f1 = io.open(file1, 'w')
+ f1:write(fcontents)
+ f1:close()
+
+ local f2 = io.open(file2, 'w')
+ f2:write(fcontents)
+ f2:close()
+
+ lfs.link('file1.dat', linkf, true)
+ lfs.link('broken.dat', linkb, true)
+end)
+
+after_each(function()
+ os.remove(file1)
+ os.remove(file2)
+ os.remove(linkf)
+ os.remove(linkb)
+ os.remove(filec)
+ lfs.rmdir(dir)
+end)
+
+local function file_open(fname, flags, mode)
+ local ret2 = ffi.new('FileDescriptor')
+ local ret1 = m.file_open(ret2, fname, flags, mode)
+ return ret1, ret2
+end
+
+local function file_open_new(fname, flags, mode)
+ local ret1 = ffi.new('int[?]', 1, {0})
+ local ret2 = ffi.gc(m.file_open_new(ret1, fname, flags, mode), nil)
+ return ret1[0], ret2
+end
+
+local function file_write(fp, buf)
+ return m.file_write(fp, buf, #buf)
+end
+
+local function file_read(fp, size)
+ local buf = nil
+ if size == nil then
+ size = 0
+ else
+ -- For some reason if length of NUL-bytes-string is the same as `char[?]`
+ -- size luajit garbage collector crashes. But it does not do so in
+ -- os_read[v] tests in os/fs_spec.lua.
+ buf = ffi.new('char[?]', size + 1, ('\0'):rep(size))
+ end
+ local ret1 = m.file_read(fp, buf, size)
+ local ret2 = ''
+ if buf ~= nil then
+ ret2 = ffi.string(buf, size)
+ end
+ return ret1, ret2
+end
+
+local function file_fsync(fp)
+ return m.file_fsync(fp)
+end
+
+local function file_skip(fp, size)
+ return m.file_skip(fp, size)
+end
+
+describe('file_open', function()
+ it('can create a rwx------ file with kFileCreate', function()
+ local err, fp = file_open(filec, m.kFileCreate, 448)
+ eq(0, err)
+ local attrs = lfs.attributes(filec)
+ eq('rwx------', attrs.permissions)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can create a rw------- file with kFileCreate', function()
+ local err, fp = file_open(filec, m.kFileCreate, 384)
+ eq(0, err)
+ local attrs = lfs.attributes(filec)
+ eq('rw-------', attrs.permissions)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can create a rwx------ file with kFileCreateOnly', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 448)
+ eq(0, err)
+ local attrs = lfs.attributes(filec)
+ eq('rwx------', attrs.permissions)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can create a rw------- file with kFileCreateOnly', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 384)
+ eq(0, err)
+ local attrs = lfs.attributes(filec)
+ eq('rw-------', attrs.permissions)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('fails to open an existing file with kFileCreateOnly', function()
+ local err, _ = file_open(file1, m.kFileCreateOnly, 384)
+ eq(m.UV_EEXIST, err)
+ end)
+
+ it('fails to open an symlink with kFileNoSymlink', function()
+ local err, _ = file_open(linkf, m.kFileNoSymlink, 384)
+ -- err is UV_EMLINK in FreeBSD, but if I use `ok(err == m.UV_ELOOP or err ==
+ -- m.UV_EMLINK)`, then I loose the ability to see actual `err` value.
+ if err ~= m.UV_ELOOP then eq(m.UV_EMLINK, err) end
+ end)
+
+ it('can open an existing file write-only with kFileCreate', function()
+ local err, fp = file_open(file1, m.kFileCreate, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can open an existing file read-only with zero', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can open an existing file read-only with kFileReadOnly', function()
+ local err, fp = file_open(file1, m.kFileReadOnly, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can open an existing file read-only with kFileNoSymlink', function()
+ local err, fp = file_open(file1, m.kFileNoSymlink, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can truncate an existing file with kFileTruncate', function()
+ local err, fp = file_open(file1, m.kFileTruncate, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ eq(0, m.file_close(fp))
+ local attrs = lfs.attributes(file1)
+ eq(0, attrs.size)
+ end)
+
+ it('can open an existing file write-only with kFileWriteOnly', function()
+ local err, fp = file_open(file1, m.kFileWriteOnly, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ eq(0, m.file_close(fp))
+ local attrs = lfs.attributes(file1)
+ eq(4096, attrs.size)
+ end)
+
+ it('fails to create a file with just kFileWriteOnly', function()
+ local err, _ = file_open(filec, m.kFileWriteOnly, 384)
+ eq(m.UV_ENOENT, err)
+ local attrs = lfs.attributes(filec)
+ eq(nil, attrs)
+ end)
+
+ it('can truncate an existing file with kFileTruncate when opening a symlink',
+ function()
+ local err, fp = file_open(linkf, m.kFileTruncate, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ eq(0, m.file_close(fp))
+ local attrs = lfs.attributes(file1)
+ eq(0, attrs.size)
+ end)
+
+ it('fails to open a directory write-only', function()
+ local err, _ = file_open(dir, m.kFileWriteOnly, 384)
+ eq(m.UV_EISDIR, err)
+ end)
+
+ it('fails to open a broken symbolic link write-only', function()
+ local err, _ = file_open(linkb, m.kFileWriteOnly, 384)
+ eq(m.UV_ENOENT, err)
+ end)
+
+ it('fails to open a broken symbolic link read-only', function()
+ local err, _ = file_open(linkb, m.kFileReadOnly, 384)
+ eq(m.UV_ENOENT, err)
+ end)
+end)
+
+describe('file_open_new', function()
+ it('can open a file read-only', function()
+ local err, fp = file_open_new(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq(0, m.file_free(fp))
+ end)
+
+ it('fails to open an existing file with kFileCreateOnly', function()
+ local err, fp = file_open_new(file1, m.kFileCreateOnly, 384)
+ eq(m.UV_EEXIST, err)
+ eq(nil, fp)
+ end)
+end)
+
+-- file_close is called above, so it is not tested directly
+
+describe('file_fsync', function()
+ it('can flush writes to disk', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 384)
+ eq(0, file_fsync(fp))
+ eq(0, err)
+ eq(0, lfs.attributes(filec).size)
+ local wsize = file_write(fp, 'test')
+ eq(4, wsize)
+ eq(0, lfs.attributes(filec).size)
+ eq(0, file_fsync(fp))
+ eq(wsize, lfs.attributes(filec).size)
+ eq(0, m.file_close(fp))
+ end)
+end)
+
+describe('file_read', function()
+ it('can read small chunks of input until eof', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ local shift = 0
+ while shift < #fcontents do
+ local size = 3
+ local exp_err = size
+ local exp_s = fcontents:sub(shift + 1, shift + size)
+ if shift + size >= #fcontents then
+ exp_err = #fcontents - shift
+ exp_s = (fcontents:sub(shift + 1, shift + size)
+ .. (('\0'):rep(size - exp_err)))
+ end
+ eq({exp_err, exp_s}, {file_read(fp, size)})
+ shift = shift + size
+ end
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can read the whole file at once', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq({#fcontents, fcontents}, {file_read(fp, #fcontents)})
+ eq({0, ('\0'):rep(#fcontents)}, {file_read(fp, #fcontents)})
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can read more then 1024 bytes after reading a small chunk', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq({5, fcontents:sub(1, 5)}, {file_read(fp, 5)})
+ eq({#fcontents - 5, fcontents:sub(6) .. (('\0'):rep(5))},
+ {file_read(fp, #fcontents)})
+ eq(0, m.file_close(fp))
+ end)
+
+ it('can read file by 768-byte-chunks', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ local shift = 0
+ while shift < #fcontents do
+ local size = 768
+ local exp_err = size
+ local exp_s = fcontents:sub(shift + 1, shift + size)
+ if shift + size >= #fcontents then
+ exp_err = #fcontents - shift
+ exp_s = (fcontents:sub(shift + 1, shift + size)
+ .. (('\0'):rep(size - exp_err)))
+ end
+ eq({exp_err, exp_s}, {file_read(fp, size)})
+ shift = shift + size
+ end
+ eq(0, m.file_close(fp))
+ end)
+end)
+
+describe('file_write', function()
+ it('can write the whole file at once', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ local wr = file_write(fp, fcontents)
+ eq(#fcontents, wr)
+ eq(0, m.file_close(fp))
+ eq(wr, lfs.attributes(filec).size)
+ eq(fcontents, io.open(filec):read('*a'))
+ end)
+
+ it('can write the whole file by small chunks', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ local shift = 0
+ while shift < #fcontents do
+ local size = 3
+ local s = fcontents:sub(shift + 1, shift + size)
+ local wr = file_write(fp, s)
+ eq(wr, #s)
+ shift = shift + size
+ end
+ eq(0, m.file_close(fp))
+ eq(#fcontents, lfs.attributes(filec).size)
+ eq(fcontents, io.open(filec):read('*a'))
+ end)
+
+ it('can write the whole file by 768-byte-chunks', function()
+ local err, fp = file_open(filec, m.kFileCreateOnly, 384)
+ eq(0, err)
+ eq(true, fp.wr)
+ local shift = 0
+ while shift < #fcontents do
+ local size = 768
+ local s = fcontents:sub(shift + 1, shift + size)
+ local wr = file_write(fp, s)
+ eq(wr, #s)
+ shift = shift + size
+ end
+ eq(0, m.file_close(fp))
+ eq(#fcontents, lfs.attributes(filec).size)
+ eq(fcontents, io.open(filec):read('*a'))
+ end)
+end)
+
+describe('file_skip', function()
+ it('can skip 3 bytes', function()
+ local err, fp = file_open(file1, 0, 384)
+ eq(0, err)
+ eq(false, fp.wr)
+ eq(3, file_skip(fp, 3))
+ local rd, s = file_read(fp, 3)
+ eq(3, rd)
+ eq(fcontents:sub(4, 6), s)
+ eq(0, m.file_close(fp))
+ end)
+end)
diff --git a/test/unit/os/fs_spec.lua b/test/unit/os/fs_spec.lua
index 857a5001f1..7e7eddb6fc 100644
--- a/test/unit/os/fs_spec.lua
+++ b/test/unit/os/fs_spec.lua
@@ -6,6 +6,7 @@ local helpers = require('test.unit.helpers')
local cimport = helpers.cimport
local cppimport = helpers.cppimport
local internalize = helpers.internalize
+local ok = helpers.ok
local eq = helpers.eq
local neq = helpers.neq
local ffi = helpers.ffi
@@ -27,6 +28,12 @@ cppimport('sys/stat.h')
cppimport('fcntl.h')
cppimport('uv-errno.h')
+local s = ''
+for i = 0, 255 do
+ s = s .. (i == 0 and '\0' or ('%c'):format(i))
+end
+local fcontents = s:rep(16)
+
local buffer = ""
local directory = nil
local absolute_executable = nil
@@ -68,6 +75,8 @@ describe('fs function', function()
io.open('unit-test-directory/test_2.file', 'w').close()
lfs.link('test.file', 'unit-test-directory/test_link.file', true)
+
+ lfs.link('non_existing_file.file', 'unit-test-directory/test_broken_link.file', true)
-- Since the tests are executed, they are called by an executable. We use
-- that executable for several asserts.
absolute_executable = arg[0]
@@ -81,6 +90,7 @@ describe('fs function', function()
os.remove('unit-test-directory/test_2.file')
os.remove('unit-test-directory/test_link.file')
os.remove('unit-test-directory/test_hlink.file')
+ os.remove('unit-test-directory/test_broken_link.file')
lfs.rmdir('unit-test-directory')
end)
@@ -150,11 +160,11 @@ describe('fs function', function()
local function os_can_exe(name)
local buf = ffi.new('char *[1]')
buf[0] = NULL
- local ok = fs.os_can_exe(to_cstr(name), buf, true)
+ local ce_ret = fs.os_can_exe(to_cstr(name), buf, true)
-- When os_can_exe returns true, it must set the path.
-- When it returns false, the path must be NULL.
- if ok then
+ if ce_ret then
neq(NULL, buf[0])
return internalize(buf[0])
else
@@ -356,8 +366,8 @@ describe('fs function', function()
end)
describe('file operations', function()
- local function os_file_exists(filename)
- return fs.os_file_exists((to_cstr(filename)))
+ local function os_path_exists(filename)
+ return fs.os_path_exists((to_cstr(filename)))
end
local function os_rename(path, new_path)
return fs.os_rename((to_cstr(path)), (to_cstr(new_path)))
@@ -368,14 +378,67 @@ describe('fs function', function()
local function os_open(path, flags, mode)
return fs.os_open((to_cstr(path)), flags, mode)
end
+ local function os_close(fd)
+ return fs.os_close(fd)
+ end
+ -- For some reason if length of NUL-bytes-string is the same as `char[?]`
+ -- size luajit crashes. Though it does not do so in this test suite, better
+ -- be cautios and allocate more elements then needed. I only did this to
+ -- strings.
+ local function os_read(fd, size)
+ local buf = nil
+ if size == nil then
+ size = 0
+ else
+ buf = ffi.new('char[?]', size + 1, ('\0'):rep(size))
+ end
+ local eof = ffi.new('bool[?]', 1, {true})
+ local ret2 = fs.os_read(fd, eof, buf, size)
+ local ret1 = eof[0]
+ local ret3 = ''
+ if buf ~= nil then
+ ret3 = ffi.string(buf, size)
+ end
+ return ret1, ret2, ret3
+ end
+ local function os_readv(fd, sizes)
+ local bufs = {}
+ for i, size in ipairs(sizes) do
+ bufs[i] = {
+ iov_base=ffi.new('char[?]', size + 1, ('\0'):rep(size)),
+ iov_len=size,
+ }
+ end
+ local iov = ffi.new('struct iovec[?]', #sizes, bufs)
+ local eof = ffi.new('bool[?]', 1, {true})
+ local ret2 = fs.os_readv(fd, eof, iov, #sizes)
+ local ret1 = eof[0]
+ local ret3 = {}
+ for i = 1,#sizes do
+ -- Warning: iov may not be used.
+ ret3[i] = ffi.string(bufs[i].iov_base, bufs[i].iov_len)
+ end
+ return ret1, ret2, ret3
+ end
+ local function os_write(fd, data)
+ return fs.os_write(fd, data, data and #data or 0)
+ end
- describe('os_file_exists', function()
+ describe('os_path_exists', function()
it('returns false when given a non-existing file', function()
- eq(false, (os_file_exists('non-existing-file')))
+ eq(false, (os_path_exists('non-existing-file')))
end)
it('returns true when given an existing file', function()
- eq(true, (os_file_exists('unit-test-directory/test.file')))
+ eq(true, (os_path_exists('unit-test-directory/test.file')))
+ end)
+
+ it('returns false when given a broken symlink', function()
+ eq(false, (os_path_exists('unit-test-directory/test_broken_link.file')))
+ end)
+
+ it('returns true when given a directory', function()
+ eq(true, (os_path_exists('unit-test-directory')))
end)
end)
@@ -385,8 +448,8 @@ describe('fs function', function()
it('can rename file if destination file does not exist', function()
eq(OK, (os_rename(test, not_exist)))
- eq(false, (os_file_exists(test)))
- eq(true, (os_file_exists(not_exist)))
+ eq(false, (os_path_exists(test)))
+ eq(true, (os_path_exists(not_exist)))
eq(OK, (os_rename(not_exist, test))) -- restore test file
end)
@@ -402,8 +465,8 @@ describe('fs function', function()
file:close()
eq(OK, (os_rename(other, test)))
- eq(false, (os_file_exists(other)))
- eq(true, (os_file_exists(test)))
+ eq(false, (os_path_exists(other)))
+ eq(true, (os_path_exists(test)))
file = io.open(test, 'r')
eq('other', (file:read('*all')))
file:close()
@@ -432,30 +495,34 @@ describe('fs function', function()
end)
describe('os_open', function()
+ local new_file = 'test_new_file'
+ local existing_file = 'unit-test-directory/test_existing.file'
+
before_each(function()
- io.open('unit-test-directory/test_existing.file', 'w').close()
+ (io.open(existing_file, 'w')):close()
end)
after_each(function()
- os.remove('unit-test-directory/test_existing.file')
- os.remove('test_new_file')
+ os.remove(existing_file)
+ os.remove(new_file)
end)
- local new_file = 'test_new_file'
- local existing_file = 'unit-test-directory/test_existing.file'
-
it('returns UV_ENOENT for O_RDWR on a non-existing file', function()
eq(ffi.C.UV_ENOENT, (os_open('non-existing-file', ffi.C.kO_RDWR, 0)))
end)
- it('returns non-negative for O_CREAT on a non-existing file', function()
+ it('returns non-negative for O_CREAT on a non-existing file which then can be closed', function()
assert_file_does_not_exist(new_file)
- assert.is_true(0 <= (os_open(new_file, ffi.C.kO_CREAT, 0)))
+ local fd = os_open(new_file, ffi.C.kO_CREAT, 0)
+ assert.is_true(0 <= fd)
+ eq(0, os_close(fd))
end)
- it('returns non-negative for O_CREAT on a existing file', function()
+ it('returns non-negative for O_CREAT on a existing file which then can be closed', function()
assert_file_exists(existing_file)
- assert.is_true(0 <= (os_open(existing_file, ffi.C.kO_CREAT, 0)))
+ local fd = os_open(existing_file, ffi.C.kO_CREAT, 0)
+ assert.is_true(0 <= fd)
+ eq(0, os_close(fd))
end)
it('returns UV_EEXIST for O_CREAT|O_EXCL on a existing file', function()
@@ -463,24 +530,181 @@ describe('fs function', function()
eq(ffi.C.kUV_EEXIST, (os_open(existing_file, (bit.bor(ffi.C.kO_CREAT, ffi.C.kO_EXCL)), 0)))
end)
- it('sets `rwx` permissions for O_CREAT 700', function()
+ it('sets `rwx` permissions for O_CREAT 700 which then can be closed', function()
assert_file_does_not_exist(new_file)
--create the file
- os_open(new_file, ffi.C.kO_CREAT, tonumber("700", 8))
+ local fd = os_open(new_file, ffi.C.kO_CREAT, tonumber("700", 8))
--verify permissions
eq('rwx------', lfs.attributes(new_file)['permissions'])
+ eq(0, os_close(fd))
end)
- it('sets `rw` permissions for O_CREAT 600', function()
+ it('sets `rw` permissions for O_CREAT 600 which then can be closed', function()
assert_file_does_not_exist(new_file)
--create the file
- os_open(new_file, ffi.C.kO_CREAT, tonumber("600", 8))
+ local fd = os_open(new_file, ffi.C.kO_CREAT, tonumber("600", 8))
--verify permissions
eq('rw-------', lfs.attributes(new_file)['permissions'])
+ eq(0, os_close(fd))
+ end)
+
+ it('returns a non-negative file descriptor for an existing file which then can be closed', function()
+ local fd = os_open(existing_file, ffi.C.kO_RDWR, 0)
+ assert.is_true(0 <= fd)
+ eq(0, os_close(fd))
+ end)
+ end)
+
+ describe('os_close', function()
+ it('returns EBADF for negative file descriptors', function()
+ eq(ffi.C.UV_EBADF, os_close(-1))
+ eq(ffi.C.UV_EBADF, os_close(-1000))
+ end)
+ end)
+
+ describe('os_read', function()
+ local file = 'test-unit-os-fs_spec-os_read.dat'
+
+ before_each(function()
+ local f = io.open(file, 'w')
+ f:write(fcontents)
+ f:close()
+ end)
+
+ after_each(function()
+ os.remove(file)
+ end)
+
+ it('can read zero bytes from a file', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, 0, ''}, {os_read(fd, nil)})
+ eq({false, 0, ''}, {os_read(fd, 0)})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read from a file multiple times', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, 2, '\000\001'}, {os_read(fd, 2)})
+ eq({false, 2, '\002\003'}, {os_read(fd, 2)})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read the whole file at once and then report eof', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, #fcontents, fcontents}, {os_read(fd, #fcontents)})
+ eq({true, 0, ('\0'):rep(#fcontents)}, {os_read(fd, #fcontents)})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read the whole file in two calls, one partially', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, #fcontents * 3/4, fcontents:sub(1, #fcontents * 3/4)},
+ {os_read(fd, #fcontents * 3/4)})
+ eq({true,
+ (#fcontents * 1/4),
+ fcontents:sub(#fcontents * 3/4 + 1) .. ('\0'):rep(#fcontents * 2/4)},
+ {os_read(fd, #fcontents * 3/4)})
+ eq(0, os_close(fd))
+ end)
+ end)
+
+ describe('os_readv', function()
+ -- Function may be absent
+ if not pcall(function() return fs.os_readv end) then
+ return
+ end
+ local file = 'test-unit-os-fs_spec-os_readv.dat'
+
+ before_each(function()
+ local f = io.open(file, 'w')
+ f:write(fcontents)
+ f:close()
+ end)
+
+ after_each(function()
+ os.remove(file)
+ end)
+
+ it('can read zero bytes from a file', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, 0, {}}, {os_readv(fd, {})})
+ eq({false, 0, {'', '', ''}}, {os_readv(fd, {0, 0, 0})})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read from a file multiple times to a differently-sized buffers', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, 2, {'\000\001'}}, {os_readv(fd, {2})})
+ eq({false, 5, {'\002\003', '\004\005\006'}}, {os_readv(fd, {2, 3})})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read the whole file at once and then report eof', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false,
+ #fcontents,
+ {fcontents:sub(1, #fcontents * 1/4),
+ fcontents:sub(#fcontents * 1/4 + 1, #fcontents * 3/4),
+ fcontents:sub(#fcontents * 3/4 + 1, #fcontents * 15/16),
+ fcontents:sub(#fcontents * 15/16 + 1, #fcontents)}},
+ {os_readv(fd, {#fcontents * 1/4,
+ #fcontents * 2/4,
+ #fcontents * 3/16,
+ #fcontents * 1/16})})
+ eq({true, 0, {'\0'}}, {os_readv(fd, {1})})
+ eq(0, os_close(fd))
+ end)
+
+ it('can read the whole file in two calls, one partially', function()
+ local fd = os_open(file, ffi.C.kO_RDONLY, 0)
+ ok(fd >= 0)
+ eq({false, #fcontents * 3/4, {fcontents:sub(1, #fcontents * 3/4)}},
+ {os_readv(fd, {#fcontents * 3/4})})
+ eq({true,
+ (#fcontents * 1/4),
+ {fcontents:sub(#fcontents * 3/4 + 1) .. ('\0'):rep(#fcontents * 2/4)}},
+ {os_readv(fd, {#fcontents * 3/4})})
+ eq(0, os_close(fd))
+ end)
+ end)
+
+ describe('os_write', function()
+ -- Function may be absent
+ local file = 'test-unit-os-fs_spec-os_write.dat'
+
+ before_each(function()
+ local f = io.open(file, 'w')
+ f:write(fcontents)
+ f:close()
+ end)
+
+ after_each(function()
+ os.remove(file)
+ end)
+
+ it('can write zero bytes to a file', function()
+ local fd = os_open(file, ffi.C.kO_WRONLY, 0)
+ ok(fd >= 0)
+ eq(0, os_write(fd, ''))
+ eq(0, os_write(fd, nil))
+ eq(fcontents, io.open(file, 'r'):read('*a'))
+ eq(0, os_close(fd))
end)
- it('returns a non-negative file descriptor for an existing file', function()
- assert.is_true(0 <= (os_open(existing_file, ffi.C.kO_RDWR, 0)))
+ it('can write some data to a file', function()
+ local fd = os_open(file, ffi.C.kO_WRONLY, 0)
+ ok(fd >= 0)
+ eq(3, os_write(fd, 'abc'))
+ eq(4, os_write(fd, ' def'))
+ eq('abc def' .. fcontents:sub(8), io.open(file, 'r'):read('*a'))
+ eq(0, os_close(fd))
end)
end)
diff --git a/test/unit/os/shell_spec.lua b/test/unit/os/shell_spec.lua
index 93103e4e8c..906f950308 100644
--- a/test/unit/os/shell_spec.lua
+++ b/test/unit/os/shell_spec.lua
@@ -30,10 +30,6 @@ describe('shell functions', function()
cimported.p_shcf = to_cstr('-c')
end)
- teardown(function()
- cimported.event_teardown()
- end)
-
local function shell_build_argv(cmd, extra_args)
local res = cimported.shell_build_argv(
cmd and to_cstr(cmd),
diff --git a/test/unit/strings_spec.lua b/test/unit/strings_spec.lua
index e935d2af6a..0034670ee8 100644
--- a/test/unit/strings_spec.lua
+++ b/test/unit/strings_spec.lua
@@ -8,6 +8,38 @@ local to_cstr = helpers.to_cstr
local strings = cimport('stdlib.h', './src/nvim/strings.h',
'./src/nvim/memory.h')
+describe('vim_strsave_escaped()', function()
+ local vim_strsave_escaped = function(s, chars)
+ local res = strings.vim_strsave_escaped(to_cstr(s), to_cstr(chars))
+ local ret = ffi.string(res)
+
+ -- Explicitly free memory so we are sure it is allocated: if it was not it
+ -- will crash.
+ strings.xfree(res)
+ return ret
+ end
+
+ it('precedes by a backslash all chars from second argument', function()
+ eq([[\a\b\c\d]], vim_strsave_escaped('abcd','abcd'))
+ end)
+
+ it('precedes by a backslash chars only from second argument', function()
+ eq([[\a\bcd]], vim_strsave_escaped('abcd','ab'))
+ end)
+
+ it('returns a copy of passed string if second argument is empty', function()
+ eq('text \n text', vim_strsave_escaped('text \n text',''))
+ end)
+
+ it('returns an empty string if first argument is empty string', function()
+ eq('', vim_strsave_escaped('','\r'))
+ end)
+
+ it('returns a copy of passed string if it does not contain chars from 2nd argument', function()
+ eq('some text', vim_strsave_escaped('some text', 'a'))
+ end)
+end)
+
describe('vim_strnsave_unquoted()', function()
local vim_strnsave_unquoted = function(s, len)
local res = strings.vim_strnsave_unquoted(to_cstr(s), len or #s)
diff --git a/test/unit/tempfile_spec.lua b/test/unit/tempfile_spec.lua
index 7975d11aed..cf0d78b7a7 100644
--- a/test/unit/tempfile_spec.lua
+++ b/test/unit/tempfile_spec.lua
@@ -43,7 +43,7 @@ describe('tempfile related functions', function()
it('generate name of non-existing file', function()
local file = vim_tempname()
assert.truthy(file)
- assert.False(os.os_file_exists(file))
+ assert.False(os.os_path_exists(file))
end)
it('generate different names on each call', function()
generated by cgit (git 2.34.1) at 2025-07-25 10:45:57 +0000