neovim/test/unit/statusline_spec.lua
bfredl af5beac1bd refactor(api): refactor more api functions to use arena return
Currently having two separate memory strategies for API return values is
a bit unnecessary, and mostly a consequence of converting the hot spot
cases which needed it first. But there is really no downside to using
arena everywhere (which implies also directly using strings which are
allocated earlier or even statically, without copy).

There only restriction is we need to know the size of arrays in advance,
but this info can often be passed on from some earlier stage if it is
missing.

This collects some "small" cases. The more complex stuff will get a PR
each.
2024-02-08 14:40:34 +01:00

472 lines
13 KiB
Lua

local helpers = require('test.unit.helpers')(after_each)
local itp = helpers.gen_itp(it)
local to_cstr = helpers.to_cstr
local get_str = helpers.ffi.string
local eq = helpers.eq
local NULL = helpers.NULL
local buffer = helpers.cimport('./src/nvim/buffer.h')
local globals = helpers.cimport('./src/nvim/globals.h')
local stl = helpers.cimport('./src/nvim/statusline.h')
local grid = helpers.cimport('./src/nvim/grid.h')
describe('build_stl_str_hl', function()
local buffer_byte_size = 100
local STL_INITIAL_ITEMS = 20
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 ' '
local maximum_cell_count = arg.maximum_cell_count or buffer_byte_size
if type(fillchar) == type('') then
fillchar = grid.schar_from_str(fillchar)
end
return stl.build_stl_str_hl(
globals.curwin,
output_buffer,
buffer_byte_size,
to_cstr(pat),
-1,
0,
fillchar,
maximum_cell_count,
NULL,
NULL,
NULL,
NULL
)
end
-- 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 (defaults to byte length of expected_stl)
-- .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 ' '
local expected_cell_count = option.expected_cell_count or statusline_cell_count
local expected_byte_length = option.expected_byte_length or #expected_stl
itp(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
-- expression testing
statusline_test('Should expand expression', 2, '%!expand(20+1)', '21')
statusline_test('Should expand broken expression to itself', 11, '%!expand(20+1', 'expand(20+1')
-- 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 = '!' }
)
statusline_test(
'should handle `~` as a fillchar',
10,
'%=abcde',
'~~~~~abcde',
{ fillchar = '~' }
)
statusline_test(
'should put fillchar `!` in between text',
10,
'abc%=def',
'abc!!!!def',
{ fillchar = '!' }
)
statusline_test(
'should put fillchar `~` in between text',
10,
'abc%=def',
'abc~~~~def',
{ fillchar = '~' }
)
statusline_test(
'should put fillchar `━` in between text',
10,
'abc%=def',
'abc━━━━def',
{ fillchar = '' }
)
statusline_test(
'should handle zero-fillchar as a space',
10,
'abcde%=',
'abcde ',
{ fillchar = 0 }
)
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')
statusline_test('should ignore trailing %', 3, 'abc%', 'abc')
-- alignment testing with fillchar
local function statusline_test_align(
description,
statusline_cell_count,
input_stl,
expected_stl,
arg
)
arg = arg or {}
statusline_test(
description .. ' without fillchar',
statusline_cell_count,
input_stl,
expected_stl:gsub('%~', ' '),
arg
)
arg.fillchar = '!'
statusline_test(
description .. ' with fillchar `!`',
statusline_cell_count,
input_stl,
expected_stl:gsub('%~', '!'),
arg
)
arg.fillchar = ''
statusline_test(
description .. ' with fillchar `━`',
statusline_cell_count,
input_stl,
expected_stl:gsub('%~', ''),
arg
)
end
statusline_test_align('should right align when using =', 20, 'neo%=vim', 'neo~~~~~~~~~~~~~~vim')
statusline_test_align(
'should, when possible, center text when using %=text%=',
20,
'abc%=neovim%=def',
'abc~~~~neovim~~~~def'
)
statusline_test_align(
'should handle uneven spacing in the buffer when using %=text%=',
20,
'abc%=neo_vim%=def',
'abc~~~neo_vim~~~~def'
)
statusline_test_align(
'should have equal spaces even with non-equal sides when using =',
20,
'foobar%=test%=baz',
'foobar~~~test~~~~baz'
)
statusline_test_align(
'should have equal spaces even with longer right side when using =',
20,
'a%=test%=longtext',
'a~~~test~~~~longtext'
)
statusline_test_align(
'should handle an empty left side when using ==',
20,
'%=test%=baz',
'~~~~~~test~~~~~~~baz'
)
statusline_test_align(
'should handle an empty right side when using ==',
20,
'foobar%=test%=',
'foobar~~~~~test~~~~~'
)
statusline_test_align(
'should handle consecutive empty ==',
20,
'%=%=test%=',
'~~~~~~~~~~test~~~~~~'
)
statusline_test_align('should handle an = alone', 20, '%=', '~~~~~~~~~~~~~~~~~~~~')
statusline_test_align(
'should right align text when it is alone with =',
20,
'%=foo',
'~~~~~~~~~~~~~~~~~foo'
)
statusline_test_align(
'should left align text when it is alone with =',
20,
'foo%=',
'foo~~~~~~~~~~~~~~~~~'
)
statusline_test_align(
'should approximately center text when using %=text%=',
21,
'abc%=neovim%=def',
'abc~~~~neovim~~~~~def'
)
statusline_test_align(
'should completely fill the buffer when using %=text%=',
21,
'abc%=neo_vim%=def',
'abc~~~~neo_vim~~~~def'
)
statusline_test_align(
'should have equal spacing even with non-equal sides when using =',
21,
'foobar%=test%=baz',
'foobar~~~~test~~~~baz'
)
statusline_test_align(
'should have equal spacing even with longer right side when using =',
21,
'a%=test%=longtext',
'a~~~~test~~~~longtext'
)
statusline_test_align(
'should handle an empty left side when using ==',
21,
'%=test%=baz',
'~~~~~~~test~~~~~~~baz'
)
statusline_test_align(
'should handle an empty right side when using ==',
21,
'foobar%=test%=',
'foobar~~~~~test~~~~~~'
)
statusline_test_align(
'should quadrant the text when using 3 %=',
40,
'abcd%=n%=eovim%=ef',
'abcd~~~~~~~~~n~~~~~~~~~eovim~~~~~~~~~~ef'
)
statusline_test_align(
'should work well with %t',
40,
'%t%=right_aligned',
'buffer_spec.lua~~~~~~~~~~~~right_aligned',
{ file_name = 'test/unit/buffer_spec.lua' }
)
statusline_test_align(
'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_align(
'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_align(
'should quadrant the text when using 3 %=',
41,
'abcd%=n%=eovim%=ef',
'abcd~~~~~~~~~n~~~~~~~~~eovim~~~~~~~~~~~ef'
)
statusline_test_align(
'should work well with %t',
41,
'%t%=right_aligned',
'buffer_spec.lua~~~~~~~~~~~~~right_aligned',
{ file_name = 'test/unit/buffer_spec.lua' }
)
statusline_test_align(
'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_align(
'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_align(
'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'
)
-- stl item testing
local tabline = ''
for i = 1, 1000 do
tabline = tabline .. (i % 2 == 0 and '%#TabLineSel#' or '%#TabLineFill#') .. tostring(i % 2)
end
statusline_test('should handle a large amount of any items', 20, tabline, '<1010101010101010101') -- Should not show any error
statusline_test(
'should handle a larger amount of = than stl initial item',
20,
('%='):rep(STL_INITIAL_ITEMS * 5),
' '
) -- Should not show any error
statusline_test(
'should handle many extra characters',
20,
'a' .. ('a'):rep(STL_INITIAL_ITEMS * 5),
'<aaaaaaaaaaaaaaaaaaa'
) -- Does not show any error
statusline_test(
'should handle many extra characters and flags',
20,
'a' .. ('%=a'):rep(STL_INITIAL_ITEMS * 2),
'a<aaaaaaaaaaaaaaaaaa'
) -- Should not show any error
-- multi-byte testing
statusline_test('should handle multibyte characters', 10, 'Ĉ%=x', 'Ĉ x')
statusline_test(
'should handle multibyte characters and different fillchars',
10,
'Ą%=mid%=end',
'Ą@mid@@end',
{ fillchar = '@' }
)
-- escaping % testing
statusline_test('should handle escape of %', 4, 'abc%%', 'abc%')
statusline_test('case where escaped % does not fit', 3, 'abc%%abcabc', '<bc')
statusline_test('escaped % is first', 1, '%%', '%')
end)