mirror of
https://github.com/neovim/neovim.git
synced 2024-12-24 21:25:04 -07:00
e61228a214
Before calling "attach" a screen object is just a dummy container for (row, col) values whose purpose is to be sent as part of the "attach" function call anyway. Just create the screen in an attached state directly. Keep the complete (row, col, options) config together. It is still completely valid to later detach and re-attach as needed, including to another session.
1288 lines
40 KiB
Lua
1288 lines
40 KiB
Lua
--
|
|
-- Tests for default options and environment decisions.
|
|
--
|
|
-- See editor/defaults_spec.lua for default autocmds, mappings, commands, and menus.
|
|
--
|
|
|
|
local t = require('test.testutil')
|
|
local n = require('test.functional.testnvim')()
|
|
local Screen = require('test.functional.ui.screen')
|
|
|
|
local assert_alive = n.assert_alive
|
|
local assert_log = t.assert_log
|
|
local api = n.api
|
|
local command = n.command
|
|
local clear = n.clear
|
|
local exc_exec = n.exc_exec
|
|
local exec_lua = n.exec_lua
|
|
local eval = n.eval
|
|
local eq = t.eq
|
|
local ok = t.ok
|
|
local fn = n.fn
|
|
local insert = n.insert
|
|
local neq = t.neq
|
|
local mkdir = t.mkdir
|
|
local rmdir = n.rmdir
|
|
local tbl_contains = vim.tbl_contains
|
|
local expect_exit = n.expect_exit
|
|
local check_close = n.check_close
|
|
local is_os = t.is_os
|
|
|
|
local testlog = 'Xtest-defaults-log'
|
|
|
|
describe('startup defaults', function()
|
|
describe(':filetype', function()
|
|
local function expect_filetype(expected)
|
|
local screen = Screen.new(50, 4)
|
|
command('filetype')
|
|
screen:expect([[
|
|
^ |
|
|
{1:~ }|*2
|
|
]] .. expected)
|
|
end
|
|
|
|
it('all ON after `-u NORC`', function()
|
|
clear('-u', 'NORC')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
end)
|
|
|
|
it('all ON after `:syntax …` #7765', function()
|
|
clear('-u', 'NORC', '--cmd', 'syntax on')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
clear('-u', 'NORC', '--cmd', 'syntax off')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
end)
|
|
|
|
it('all OFF after `-u NONE`', function()
|
|
clear('-u', 'NONE')
|
|
expect_filetype('filetype detection:OFF plugin:OFF indent:OFF |')
|
|
end)
|
|
|
|
it('explicit OFF stays OFF', function()
|
|
clear('-u', 'NORC', '--cmd', 'syntax off | filetype off | filetype plugin indent off')
|
|
expect_filetype('filetype detection:OFF plugin:OFF indent:OFF |')
|
|
clear('-u', 'NORC', '--cmd', 'syntax off | filetype plugin indent off')
|
|
expect_filetype('filetype detection:ON plugin:OFF indent:OFF |')
|
|
clear('-u', 'NORC', '--cmd', 'filetype indent off')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:OFF |')
|
|
clear('-u', 'NORC', '--cmd', 'syntax off | filetype off')
|
|
expect_filetype('filetype detection:OFF plugin:(on) indent:(on) |')
|
|
-- Swap the order.
|
|
clear('-u', 'NORC', '--cmd', 'filetype off | syntax off')
|
|
expect_filetype('filetype detection:OFF plugin:(on) indent:(on) |')
|
|
end)
|
|
|
|
it('all ON after early `:filetype … on`', function()
|
|
-- `:filetype … on` should not change the defaults. #7765
|
|
-- Only an explicit `:filetype … off` sets OFF.
|
|
|
|
clear('-u', 'NORC', '--cmd', 'filetype on')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
clear('-u', 'NORC', '--cmd', 'filetype plugin on')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
clear('-u', 'NORC', '--cmd', 'filetype indent on')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:ON |')
|
|
end)
|
|
|
|
it('late `:filetype … off` stays OFF', function()
|
|
clear('-u', 'NORC', '-c', 'filetype off')
|
|
expect_filetype('filetype detection:OFF plugin:(on) indent:(on) |')
|
|
clear('-u', 'NORC', '-c', 'filetype plugin off')
|
|
expect_filetype('filetype detection:ON plugin:OFF indent:ON |')
|
|
clear('-u', 'NORC', '-c', 'filetype indent off')
|
|
expect_filetype('filetype detection:ON plugin:ON indent:OFF |')
|
|
end)
|
|
end)
|
|
|
|
describe('syntax', function()
|
|
it('enabled by `-u NORC`', function()
|
|
clear('-u', 'NORC')
|
|
eq(1, eval('g:syntax_on'))
|
|
end)
|
|
|
|
it('disabled by `-u NONE`', function()
|
|
clear('-u', 'NONE')
|
|
eq(0, eval('exists("g:syntax_on")'))
|
|
end)
|
|
|
|
it('`:syntax off` stays off', function()
|
|
-- early
|
|
clear('-u', 'NORC', '--cmd', 'syntax off')
|
|
eq(0, eval('exists("g:syntax_on")'))
|
|
-- late
|
|
clear('-u', 'NORC', '-c', 'syntax off')
|
|
eq(0, eval('exists("g:syntax_on")'))
|
|
end)
|
|
|
|
it('":if 0|syntax on|endif" does not affect default #8728', function()
|
|
clear('-u', 'NORC', '--cmd', ':if 0|syntax on|endif')
|
|
eq(1, eval('exists("g:syntax_on")'))
|
|
clear('-u', 'NORC', '--cmd', ':if 0|syntax off|endif')
|
|
eq(1, eval('exists("g:syntax_on")'))
|
|
end)
|
|
end)
|
|
|
|
describe("'fillchars'", function()
|
|
it('vert/fold flags', function()
|
|
clear()
|
|
local screen = Screen.new(50, 5)
|
|
command('set laststatus=0')
|
|
insert([[
|
|
1
|
|
2
|
|
3
|
|
4]])
|
|
command('normal! ggjzfj')
|
|
command('vsp')
|
|
screen:expect([[
|
|
1 │1 |
|
|
{13:^+-- 2 lines: 2··········}│{13:+-- 2 lines: 2·········}|
|
|
4 │4 |
|
|
{1:~ }│{1:~ }|
|
|
|
|
|
]])
|
|
|
|
-- ambiwidth=double defaults to single-byte fillchars.
|
|
command('set ambiwidth=double')
|
|
screen:expect([[
|
|
1 |1 |
|
|
{13:^+-- 2 lines: 2----------}|{13:+-- 2 lines: 2---------}|
|
|
4 |4 |
|
|
{1:~ }|{1:~ }|
|
|
|
|
|
]])
|
|
|
|
-- change "vert" character to single-cell
|
|
fn.setcellwidths({ { 0x2502, 0x2502, 1 } })
|
|
screen:expect([[
|
|
1 │1 |
|
|
{13:^+-- 2 lines: 2----------}│{13:+-- 2 lines: 2---------}|
|
|
4 │4 |
|
|
{1:~ }│{1:~ }|
|
|
|
|
|
]])
|
|
|
|
-- change "vert" character to double-cell
|
|
fn.setcellwidths({ { 0x2502, 0x2502, 2 } })
|
|
screen:expect([[
|
|
1 |1 |
|
|
{13:^+-- 2 lines: 2----------}|{13:+-- 2 lines: 2---------}|
|
|
4 |4 |
|
|
{1:~ }|{1:~ }|
|
|
|
|
|
]])
|
|
|
|
-- "vert" character should still default to single-byte fillchars because of setcellwidths().
|
|
command('set ambiwidth=single')
|
|
screen:expect([[
|
|
1 |1 |
|
|
{13:^+-- 2 lines: 2··········}|{13:+-- 2 lines: 2·········}|
|
|
4 |4 |
|
|
{1:~ }|{1:~ }|
|
|
|
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
it("'shadafile' ('viminfofile')", function()
|
|
local env = {
|
|
XDG_DATA_HOME = 'Xtest-userdata',
|
|
XDG_STATE_HOME = 'Xtest-userstate',
|
|
XDG_CONFIG_HOME = 'Xtest-userconfig',
|
|
}
|
|
finally(function()
|
|
command('set shadafile=NONE') -- Avoid writing shada file on exit
|
|
rmdir('Xtest-userstate')
|
|
os.remove('Xtest-foo')
|
|
end)
|
|
|
|
clear { args = {}, args_rm = { '-i' }, env = env }
|
|
-- Default 'shadafile' is empty.
|
|
-- This means use the default location. :help shada-file-name
|
|
eq('', api.nvim_get_option_value('shadafile', {}))
|
|
eq('', api.nvim_get_option_value('viminfofile', {}))
|
|
-- Handles viminfo/viminfofile as alias for shada/shadafile.
|
|
eq('\n shadafile=', eval('execute("set shadafile?")'))
|
|
eq('\n shadafile=', eval('execute("set viminfofile?")'))
|
|
eq("\n shada=!,'100,<50,s10,h", eval('execute("set shada?")'))
|
|
eq("\n shada=!,'100,<50,s10,h", eval('execute("set viminfo?")'))
|
|
|
|
-- Check that shada data (such as v:oldfiles) is saved/restored.
|
|
command('edit Xtest-foo')
|
|
command('write')
|
|
local f = eval('fnamemodify(@%,":p")')
|
|
assert(string.len(f) > 3)
|
|
expect_exit(command, 'qall')
|
|
clear { args = {}, args_rm = { '-i' }, env = env }
|
|
eq({ f }, eval('v:oldfiles'))
|
|
end)
|
|
|
|
it("'packpath'", function()
|
|
clear {
|
|
args_rm = { 'runtimepath' },
|
|
}
|
|
-- Defaults to &runtimepath.
|
|
eq(api.nvim_get_option_value('runtimepath', {}), api.nvim_get_option_value('packpath', {}))
|
|
|
|
-- Does not follow modifications to runtimepath.
|
|
command('set runtimepath+=foo')
|
|
neq(api.nvim_get_option_value('runtimepath', {}), api.nvim_get_option_value('packpath', {}))
|
|
command('set packpath+=foo')
|
|
eq(api.nvim_get_option_value('runtimepath', {}), api.nvim_get_option_value('packpath', {}))
|
|
end)
|
|
|
|
it('v:progpath is set to the absolute path', function()
|
|
clear()
|
|
eq(eval("fnamemodify(v:progpath, ':p')"), eval('v:progpath'))
|
|
end)
|
|
|
|
describe('$NVIM_LOG_FILE', function()
|
|
local xdgdir = 'Xtest-startup-xdg-logpath'
|
|
local xdgstatedir = is_os('win') and xdgdir .. '/nvim-data' or xdgdir .. '/nvim'
|
|
after_each(function()
|
|
os.remove('Xtest-logpath')
|
|
rmdir(xdgdir)
|
|
end)
|
|
|
|
it('is used if expansion succeeds', function()
|
|
clear({ env = {
|
|
NVIM_LOG_FILE = 'Xtest-logpath',
|
|
} })
|
|
eq('Xtest-logpath', eval('$NVIM_LOG_FILE'))
|
|
end)
|
|
|
|
it('defaults to stdpath("log")/log if empty', function()
|
|
eq(true, mkdir(xdgdir) and mkdir(xdgstatedir))
|
|
clear({
|
|
env = {
|
|
XDG_STATE_HOME = xdgdir,
|
|
NVIM_LOG_FILE = '', -- Empty is invalid.
|
|
},
|
|
})
|
|
eq(xdgstatedir .. '/log', t.fix_slashes(eval('$NVIM_LOG_FILE')))
|
|
end)
|
|
|
|
it('defaults to stdpath("log")/log if invalid', function()
|
|
eq(true, mkdir(xdgdir) and mkdir(xdgstatedir))
|
|
clear({
|
|
env = {
|
|
XDG_STATE_HOME = xdgdir,
|
|
NVIM_LOG_FILE = '.', -- Any directory is invalid.
|
|
},
|
|
})
|
|
eq(xdgstatedir .. '/log', t.fix_slashes(eval('$NVIM_LOG_FILE')))
|
|
-- Avoid "failed to open $NVIM_LOG_FILE" noise in test output.
|
|
expect_exit(command, 'qall!')
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('XDG defaults', function()
|
|
-- Need separate describe() blocks to not run clear() twice.
|
|
-- Do not put before_each() here for the same reasons.
|
|
|
|
after_each(function()
|
|
check_close()
|
|
os.remove(testlog)
|
|
end)
|
|
|
|
it("&runtimepath data-dir matches stdpath('data') #9910", function()
|
|
clear()
|
|
local rtp = eval('split(&runtimepath, ",")')
|
|
local rv = {}
|
|
local expected = (
|
|
is_os('win') and { [[\nvim-data\site]], [[\nvim-data\site\after]] }
|
|
or { '/nvim/site', '/nvim/site/after' }
|
|
)
|
|
|
|
for _, v in ipairs(rtp) do
|
|
local m = string.match(v, [=[[/\]nvim[^/\]*[/\]site.*$]=])
|
|
if m and not tbl_contains(rv, m) then
|
|
table.insert(rv, m)
|
|
end
|
|
end
|
|
eq(expected, rv)
|
|
end)
|
|
|
|
describe('with empty/broken environment', function()
|
|
it('sets correct defaults', function()
|
|
clear({
|
|
env = {
|
|
XDG_CONFIG_HOME = nil,
|
|
XDG_DATA_HOME = nil,
|
|
XDG_CACHE_HOME = nil,
|
|
XDG_STATE_HOME = nil,
|
|
XDG_RUNTIME_DIR = nil,
|
|
XDG_CONFIG_DIRS = nil,
|
|
XDG_DATA_DIRS = nil,
|
|
LOCALAPPDATA = nil,
|
|
HOMEPATH = nil,
|
|
HOMEDRIVE = nil,
|
|
HOME = nil,
|
|
TEMP = nil,
|
|
VIMRUNTIME = nil,
|
|
USER = nil,
|
|
},
|
|
})
|
|
|
|
eq('.', api.nvim_get_option_value('backupdir', {}))
|
|
eq('.', api.nvim_get_option_value('viewdir', {}))
|
|
eq('.', api.nvim_get_option_value('directory', {}))
|
|
eq('.', api.nvim_get_option_value('undodir', {}))
|
|
ok((fn.tempname()):len() > 4)
|
|
end)
|
|
end)
|
|
|
|
local function vimruntime_and_libdir()
|
|
local vimruntime = eval('$VIMRUNTIME')
|
|
-- libdir is hard to calculate reliably across various ci platforms
|
|
-- local libdir = string.gsub(vimruntime, "share/nvim/runtime$", "lib/nvim")
|
|
local libdir = api.nvim__get_lib_dir()
|
|
return vimruntime, libdir
|
|
end
|
|
|
|
local env_sep = is_os('win') and ';' or ':'
|
|
local data_dir = is_os('win') and 'nvim-data' or 'nvim'
|
|
local state_dir = is_os('win') and 'nvim-data' or 'nvim'
|
|
local root_path = is_os('win') and 'C:' or ''
|
|
|
|
describe('with too long XDG vars', function()
|
|
before_each(function()
|
|
clear({
|
|
-- Ensure valid --listen address despite broken XDG vars (else Nvim won't start).
|
|
args = { '--listen', is_os('win') and '' or t.tmpname(false) },
|
|
args_rm = { 'runtimepath' },
|
|
env = {
|
|
NVIM_LOG_FILE = testlog,
|
|
XDG_CONFIG_HOME = (root_path .. ('/x'):rep(4096)),
|
|
XDG_CONFIG_DIRS = (root_path .. ('/a'):rep(2048) .. env_sep .. root_path .. ('/b'):rep(
|
|
2048
|
|
) .. (env_sep .. root_path .. '/c'):rep(512)),
|
|
XDG_DATA_HOME = (root_path .. ('/X'):rep(4096)),
|
|
XDG_RUNTIME_DIR = (root_path .. ('/X'):rep(4096)),
|
|
XDG_STATE_HOME = (root_path .. ('/X'):rep(4096)),
|
|
XDG_DATA_DIRS = (root_path .. ('/A'):rep(2048) .. env_sep .. root_path .. ('/B'):rep(
|
|
2048
|
|
) .. (env_sep .. root_path .. '/C'):rep(512)),
|
|
},
|
|
})
|
|
end)
|
|
|
|
it('are correctly set', function()
|
|
if not is_os('win') then
|
|
-- Broken XDG vars cause serverstart() to fail (except on Windows, where servernames are not
|
|
-- informed by $XDG_STATE_HOME).
|
|
t.matches('Failed to start server: no such file or directory', t.pcall_err(fn.serverstart))
|
|
assert_log('Failed to start server: no such file or directory: /X/X/X', testlog, 10)
|
|
end
|
|
|
|
local vimruntime, libdir = vimruntime_and_libdir()
|
|
|
|
eq(
|
|
(
|
|
t.fix_slashes(
|
|
root_path
|
|
.. ('/x'):rep(4096)
|
|
.. '/nvim'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/a'):rep(2048)
|
|
.. '/nvim'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/b'):rep(2048)
|
|
.. '/nvim'
|
|
.. (',' .. root_path .. '/c/nvim')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/X'):rep(4096)
|
|
.. '/'
|
|
.. data_dir
|
|
.. '/site'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/A'):rep(2048)
|
|
.. '/nvim/site'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/B'):rep(2048)
|
|
.. '/nvim/site'
|
|
.. (',' .. root_path .. '/C/nvim/site')
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. (',' .. root_path .. '/C/nvim/site/after')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/B'):rep(2048)
|
|
.. '/nvim/site/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/A'):rep(2048)
|
|
.. '/nvim/site/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/X'):rep(4096)
|
|
.. '/'
|
|
.. data_dir
|
|
.. '/site/after'
|
|
.. (',' .. root_path .. '/c/nvim/after')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/b'):rep(2048)
|
|
.. '/nvim/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/a'):rep(2048)
|
|
.. '/nvim/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/x'):rep(4096)
|
|
.. '/nvim/after'
|
|
)
|
|
),
|
|
t.fix_slashes(api.nvim_get_option_value('runtimepath', {}))
|
|
)
|
|
command('set runtimepath&')
|
|
command('set backupdir&')
|
|
command('set directory&')
|
|
command('set undodir&')
|
|
command('set viewdir&')
|
|
eq(
|
|
(
|
|
t.fix_slashes(
|
|
root_path
|
|
.. ('/x'):rep(4096)
|
|
.. '/nvim'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/a'):rep(2048)
|
|
.. '/nvim'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/b'):rep(2048)
|
|
.. '/nvim'
|
|
.. (',' .. root_path .. '/c/nvim')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/X'):rep(4096)
|
|
.. '/'
|
|
.. data_dir
|
|
.. '/site'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/A'):rep(2048)
|
|
.. '/nvim/site'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/B'):rep(2048)
|
|
.. '/nvim/site'
|
|
.. (',' .. root_path .. '/C/nvim/site')
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. (',' .. root_path .. '/C/nvim/site/after')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/B'):rep(2048)
|
|
.. '/nvim/site/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/A'):rep(2048)
|
|
.. '/nvim/site/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/X'):rep(4096)
|
|
.. '/'
|
|
.. data_dir
|
|
.. '/site/after'
|
|
.. (',' .. root_path .. '/c/nvim/after')
|
|
.. ','
|
|
.. root_path
|
|
.. ('/b'):rep(2048)
|
|
.. '/nvim/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/a'):rep(2048)
|
|
.. '/nvim/after'
|
|
.. ','
|
|
.. root_path
|
|
.. ('/x'):rep(4096)
|
|
.. '/nvim/after'
|
|
)
|
|
),
|
|
t.fix_slashes(api.nvim_get_option_value('runtimepath', {}))
|
|
)
|
|
eq(
|
|
'.,' .. root_path .. ('/X'):rep(4096) .. '/' .. state_dir .. '/backup//',
|
|
t.fix_slashes(api.nvim_get_option_value('backupdir', {}))
|
|
)
|
|
eq(
|
|
root_path .. ('/X'):rep(4096) .. '/' .. state_dir .. '/swap//',
|
|
t.fix_slashes(api.nvim_get_option_value('directory', {}))
|
|
)
|
|
eq(
|
|
root_path .. ('/X'):rep(4096) .. '/' .. state_dir .. '/undo//',
|
|
t.fix_slashes(api.nvim_get_option_value('undodir', {}))
|
|
)
|
|
eq(
|
|
root_path .. ('/X'):rep(4096) .. '/' .. state_dir .. '/view//',
|
|
t.fix_slashes(api.nvim_get_option_value('viewdir', {}))
|
|
)
|
|
end)
|
|
end)
|
|
|
|
describe('with expandable XDG vars', function()
|
|
before_each(function()
|
|
clear({
|
|
-- Ensure valid --listen address despite broken XDG vars (else Nvim won't start).
|
|
args = { '--listen', is_os('win') and '' or t.tmpname(false) },
|
|
args_rm = { 'runtimepath' },
|
|
env = {
|
|
NVIM_LOG_FILE = testlog,
|
|
XDG_CONFIG_HOME = '$XDG_DATA_HOME',
|
|
XDG_CONFIG_DIRS = '$XDG_DATA_DIRS',
|
|
XDG_DATA_HOME = '$XDG_CONFIG_HOME',
|
|
XDG_RUNTIME_DIR = '$XDG_RUNTIME_DIR',
|
|
XDG_STATE_HOME = '$XDG_CONFIG_HOME',
|
|
XDG_DATA_DIRS = '$XDG_CONFIG_DIRS',
|
|
},
|
|
})
|
|
end)
|
|
|
|
after_each(function()
|
|
command('set shadafile=NONE') -- Avoid writing shada file on exit
|
|
end)
|
|
|
|
it('are not expanded', function()
|
|
if not is_os('win') then
|
|
-- Broken XDG vars cause serverstart() to fail (except on Windows, where servernames are not
|
|
-- informed by $XDG_STATE_HOME).
|
|
t.matches('Failed to start server: no such file or directory', t.pcall_err(fn.serverstart))
|
|
assert_log(
|
|
'Failed to start server: no such file or directory: %$XDG_RUNTIME_DIR%/',
|
|
testlog,
|
|
10
|
|
)
|
|
end
|
|
|
|
local vimruntime, libdir = vimruntime_and_libdir()
|
|
eq(
|
|
(
|
|
t.fix_slashes(
|
|
'$XDG_DATA_HOME/nvim'
|
|
.. ',$XDG_DATA_DIRS/nvim'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site'
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site'
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site/after'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site/after'
|
|
.. ',$XDG_DATA_DIRS/nvim/after'
|
|
.. ',$XDG_DATA_HOME/nvim/after'
|
|
)
|
|
),
|
|
t.fix_slashes(api.nvim_get_option_value('runtimepath', {}))
|
|
)
|
|
command('set runtimepath&')
|
|
command('set backupdir&')
|
|
command('set directory&')
|
|
command('set undodir&')
|
|
command('set viewdir&')
|
|
eq(
|
|
(
|
|
t.fix_slashes(
|
|
'$XDG_DATA_HOME/nvim'
|
|
.. ',$XDG_DATA_DIRS/nvim'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site'
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site'
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site/after'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site/after'
|
|
.. ',$XDG_DATA_DIRS/nvim/after'
|
|
.. ',$XDG_DATA_HOME/nvim/after'
|
|
)
|
|
),
|
|
t.fix_slashes(api.nvim_get_option_value('runtimepath', {}))
|
|
)
|
|
eq(
|
|
('.,$XDG_CONFIG_HOME/' .. state_dir .. '/backup//'),
|
|
t.fix_slashes(api.nvim_get_option_value('backupdir', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/swap//'),
|
|
t.fix_slashes(api.nvim_get_option_value('directory', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/undo//'),
|
|
t.fix_slashes(api.nvim_get_option_value('undodir', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/view//'),
|
|
t.fix_slashes(api.nvim_get_option_value('viewdir', {}))
|
|
)
|
|
command('set all&')
|
|
eq(
|
|
t.fix_slashes(
|
|
'$XDG_DATA_HOME/nvim'
|
|
.. ',$XDG_DATA_DIRS/nvim'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site'
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site'
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. ',$XDG_CONFIG_DIRS/nvim/site/after'
|
|
.. ',$XDG_CONFIG_HOME/'
|
|
.. data_dir
|
|
.. '/site/after'
|
|
.. ',$XDG_DATA_DIRS/nvim/after'
|
|
.. ',$XDG_DATA_HOME/nvim/after'
|
|
),
|
|
t.fix_slashes(api.nvim_get_option_value('runtimepath', {}))
|
|
)
|
|
eq(
|
|
('.,$XDG_CONFIG_HOME/' .. state_dir .. '/backup//'),
|
|
t.fix_slashes(api.nvim_get_option_value('backupdir', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/swap//'),
|
|
t.fix_slashes(api.nvim_get_option_value('directory', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/undo//'),
|
|
t.fix_slashes(api.nvim_get_option_value('undodir', {}))
|
|
)
|
|
eq(
|
|
('$XDG_CONFIG_HOME/' .. state_dir .. '/view//'),
|
|
t.fix_slashes(api.nvim_get_option_value('viewdir', {}))
|
|
)
|
|
eq(nil, (fn.tempname()):match('XDG_RUNTIME_DIR'))
|
|
end)
|
|
end)
|
|
|
|
describe('with commas', function()
|
|
before_each(function()
|
|
clear({
|
|
args_rm = { 'runtimepath' },
|
|
env = {
|
|
XDG_CONFIG_HOME = ', , ,',
|
|
XDG_CONFIG_DIRS = ',-,-,' .. env_sep .. '-,-,-',
|
|
XDG_DATA_HOME = ',=,=,',
|
|
XDG_STATE_HOME = ',=,=,',
|
|
XDG_DATA_DIRS = ',≡,≡,' .. env_sep .. '≡,≡,≡',
|
|
},
|
|
})
|
|
end)
|
|
|
|
it('are escaped properly', function()
|
|
local vimruntime, libdir = vimruntime_and_libdir()
|
|
local path_sep = is_os('win') and '\\' or '/'
|
|
eq(
|
|
(
|
|
'\\, \\, \\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',\\,-\\,-\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',-\\,-\\,-'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. data_dir
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ',\\,≡\\,≡\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ',≡\\,≡\\,≡'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. ',≡\\,≡\\,≡'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,≡\\,≡\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. data_dir
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',-\\,-\\,-'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,-\\,-\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\, \\, \\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
),
|
|
api.nvim_get_option_value('runtimepath', {})
|
|
)
|
|
command('set runtimepath&')
|
|
command('set backupdir&')
|
|
command('set directory&')
|
|
command('set undodir&')
|
|
command('set viewdir&')
|
|
eq(
|
|
(
|
|
'\\, \\, \\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',\\,-\\,-\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',-\\,-\\,-'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. ',\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. ''
|
|
.. data_dir
|
|
.. ''
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ',\\,≡\\,≡\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ',≡\\,≡\\,≡'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. ','
|
|
.. vimruntime
|
|
.. ','
|
|
.. libdir
|
|
.. ',≡\\,≡\\,≡'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,≡\\,≡\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. ''
|
|
.. data_dir
|
|
.. ''
|
|
.. path_sep
|
|
.. 'site'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',-\\,-\\,-'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\,-\\,-\\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
.. ',\\, \\, \\,'
|
|
.. path_sep
|
|
.. 'nvim'
|
|
.. path_sep
|
|
.. 'after'
|
|
),
|
|
api.nvim_get_option_value('runtimepath', {})
|
|
)
|
|
eq(
|
|
'.,\\,=\\,=\\,' .. path_sep .. state_dir .. '' .. path_sep .. 'backup' .. (path_sep):rep(2),
|
|
api.nvim_get_option_value('backupdir', {})
|
|
)
|
|
eq(
|
|
'\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. ''
|
|
.. state_dir
|
|
.. ''
|
|
.. path_sep
|
|
.. 'swap'
|
|
.. (path_sep):rep(2),
|
|
api.nvim_get_option_value('directory', {})
|
|
)
|
|
eq(
|
|
'\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. ''
|
|
.. state_dir
|
|
.. ''
|
|
.. path_sep
|
|
.. 'undo'
|
|
.. (path_sep):rep(2),
|
|
api.nvim_get_option_value('undodir', {})
|
|
)
|
|
eq(
|
|
'\\,=\\,=\\,'
|
|
.. path_sep
|
|
.. ''
|
|
.. state_dir
|
|
.. ''
|
|
.. path_sep
|
|
.. 'view'
|
|
.. (path_sep):rep(2),
|
|
api.nvim_get_option_value('viewdir', {})
|
|
)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('stdpath()', function()
|
|
after_each(function()
|
|
check_close()
|
|
os.remove(testlog)
|
|
end)
|
|
|
|
-- Windows appends 'nvim-data' instead of just 'nvim' to prevent collisions
|
|
-- due to XDG_CONFIG_HOME, XDG_DATA_HOME and XDG_STATE_HOME being the same.
|
|
local function maybe_data(name)
|
|
return is_os('win') and name .. '-data' or name
|
|
end
|
|
|
|
local datadir = maybe_data('nvim')
|
|
local statedir = maybe_data('nvim')
|
|
local env_sep = is_os('win') and ';' or ':'
|
|
|
|
it('acceptance', function()
|
|
clear() -- Do not explicitly set any env vars.
|
|
|
|
eq('nvim', fn.fnamemodify(fn.stdpath('cache'), ':t'))
|
|
eq('nvim', fn.fnamemodify(fn.stdpath('config'), ':t'))
|
|
eq(datadir, fn.fnamemodify(fn.stdpath('data'), ':t'))
|
|
eq(statedir, fn.fnamemodify(fn.stdpath('state'), ':t'))
|
|
eq('table', type(fn.stdpath('config_dirs')))
|
|
eq('table', type(fn.stdpath('data_dirs')))
|
|
eq('string', type(fn.stdpath('run')))
|
|
assert_alive() -- Check for crash. #8393
|
|
end)
|
|
|
|
it('$NVIM_APPNAME', function()
|
|
local appname = 'NVIM_APPNAME_TEST' .. ('_'):rep(106)
|
|
clear({ env = { NVIM_APPNAME = appname, NVIM_LOG_FILE = testlog } })
|
|
eq(appname, fn.fnamemodify(fn.stdpath('config'), ':t'))
|
|
eq(appname, fn.fnamemodify(fn.stdpath('cache'), ':t'))
|
|
eq(maybe_data(appname), fn.fnamemodify(fn.stdpath('log'), ':t'))
|
|
eq(maybe_data(appname), fn.fnamemodify(fn.stdpath('data'), ':t'))
|
|
eq(maybe_data(appname), fn.fnamemodify(fn.stdpath('state'), ':t'))
|
|
-- config_dirs and data_dirs are empty on windows, so don't check them on
|
|
-- that platform
|
|
if not is_os('win') then
|
|
eq(appname, fn.fnamemodify(fn.stdpath('config_dirs')[1], ':t'))
|
|
eq(appname, fn.fnamemodify(fn.stdpath('data_dirs')[1], ':t'))
|
|
end
|
|
assert_alive() -- Check for crash. #8393
|
|
|
|
-- Check that Nvim rejects invalid APPNAMEs
|
|
-- Call jobstart() and jobwait() in the same RPC request to reduce flakiness.
|
|
local function test_appname(testAppname, expected_exitcode)
|
|
local lua_code = string.format(
|
|
[[
|
|
local child = vim.fn.jobstart({ vim.v.progpath, '--clean', '--headless', '--listen', 'x', '+qall!' }, { env = { NVIM_APPNAME = %q } })
|
|
return vim.fn.jobwait({ child }, %d)[1]
|
|
]],
|
|
testAppname,
|
|
3000
|
|
)
|
|
eq(expected_exitcode, exec_lua(lua_code))
|
|
end
|
|
-- Invalid appnames:
|
|
test_appname('a/../b', 1)
|
|
test_appname('../a', 1)
|
|
test_appname('a/..', 1)
|
|
test_appname('..', 1)
|
|
test_appname('.', 1)
|
|
test_appname('/', 1)
|
|
test_appname(is_os('win') and 'C:/a/b' or '/a/b', 1)
|
|
-- Valid appnames:
|
|
test_appname('a/b', 0)
|
|
test_appname('a/b\\c', 0)
|
|
end)
|
|
|
|
it('$NVIM_APPNAME relative path', function()
|
|
local tmpdir = t.tmpname(false)
|
|
t.mkdir(tmpdir)
|
|
|
|
clear({
|
|
args_rm = { '--listen' },
|
|
env = {
|
|
NVIM_APPNAME = 'relative/appname',
|
|
NVIM_LOG_FILE = testlog,
|
|
TMPDIR = tmpdir,
|
|
},
|
|
})
|
|
|
|
t.matches(vim.pesc(tmpdir), t.fix_slashes(fn.tempname()))
|
|
t.assert_nolog('tempdir', testlog, 100)
|
|
t.assert_nolog('TMPDIR', testlog, 100)
|
|
t.matches([=[[/\\]relative%-appname.[^/\\]+]=], api.nvim_get_vvar('servername'))
|
|
end)
|
|
|
|
describe('returns a String', function()
|
|
describe('with "config"', function()
|
|
it('knows XDG_CONFIG_HOME', function()
|
|
clear({
|
|
env = {
|
|
XDG_CONFIG_HOME = '/home/docwhat/.config',
|
|
},
|
|
})
|
|
eq('/home/docwhat/.config/nvim', t.fix_slashes(fn.stdpath('config')))
|
|
end)
|
|
|
|
it('handles changes during runtime', function()
|
|
clear({ env = {
|
|
XDG_CONFIG_HOME = '/home/original',
|
|
} })
|
|
eq('/home/original/nvim', t.fix_slashes(fn.stdpath('config')))
|
|
command("let $XDG_CONFIG_HOME='/home/new'")
|
|
eq('/home/new/nvim', t.fix_slashes(fn.stdpath('config')))
|
|
end)
|
|
|
|
it("doesn't expand $VARIABLES", function()
|
|
clear({
|
|
env = {
|
|
XDG_CONFIG_HOME = '$VARIABLES',
|
|
VARIABLES = 'this-should-not-happen',
|
|
},
|
|
})
|
|
eq('$VARIABLES/nvim', t.fix_slashes(fn.stdpath('config')))
|
|
end)
|
|
|
|
it("doesn't expand ~/", function()
|
|
clear({ env = {
|
|
XDG_CONFIG_HOME = '~/frobnitz',
|
|
} })
|
|
eq('~/frobnitz/nvim', t.fix_slashes(fn.stdpath('config')))
|
|
end)
|
|
end)
|
|
|
|
describe('with "data"', function()
|
|
it('knows XDG_DATA_HOME', function()
|
|
clear({ env = {
|
|
XDG_DATA_HOME = '/home/docwhat/.local',
|
|
} })
|
|
eq('/home/docwhat/.local/' .. datadir, t.fix_slashes(fn.stdpath('data')))
|
|
end)
|
|
|
|
it('handles changes during runtime', function()
|
|
clear({ env = {
|
|
XDG_DATA_HOME = '/home/original',
|
|
} })
|
|
eq('/home/original/' .. datadir, t.fix_slashes(fn.stdpath('data')))
|
|
command("let $XDG_DATA_HOME='/home/new'")
|
|
eq('/home/new/' .. datadir, t.fix_slashes(fn.stdpath('data')))
|
|
end)
|
|
|
|
it("doesn't expand $VARIABLES", function()
|
|
clear({
|
|
env = {
|
|
XDG_DATA_HOME = '$VARIABLES',
|
|
VARIABLES = 'this-should-not-happen',
|
|
},
|
|
})
|
|
eq('$VARIABLES/' .. datadir, t.fix_slashes(fn.stdpath('data')))
|
|
end)
|
|
|
|
it("doesn't expand ~/", function()
|
|
clear({ env = {
|
|
XDG_DATA_HOME = '~/frobnitz',
|
|
} })
|
|
eq('~/frobnitz/' .. datadir, t.fix_slashes(fn.stdpath('data')))
|
|
end)
|
|
end)
|
|
|
|
describe('with "state"', function()
|
|
it('knows XDG_STATE_HOME', function()
|
|
clear({
|
|
env = {
|
|
XDG_STATE_HOME = '/home/docwhat/.local',
|
|
},
|
|
})
|
|
eq('/home/docwhat/.local/' .. statedir, t.fix_slashes(fn.stdpath('state')))
|
|
end)
|
|
|
|
it('handles changes during runtime', function()
|
|
clear({ env = {
|
|
XDG_STATE_HOME = '/home/original',
|
|
} })
|
|
eq('/home/original/' .. statedir, t.fix_slashes(fn.stdpath('state')))
|
|
command("let $XDG_STATE_HOME='" .. '/home/new' .. "'")
|
|
eq('/home/new/' .. statedir, t.fix_slashes(fn.stdpath('state')))
|
|
end)
|
|
|
|
it("doesn't expand $VARIABLES", function()
|
|
clear({
|
|
env = {
|
|
XDG_STATE_HOME = '$VARIABLES',
|
|
VARIABLES = 'this-should-not-happen',
|
|
},
|
|
})
|
|
eq('$VARIABLES/' .. statedir, t.fix_slashes(fn.stdpath('state')))
|
|
end)
|
|
|
|
it("doesn't expand ~/", function()
|
|
clear({ env = {
|
|
XDG_STATE_HOME = '~/frobnitz',
|
|
} })
|
|
eq('~/frobnitz/' .. statedir, t.fix_slashes(fn.stdpath('state')))
|
|
end)
|
|
end)
|
|
|
|
describe('with "cache"', function()
|
|
it('knows XDG_CACHE_HOME', function()
|
|
clear({
|
|
env = {
|
|
XDG_CACHE_HOME = '/home/docwhat/.cache',
|
|
},
|
|
})
|
|
eq('/home/docwhat/.cache/nvim', t.fix_slashes(fn.stdpath('cache')))
|
|
end)
|
|
|
|
it('handles changes during runtime', function()
|
|
clear({ env = {
|
|
XDG_CACHE_HOME = '/home/original',
|
|
} })
|
|
eq('/home/original/nvim', t.fix_slashes(fn.stdpath('cache')))
|
|
command("let $XDG_CACHE_HOME='" .. '/home/new' .. "'")
|
|
eq('/home/new/nvim', t.fix_slashes(fn.stdpath('cache')))
|
|
end)
|
|
|
|
it("doesn't expand $VARIABLES", function()
|
|
clear({
|
|
env = {
|
|
XDG_CACHE_HOME = '$VARIABLES',
|
|
VARIABLES = 'this-should-not-happen',
|
|
},
|
|
})
|
|
eq('$VARIABLES/nvim', t.fix_slashes(fn.stdpath('cache')))
|
|
end)
|
|
|
|
it("doesn't expand ~/", function()
|
|
clear({ env = {
|
|
XDG_CACHE_HOME = '~/frobnitz',
|
|
} })
|
|
eq('~/frobnitz/nvim', t.fix_slashes(fn.stdpath('cache')))
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('returns a List', function()
|
|
-- Some OS specific variables the system would have set.
|
|
local function base_env()
|
|
if is_os('win') then
|
|
return {
|
|
HOME = 'C:\\Users\\docwhat', -- technically, is not a usual PATH
|
|
HOMEDRIVE = 'C:',
|
|
HOMEPATH = '\\Users\\docwhat',
|
|
LOCALAPPDATA = 'C:\\Users\\docwhat\\AppData\\Local',
|
|
NVIM_LOG_FILE = testlog,
|
|
TEMP = 'C:\\Users\\docwhat\\AppData\\Local\\Temp',
|
|
TMPDIR = 'C:\\Users\\docwhat\\AppData\\Local\\Temp',
|
|
TMP = 'C:\\Users\\docwhat\\AppData\\Local\\Temp',
|
|
}
|
|
else
|
|
return {
|
|
HOME = '/home/docwhat',
|
|
HOMEDRIVE = 'HOMEDRIVE-should-be-ignored',
|
|
HOMEPATH = 'HOMEPATH-should-be-ignored',
|
|
LOCALAPPDATA = 'LOCALAPPDATA-should-be-ignored',
|
|
NVIM_LOG_FILE = testlog,
|
|
TEMP = 'TEMP-should-be-ignored',
|
|
TMPDIR = 'TMPDIR-should-be-ignored',
|
|
TMP = 'TMP-should-be-ignored',
|
|
}
|
|
end
|
|
end
|
|
|
|
local function set_paths_via_system(var_name, paths)
|
|
local env = base_env()
|
|
env[var_name] = table.concat(paths, env_sep)
|
|
clear({ env = env })
|
|
end
|
|
|
|
local function set_paths_at_runtime(var_name, paths)
|
|
clear({ env = base_env() })
|
|
api.nvim_set_var('env_val', table.concat(paths, env_sep))
|
|
command(('let $%s=g:env_val'):format(var_name))
|
|
end
|
|
|
|
local function behaves_like_dir_list_env(msg, stdpath_arg, env_var_name, paths, expected_paths)
|
|
describe(msg, function()
|
|
it('set via system', function()
|
|
set_paths_via_system(env_var_name, paths)
|
|
eq(expected_paths, t.fix_slashes(fn.stdpath(stdpath_arg)))
|
|
if not is_os('win') then
|
|
assert_log('$TMPDIR tempdir not a directory.*TMPDIR%-should%-be%-ignored', testlog, 100)
|
|
end
|
|
end)
|
|
|
|
it('set at runtime', function()
|
|
set_paths_at_runtime(env_var_name, paths)
|
|
eq(expected_paths, t.fix_slashes(fn.stdpath(stdpath_arg)))
|
|
if not is_os('win') then
|
|
assert_log('$TMPDIR tempdir not a directory.*TMPDIR%-should%-be%-ignored', testlog, 100)
|
|
end
|
|
end)
|
|
end)
|
|
end
|
|
|
|
describe('with "config_dirs"', function()
|
|
behaves_like_dir_list_env(
|
|
'handles XDG_CONFIG_DIRS with one path',
|
|
'config_dirs',
|
|
'XDG_CONFIG_DIRS',
|
|
{
|
|
t.fix_slashes('/home/docwhat/.config'),
|
|
},
|
|
{
|
|
t.fix_slashes('/home/docwhat/.config/nvim'),
|
|
}
|
|
)
|
|
|
|
behaves_like_dir_list_env(
|
|
'handles XDG_CONFIG_DIRS with two paths',
|
|
'config_dirs',
|
|
'XDG_CONFIG_DIRS',
|
|
{
|
|
t.fix_slashes('/home/docwhat/.config'),
|
|
t.fix_slashes('/etc/config'),
|
|
},
|
|
{
|
|
t.fix_slashes('/home/docwhat/.config/nvim'),
|
|
t.fix_slashes('/etc/config/nvim'),
|
|
}
|
|
)
|
|
|
|
behaves_like_dir_list_env(
|
|
"doesn't expand $VAR and $IBLES",
|
|
'config_dirs',
|
|
'XDG_CONFIG_DIRS',
|
|
{ '$HOME', '$TMP' },
|
|
{
|
|
t.fix_slashes('$HOME/nvim'),
|
|
t.fix_slashes('$TMP/nvim'),
|
|
}
|
|
)
|
|
|
|
behaves_like_dir_list_env("doesn't expand ~/", 'config_dirs', 'XDG_CONFIG_DIRS', {
|
|
t.fix_slashes('~/.oldconfig'),
|
|
t.fix_slashes('~/.olderconfig'),
|
|
}, {
|
|
t.fix_slashes('~/.oldconfig/nvim'),
|
|
t.fix_slashes('~/.olderconfig/nvim'),
|
|
})
|
|
end)
|
|
|
|
describe('with "data_dirs"', function()
|
|
behaves_like_dir_list_env('knows XDG_DATA_DIRS with one path', 'data_dirs', 'XDG_DATA_DIRS', {
|
|
t.fix_slashes('/home/docwhat/.data'),
|
|
}, {
|
|
t.fix_slashes('/home/docwhat/.data/nvim'),
|
|
})
|
|
|
|
behaves_like_dir_list_env(
|
|
'knows XDG_DATA_DIRS with two paths',
|
|
'data_dirs',
|
|
'XDG_DATA_DIRS',
|
|
{
|
|
t.fix_slashes('/home/docwhat/.data'),
|
|
t.fix_slashes('/etc/local'),
|
|
},
|
|
{
|
|
t.fix_slashes('/home/docwhat/.data/nvim'),
|
|
t.fix_slashes('/etc/local/nvim'),
|
|
}
|
|
)
|
|
|
|
behaves_like_dir_list_env(
|
|
"doesn't expand $VAR and $IBLES",
|
|
'data_dirs',
|
|
'XDG_DATA_DIRS',
|
|
{ '$HOME', '$TMP' },
|
|
{
|
|
t.fix_slashes('$HOME/nvim'),
|
|
t.fix_slashes('$TMP/nvim'),
|
|
}
|
|
)
|
|
|
|
behaves_like_dir_list_env("doesn't expand ~/", 'data_dirs', 'XDG_DATA_DIRS', {
|
|
t.fix_slashes('~/.oldconfig'),
|
|
t.fix_slashes('~/.olderconfig'),
|
|
}, {
|
|
t.fix_slashes('~/.oldconfig/nvim'),
|
|
t.fix_slashes('~/.olderconfig/nvim'),
|
|
})
|
|
end)
|
|
end)
|
|
|
|
describe('errors', function()
|
|
before_each(clear)
|
|
|
|
it('on unknown strings', function()
|
|
eq('Vim(call):E6100: "capybara" is not a valid stdpath', exc_exec('call stdpath("capybara")'))
|
|
eq('Vim(call):E6100: "" is not a valid stdpath', exc_exec('call stdpath("")'))
|
|
eq('Vim(call):E6100: "23" is not a valid stdpath', exc_exec('call stdpath(23)'))
|
|
end)
|
|
|
|
it('on non-strings', function()
|
|
eq('Vim(call):E731: Using a Dictionary as a String', exc_exec('call stdpath({"eris": 23})'))
|
|
eq('Vim(call):E730: Using a List as a String', exc_exec('call stdpath([23])'))
|
|
end)
|
|
end)
|
|
end)
|