test(unit): move statusline tests to statusline_spec.lua (#25441)

4 files changed, 293 insertions, 288 deletions

diff --git a/src/nvim/main.c b/src/nvim/main.c
index 2d7b2f231e..f6fd3abaec 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -10,7 +10,6 @@
 #include <assert.h>
 #include <limits.h>
 #include <msgpack/pack.h>
-#include <sanitizer/asan_interface.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
diff --git a/test/unit/buffer_spec.lua b/test/unit/buffer_spec.lua
index a54ea8c656..6e08a09295 100644
--- a/test/unit/buffer_spec.lua
+++ b/test/unit/buffer_spec.lua
@@ -1,15 +1,11 @@
-
 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 globals = helpers.cimport("./src/nvim/globals.h")
 local buffer = helpers.cimport("./src/nvim/buffer.h")
-local stl = helpers.cimport("./src/nvim/statusline.h")
 
 describe('buffer functions', function()
 
@@ -210,276 +206,4 @@ describe('buffer functions', function()
       close_buffer(NULL, buf2, buffer.DOBUF_WIPE, 0, 0)
     end)
   end)
-
-  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 (' '):byte()
-      local maximum_cell_count = arg.maximum_cell_count or buffer_byte_size
-
-      return stl.build_stl_str_hl(globals.curwin,
-                                     output_buffer,
-                                     buffer_byte_size,
-                                     to_cstr(pat),
-                                     NULL,
-                                     0,
-                                     fillchar,
-                                     maximum_cell_count,
-                                     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 (' '):byte()
-      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=('!'):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 put fillchar `━` in between text', 10,
-      'abc%=def',            'abc━━━━def',
-      {fillchar=0x2501})
-    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 = ('!'):byte()
-      statusline_test(description .. ' with fillchar `!`',
-        statusline_cell_count, input_stl, expected_stl:gsub('%~', '!'), arg)
-      arg.fillchar = 0x2501
-      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=('@'):byte()})
-
-    -- 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)
 end)
diff --git a/test/unit/keycodes_spec.lua b/test/unit/keycodes_spec.lua
index 5bf27c9232..4da3d37aaa 100644
--- a/test/unit/keycodes_spec.lua
+++ b/test/unit/keycodes_spec.lua
@@ -5,7 +5,7 @@ local ffi     = helpers.ffi
 local eq      = helpers.eq
 local neq     = helpers.neq
 
-local keymap = helpers.cimport('./src/nvim/keycodes.h')
+local keycodes = helpers.cimport('./src/nvim/keycodes.h')
 local NULL = helpers.NULL
 
 describe('keycodes.c', function()
@@ -16,12 +16,12 @@ describe('keycodes.c', function()
 
     itp('no keycode', function()
       srcp[0] = 'abc'
-      eq(0, keymap.find_special_key(srcp, 3, modp, 0, NULL))
+      eq(0, keycodes.find_special_key(srcp, 3, modp, 0, NULL))
     end)
 
     itp('keycode with multiple modifiers', function()
       srcp[0] = '<C-M-S-A>'
-      neq(0, keymap.find_special_key(srcp, 9, modp, 0, NULL))
+      neq(0, keycodes.find_special_key(srcp, 9, modp, 0, NULL))
       neq(0, modp[0])
     end)
 
@@ -29,22 +29,22 @@ describe('keycodes.c', function()
       -- Compare other capitalizations to this.
       srcp[0] = '<C-A>'
       local all_caps_key =
-          keymap.find_special_key(srcp, 5, modp, 0, NULL)
+          keycodes.find_special_key(srcp, 5, modp, 0, NULL)
       local all_caps_mod = modp[0]
 
       srcp[0] = '<C-a>'
       eq(all_caps_key,
-         keymap.find_special_key(srcp, 5, modp, 0, NULL))
+         keycodes.find_special_key(srcp, 5, modp, 0, NULL))
       eq(all_caps_mod, modp[0])
 
       srcp[0] = '<c-A>'
       eq(all_caps_key,
-         keymap.find_special_key(srcp, 5, modp, 0, NULL))
+         keycodes.find_special_key(srcp, 5, modp, 0, NULL))
       eq(all_caps_mod, modp[0])
 
       srcp[0] = '<c-a>'
       eq(all_caps_key,
-         keymap.find_special_key(srcp, 5, modp, 0, NULL))
+         keycodes.find_special_key(srcp, 5, modp, 0, NULL))
       eq(all_caps_mod, modp[0])
     end)
 
@@ -52,20 +52,20 @@ describe('keycodes.c', function()
       -- Unescaped with in_string=false
       srcp[0] = '<C-">'
       eq(string.byte('"'),
-         keymap.find_special_key(srcp, 5, modp, 0, NULL))
+         keycodes.find_special_key(srcp, 5, modp, 0, NULL))
 
       -- Unescaped with in_string=true
-      eq(0, keymap.find_special_key(srcp, 5, modp, keymap.FSK_IN_STRING, NULL))
+      eq(0, keycodes.find_special_key(srcp, 5, modp, keycodes.FSK_IN_STRING, NULL))
 
       -- Escaped with in_string=false
       srcp[0] = '<C-\\">'
       -- Should fail because the key is invalid
       -- (more than 1 non-modifier character).
-      eq(0, keymap.find_special_key(srcp, 6, modp, 0, NULL))
+      eq(0, keycodes.find_special_key(srcp, 6, modp, 0, NULL))
 
       -- Escaped with in_string=true
       eq(string.byte('"'),
-         keymap.find_special_key(srcp, 6, modp, keymap.FSK_IN_STRING, NULL))
+         keycodes.find_special_key(srcp, 6, modp, keycodes.FSK_IN_STRING, NULL))
     end)
   end)
 
diff --git a/test/unit/statusline_spec.lua b/test/unit/statusline_spec.lua
new file mode 100644
index 0000000000..a124a588e9
--- /dev/null
+++ b/test/unit/statusline_spec.lua
@@ -0,0 +1,282 @@
+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")
+
+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 (' '):byte()
+    local maximum_cell_count = arg.maximum_cell_count or buffer_byte_size
+
+    return stl.build_stl_str_hl(globals.curwin,
+                                   output_buffer,
+                                   buffer_byte_size,
+                                   to_cstr(pat),
+                                   NULL,
+                                   0,
+                                   fillchar,
+                                   maximum_cell_count,
+                                   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 (' '):byte()
+    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=('!'):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 put fillchar `━` in between text', 10,
+    'abc%=def',            'abc━━━━def',
+    {fillchar=0x2501})
+  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 = ('!'):byte()
+    statusline_test(description .. ' with fillchar `!`',
+      statusline_cell_count, input_stl, expected_stl:gsub('%~', '!'), arg)
+    arg.fillchar = 0x2501
+    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=('@'):byte()})
+
+  -- 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)