mirror of
https://github.com/neovim/neovim.git
synced 2024-12-20 11:15:14 -07:00
2dc69700ec
- Unittest should contain substring '_spec' in filename. - This is the simplest way to use both lua and moonscript tests. - This prevents running of non-test scripts from test folder.
291 lines
10 KiB
Plaintext
291 lines
10 KiB
Plaintext
{:cimport, :internalize, :eq, :neq, :ffi, :lib, :cstr, :to_cstr} = require 'test.unit.helpers'
|
|
require 'lfs'
|
|
|
|
path = cimport './src/nvim/path.h'
|
|
|
|
-- import constants parsed by ffi
|
|
{:kEqualFiles, :kDifferentFiles, :kBothFilesMissing, :kOneFileMissing, :kEqualFileNames} = path
|
|
NULL = ffi.cast 'void*', 0
|
|
OK = 1
|
|
FAIL = 0
|
|
|
|
describe 'path function', ->
|
|
describe 'path_full_compare', ->
|
|
|
|
path_full_compare = (s1, s2, cn) ->
|
|
s1 = to_cstr s1
|
|
s2 = to_cstr s2
|
|
path.path_full_compare s1, s2, cn or 0
|
|
|
|
f1 = 'f1.o'
|
|
f2 = 'f2.o'
|
|
|
|
before_each ->
|
|
-- create the three files that will be used in this spec
|
|
(io.open f1, 'w').close!
|
|
(io.open f2, 'w').close!
|
|
|
|
after_each ->
|
|
os.remove f1
|
|
os.remove f2
|
|
|
|
it 'returns kEqualFiles when passed the same file', ->
|
|
eq kEqualFiles, (path_full_compare f1, f1)
|
|
|
|
it 'returns kEqualFileNames when files that dont exist and have same name', ->
|
|
eq kEqualFileNames, (path_full_compare 'null.txt', 'null.txt', true)
|
|
|
|
it 'returns kBothFilesMissing when files that dont exist', ->
|
|
eq kBothFilesMissing, (path_full_compare 'null.txt', 'null.txt')
|
|
|
|
it 'returns kDifferentFiles when passed different files', ->
|
|
eq kDifferentFiles, (path_full_compare f1, f2)
|
|
eq kDifferentFiles, (path_full_compare f2, f1)
|
|
|
|
it 'returns kOneFileMissing if only one does not exist', ->
|
|
eq kOneFileMissing, (path_full_compare f1, 'null.txt')
|
|
eq kOneFileMissing, (path_full_compare 'null.txt', f1)
|
|
|
|
describe 'path_tail', ->
|
|
path_tail = (file) ->
|
|
res = path.path_tail (to_cstr file)
|
|
neq NULL, res
|
|
ffi.string res
|
|
|
|
it 'returns the tail of a given file path', ->
|
|
eq 'file.txt', path_tail 'directory/file.txt'
|
|
|
|
it 'returns an empty string if file ends in a slash', ->
|
|
eq '', path_tail 'directory/'
|
|
|
|
describe 'path_tail_with_sep', ->
|
|
path_tail_with_sep = (file) ->
|
|
res = path.path_tail_with_sep (to_cstr file)
|
|
neq NULL, res
|
|
ffi.string res
|
|
|
|
it 'returns the tail of a file together with its separator', ->
|
|
eq '///file.txt', path_tail_with_sep 'directory///file.txt'
|
|
|
|
it 'returns an empty string when given an empty file name', ->
|
|
eq '', path_tail_with_sep ''
|
|
|
|
it 'returns only the separator if there is a trailing separator', ->
|
|
eq '/', path_tail_with_sep 'some/directory/'
|
|
|
|
it 'cuts a leading separator', ->
|
|
eq 'file.txt', path_tail_with_sep '/file.txt'
|
|
eq '', path_tail_with_sep '/'
|
|
|
|
it 'returns the whole file name if there is no separator', ->
|
|
eq 'file.txt', path_tail_with_sep 'file.txt'
|
|
|
|
describe 'path_next_component', ->
|
|
path_next_component = (file) ->
|
|
res = path.path_next_component (to_cstr file)
|
|
neq NULL, res
|
|
ffi.string res
|
|
|
|
it 'returns', ->
|
|
eq 'directory/file.txt', path_next_component 'some/directory/file.txt'
|
|
|
|
it 'returns empty string if given file contains no separator', ->
|
|
eq '', path_next_component 'file.txt'
|
|
|
|
describe 'path_shorten_fname', ->
|
|
it 'returns NULL if `full_path` is NULL', ->
|
|
dir = to_cstr 'some/directory/file.txt'
|
|
eq NULL, (path.path_shorten_fname NULL, dir)
|
|
|
|
it 'returns NULL if the path and dir does not match', ->
|
|
dir = to_cstr 'not/the/same'
|
|
full = to_cstr 'as/this.txt'
|
|
eq NULL, (path.path_shorten_fname full, dir)
|
|
|
|
it 'returns NULL if the path is not separated properly', ->
|
|
dir = to_cstr 'some/very/long/'
|
|
full = to_cstr 'some/very/long/directory/file.txt'
|
|
eq NULL, (path.path_shorten_fname full, dir)
|
|
|
|
it 'shortens the filename if `dir_name` is the start of `full_path`', ->
|
|
full = to_cstr 'some/very/long/directory/file.txt'
|
|
dir = to_cstr 'some/very/long'
|
|
eq 'directory/file.txt', (ffi.string path.path_shorten_fname full, dir)
|
|
|
|
describe 'path_shorten_fname_if_possible', ->
|
|
cwd = lfs.currentdir!
|
|
before_each ->
|
|
lfs.mkdir 'ut_directory'
|
|
after_each ->
|
|
lfs.chdir cwd
|
|
lfs.rmdir 'ut_directory'
|
|
|
|
describe 'path_shorten_fname_if_possible', ->
|
|
it 'returns shortened path if possible', ->
|
|
lfs.chdir 'ut_directory'
|
|
full = to_cstr lfs.currentdir! .. '/subdir/file.txt'
|
|
eq 'subdir/file.txt', (ffi.string path.path_shorten_fname_if_possible full)
|
|
|
|
it 'returns `full_path` if a shorter version is not possible', ->
|
|
old = lfs.currentdir!
|
|
lfs.chdir 'ut_directory'
|
|
full = old .. '/subdir/file.txt'
|
|
eq full, (ffi.string path.path_shorten_fname_if_possible to_cstr full)
|
|
|
|
it 'returns NULL if `full_path` is NULL', ->
|
|
eq NULL, (path.path_shorten_fname_if_possible NULL)
|
|
|
|
describe 'more path function', ->
|
|
setup ->
|
|
lfs.mkdir 'unit-test-directory'
|
|
(io.open 'unit-test-directory/test.file', 'w').close!
|
|
|
|
-- Since the tests are executed, they are called by an executable. We use
|
|
-- that executable for several asserts.
|
|
export absolute_executable = arg[0]
|
|
|
|
-- Split absolute_executable into a directory and the actual file name for
|
|
-- later usage.
|
|
export directory, executable_name = string.match(absolute_executable, '^(.*)/(.*)$')
|
|
|
|
teardown ->
|
|
os.remove 'unit-test-directory/test.file'
|
|
lfs.rmdir 'unit-test-directory'
|
|
|
|
describe 'vim_FullName', ->
|
|
vim_FullName = (filename, buffer, length, force) ->
|
|
filename = to_cstr filename
|
|
path.vim_FullName filename, buffer, length, force
|
|
|
|
before_each ->
|
|
-- Create empty string buffer which will contain the resulting path.
|
|
export len = (string.len lfs.currentdir!) + 33
|
|
export buffer = cstr len, ''
|
|
|
|
it 'fails if given filename is NULL', ->
|
|
force_expansion = 1
|
|
result = path.vim_FullName NULL, buffer, len, force_expansion
|
|
eq FAIL, result
|
|
|
|
it 'uses the filename if the filename is a URL', ->
|
|
force_expansion = 1
|
|
filename = 'http://www.neovim.org'
|
|
result = vim_FullName filename, buffer, len, force_expansion
|
|
eq filename, (ffi.string buffer)
|
|
eq OK, result
|
|
|
|
it 'fails and uses filename if given filename contains non-existing directory', ->
|
|
force_expansion = 1
|
|
filename = 'non_existing_dir/test.file'
|
|
result = vim_FullName filename, buffer, len, force_expansion
|
|
eq filename, (ffi.string buffer)
|
|
eq FAIL, result
|
|
|
|
it 'concatenates given filename if it does not contain a slash', ->
|
|
force_expansion = 1
|
|
result = vim_FullName 'test.file', buffer, len, force_expansion
|
|
expected = lfs.currentdir! .. '/test.file'
|
|
eq expected, (ffi.string buffer)
|
|
eq OK, result
|
|
|
|
it 'concatenates given filename if it is a directory but does not contain a
|
|
slash', ->
|
|
force_expansion = 1
|
|
result = vim_FullName '..', buffer, len, force_expansion
|
|
expected = lfs.currentdir! .. '/..'
|
|
eq expected, (ffi.string buffer)
|
|
eq OK, result
|
|
|
|
-- Is it possible for every developer to enter '..' directory while running
|
|
-- the unit tests? Which other directory would be better?
|
|
it 'enters given directory (instead of just concatenating the strings) if
|
|
possible and if path contains a slash', ->
|
|
force_expansion = 1
|
|
result = vim_FullName '../test.file', buffer, len, force_expansion
|
|
old_dir = lfs.currentdir!
|
|
lfs.chdir '..'
|
|
expected = lfs.currentdir! .. '/test.file'
|
|
lfs.chdir old_dir
|
|
eq expected, (ffi.string buffer)
|
|
eq OK, result
|
|
|
|
it 'just copies the path if it is already absolute and force=0', ->
|
|
force_expansion = 0
|
|
absolute_path = '/absolute/path'
|
|
result = vim_FullName absolute_path, buffer, len, force_expansion
|
|
eq absolute_path, (ffi.string buffer)
|
|
eq OK, result
|
|
|
|
it 'fails and uses filename when the path is relative to HOME', ->
|
|
force_expansion = 1
|
|
absolute_path = '~/home.file'
|
|
result = vim_FullName absolute_path, buffer, len, force_expansion
|
|
eq absolute_path, (ffi.string buffer)
|
|
eq FAIL, result
|
|
|
|
it 'works with some "normal" relative path with directories', ->
|
|
force_expansion = 1
|
|
result = vim_FullName 'unit-test-directory/test.file', buffer, len, force_expansion
|
|
eq OK, result
|
|
eq lfs.currentdir! .. '/unit-test-directory/test.file', (ffi.string buffer)
|
|
|
|
it 'does not modify the given filename', ->
|
|
force_expansion = 1
|
|
filename = to_cstr 'unit-test-directory/test.file'
|
|
-- Don't use the wrapper here but pass a cstring directly to the c
|
|
-- function.
|
|
result = path.vim_FullName filename, buffer, len, force_expansion
|
|
eq lfs.currentdir! .. '/unit-test-directory/test.file', (ffi.string buffer)
|
|
eq 'unit-test-directory/test.file', (ffi.string filename)
|
|
eq OK, result
|
|
|
|
describe 'append_path', ->
|
|
it 'joins given paths with a slash', ->
|
|
path1 = cstr 100, 'path1'
|
|
to_append = to_cstr 'path2'
|
|
eq OK, (path.append_path path1, to_append, 100)
|
|
eq "path1/path2", (ffi.string path1)
|
|
|
|
it 'joins given paths without adding an unnecessary slash', ->
|
|
path1 = cstr 100, 'path1/'
|
|
to_append = to_cstr 'path2'
|
|
eq OK, path.append_path path1, to_append, 100
|
|
eq "path1/path2", (ffi.string path1)
|
|
|
|
it 'fails and uses filename if there is not enough space left for to_append', ->
|
|
path1 = cstr 11, 'path1/'
|
|
to_append = to_cstr 'path2'
|
|
eq FAIL, (path.append_path path1, to_append, 11)
|
|
|
|
it 'does not append a slash if to_append is empty', ->
|
|
path1 = cstr 6, 'path1'
|
|
to_append = to_cstr ''
|
|
eq OK, (path.append_path path1, to_append, 6)
|
|
eq 'path1', (ffi.string path1)
|
|
|
|
it 'does not append unnecessary dots', ->
|
|
path1 = cstr 6, 'path1'
|
|
to_append = to_cstr '.'
|
|
eq OK, (path.append_path path1, to_append, 6)
|
|
eq 'path1', (ffi.string path1)
|
|
|
|
it 'copies to_append to path, if path is empty', ->
|
|
path1 = cstr 7, ''
|
|
to_append = to_cstr '/path2'
|
|
eq OK, (path.append_path path1, to_append, 7)
|
|
eq '/path2', (ffi.string path1)
|
|
|
|
describe 'path_is_absolute_path', ->
|
|
path_is_absolute_path = (filename) ->
|
|
filename = to_cstr filename
|
|
path.path_is_absolute_path filename
|
|
|
|
it 'returns true if filename starts with a slash', ->
|
|
eq OK, path_is_absolute_path '/some/directory/'
|
|
|
|
it 'returns true if filename starts with a tilde', ->
|
|
eq OK, path_is_absolute_path '~/in/my/home~/directory'
|
|
|
|
it 'returns false if filename starts not with slash nor tilde', ->
|
|
eq FAIL, path_is_absolute_path 'not/in/my/home~/directory'
|