Problem: Using common name in tests leads to flaky tests.
Solution: Rename files and directories to be more specific.
call assert_equal('++', g:val)
" Also get BufEnter when editing a directory
- call mkdir('Xdir')
- split Xdir
+ call mkdir('Xbufenterdir')
+ split Xbufenterdir
call assert_equal('+++', g:val)
" On MS-Windows we can't edit the directory, make sure we wipe the right
" buffer.
- bwipe! Xdir
- call delete('Xdir', 'd')
+ bwipe! Xbufenterdir
+ call delete('Xbufenterdir', 'd')
au! BufEnter
" Editing a "nofile" buffer doesn't read the file but does trigger BufEnter
endfunc
func Test_autocmd_in_try_block()
- call mkdir('Xdir')
+ call mkdir('Xintrydir')
au BufEnter * let g:fname = expand('%')
try
- edit Xdir/
+ edit Xintrydir/
endtry
- call assert_match('Xdir', g:fname)
+ call assert_match('Xintrydir', g:fname)
unlet g:fname
au! BufEnter
- call delete('Xdir', 'rf')
+ call delete('Xintrydir', 'rf')
endfunc
func Test_autocmd_SafeState()
" Test for chdir()
func Test_chdir_func()
let topdir = getcwd()
- call mkdir('Xdir/y/z', 'p')
+ call mkdir('Xchdir/y/z', 'p')
" Create a few tabpages and windows with different directories
new
- cd Xdir
+ cd Xchdir
tabnew
tcd y
below new
lcd z
tabfirst
- call assert_match('^\[global\] .*/Xdir$', trim(execute('verbose pwd')))
+ call assert_match('^\[global\] .*/Xchdir$', trim(execute('verbose pwd')))
call chdir('..')
call assert_equal('y', fnamemodify(getcwd(1, 2), ':t'))
call assert_equal('z', fnamemodify(3->getcwd(2), ':t'))
tabnext | wincmd t
call assert_match('^\[tabpage\] .*/y$', trim(execute('verbose pwd')))
eval '..'->chdir()
- call assert_equal('Xdir', fnamemodify(getcwd(1, 2), ':t'))
- call assert_equal('Xdir', fnamemodify(getcwd(2, 2), ':t'))
+ call assert_equal('Xchdir', fnamemodify(getcwd(1, 2), ':t'))
+ call assert_equal('Xchdir', fnamemodify(getcwd(2, 2), ':t'))
call assert_equal('z', fnamemodify(getcwd(3, 2), ':t'))
call assert_equal('testdir', fnamemodify(getcwd(1, 1), ':t'))
3wincmd w
call assert_match('^\[window\] .*/z$', trim(execute('verbose pwd')))
call chdir('..')
- call assert_equal('Xdir', fnamemodify(getcwd(1, 2), ':t'))
- call assert_equal('Xdir', fnamemodify(getcwd(2, 2), ':t'))
+ call assert_equal('Xchdir', fnamemodify(getcwd(1, 2), ':t'))
+ call assert_equal('Xchdir', fnamemodify(getcwd(2, 2), ':t'))
call assert_equal('y', fnamemodify(getcwd(3, 2), ':t'))
call assert_equal('testdir', fnamemodify(getcwd(1, 1), ':t'))
only | tabonly
call chdir(topdir)
- call delete('Xdir', 'rf')
+ call delete('Xchdir', 'rf')
endfunc
" Test for changing to the previous directory '-'
func Test_prev_dir()
let topdir = getcwd()
- call mkdir('Xdir/a/b/c', 'p')
+ call mkdir('Xprevdir/a/b/c', 'p')
" Create a few tabpages and windows with different directories
new | only
tabnew | new
tabnew
tabfirst
- cd Xdir
+ cd Xprevdir
tabnext | wincmd t
tcd a
wincmd w
" Check the directory of all the windows
tabfirst
- call assert_equal('Xdir', fnamemodify(getcwd(), ':t'))
+ call assert_equal('Xprevdir', fnamemodify(getcwd(), ':t'))
tabnext | wincmd t
call assert_equal('a', fnamemodify(getcwd(), ':t'))
wincmd w
" Check the directory of all the windows
tabfirst
- call assert_equal('Xdir', fnamemodify(getcwd(), ':t'))
+ call assert_equal('Xprevdir', fnamemodify(getcwd(), ':t'))
tabnext | wincmd t
call assert_equal('a', fnamemodify(getcwd(), ':t'))
wincmd w
only | tabonly
call chdir(topdir)
- call delete('Xdir', 'rf')
+ call delete('Xprevdir', 'rf')
endfunc
func Test_lcd_split()
let text = readfile('Xlog')
call assert_match("hello there", text[1])
call assert_match("%s%s", text[2])
- call mkdir("Xdir1")
- call assert_fails("call ch_logfile('Xdir1')", 'E484:')
- cal delete("Xdir1", 'd')
+ call mkdir("Xchlogdir1")
+ call assert_fails("call ch_logfile('Xchlogdir1')", 'E484:')
+ cal delete("Xchlogdir1", 'd')
call delete('Xlog')
endfunc
" Test for 'include' without \zs or \ze
func Test_checkpath1()
- call mkdir("Xdir1/dir2", "p")
- call writefile(['#include "bar.a"'], 'Xdir1/dir2/foo.a')
- call writefile(['#include "baz.a"'], 'Xdir1/dir2/bar.a')
- call writefile(['#include "foo.a"'], 'Xdir1/dir2/baz.a')
+ call mkdir("Xcheckdir1/dir2", "p")
+ call writefile(['#include "bar.a"'], 'Xcheckdir1/dir2/foo.a')
+ call writefile(['#include "baz.a"'], 'Xcheckdir1/dir2/bar.a')
+ call writefile(['#include "foo.a"'], 'Xcheckdir1/dir2/baz.a')
call writefile(['#include <foo.a>'], 'Xbase.a')
edit Xbase.a
- set path=Xdir1/dir2
+ set path=Xcheckdir1/dir2
let res = split(execute("checkpath!"), "\n")
call assert_equal([
\ '--- Included files in path ---',
- \ 'Xdir1/dir2/foo.a',
- \ 'Xdir1/dir2/foo.a -->',
- \ ' Xdir1/dir2/bar.a',
- \ ' Xdir1/dir2/bar.a -->',
- \ ' Xdir1/dir2/baz.a',
- \ ' Xdir1/dir2/baz.a -->',
+ \ 'Xcheckdir1/dir2/foo.a',
+ \ 'Xcheckdir1/dir2/foo.a -->',
+ \ ' Xcheckdir1/dir2/bar.a',
+ \ ' Xcheckdir1/dir2/bar.a -->',
+ \ ' Xcheckdir1/dir2/baz.a',
+ \ ' Xcheckdir1/dir2/baz.a -->',
\ ' "foo.a" (Already listed)'], res)
enew
call delete("./Xbase.a")
- call delete("Xdir1", "rf")
+ call delete("Xcheckdir1", "rf")
set path&
endfunc
" Test for 'include' with \zs and \ze
func Test_checkpath2()
- call mkdir("Xdir1/dir2", "p")
- call writefile(['%inc /bar/'], 'Xdir1/dir2/foo.b')
- call writefile(['%inc /baz/'], 'Xdir1/dir2/bar.b')
- call writefile(['%inc /foo/'], 'Xdir1/dir2/baz.b')
+ call mkdir("Xcheckdir2/dir2", "p")
+ call writefile(['%inc /bar/'], 'Xcheckdir2/dir2/foo.b')
+ call writefile(['%inc /baz/'], 'Xcheckdir2/dir2/bar.b')
+ call writefile(['%inc /foo/'], 'Xcheckdir2/dir2/baz.b')
call writefile(['%inc /foo/'], 'Xbase.b')
let &include='^\s*%inc\s*/\zs[^/]\+\ze'
let &includeexpr='DotsToSlashes()'
edit Xbase.b
- set path=Xdir1/dir2
+ set path=Xcheckdir2/dir2
let res = split(execute("checkpath!"), "\n")
call assert_equal([
\ '--- Included files in path ---',
- \ 'Xdir1/dir2/foo.b',
- \ 'Xdir1/dir2/foo.b -->',
- \ ' Xdir1/dir2/bar.b',
- \ ' Xdir1/dir2/bar.b -->',
- \ ' Xdir1/dir2/baz.b',
- \ ' Xdir1/dir2/baz.b -->',
+ \ 'Xcheckdir2/dir2/foo.b',
+ \ 'Xcheckdir2/dir2/foo.b -->',
+ \ ' Xcheckdir2/dir2/bar.b',
+ \ ' Xcheckdir2/dir2/bar.b -->',
+ \ ' Xcheckdir2/dir2/baz.b',
+ \ ' Xcheckdir2/dir2/baz.b -->',
\ ' foo (Already listed)'], res)
enew
call delete("./Xbase.b")
- call delete("Xdir1", "rf")
+ call delete("Xcheckdir2", "rf")
set path&
set include&
set includeexpr&
" Test for 'include' with \zs and no \ze
func Test_checkpath3()
- call mkdir("Xdir1/dir2", "p")
- call writefile(['%inc bar.c'], 'Xdir1/dir2/foo.c')
- call writefile(['%inc baz.c'], 'Xdir1/dir2/bar.c')
- call writefile(['%inc foo.c'], 'Xdir1/dir2/baz.c')
- call writefile(['%inc foo.c'], 'Xdir1/dir2/FALSE.c')
+ call mkdir("Xcheckdir3/dir2", "p")
+ call writefile(['%inc bar.c'], 'Xcheckdir3/dir2/foo.c')
+ call writefile(['%inc baz.c'], 'Xcheckdir3/dir2/bar.c')
+ call writefile(['%inc foo.c'], 'Xcheckdir3/dir2/baz.c')
+ call writefile(['%inc foo.c'], 'Xcheckdir3/dir2/FALSE.c')
call writefile(['%inc FALSE.c foo.c'], 'Xbase.c')
let &include='^\s*%inc\s*\%([[:upper:]][^[:space:]]*\s\+\)\?\zs\S\+\ze'
let &includeexpr='StripNewlineChar()'
edit Xbase.c
- set path=Xdir1/dir2
+ set path=Xcheckdir3/dir2
let res = split(execute("checkpath!"), "\n")
call assert_equal([
\ '--- Included files in path ---',
- \ 'Xdir1/dir2/foo.c',
- \ 'Xdir1/dir2/foo.c -->',
- \ ' Xdir1/dir2/bar.c',
- \ ' Xdir1/dir2/bar.c -->',
- \ ' Xdir1/dir2/baz.c',
- \ ' Xdir1/dir2/baz.c -->',
+ \ 'Xcheckdir3/dir2/foo.c',
+ \ 'Xcheckdir3/dir2/foo.c -->',
+ \ ' Xcheckdir3/dir2/bar.c',
+ \ ' Xcheckdir3/dir2/bar.c -->',
+ \ ' Xcheckdir3/dir2/baz.c',
+ \ ' Xcheckdir3/dir2/baz.c -->',
\ ' foo.c (Already listed)'], res)
enew
call delete("./Xbase.c")
- call delete("Xdir1", "rf")
+ call delete("Xcheckdir3", "rf")
set path&
set include&
set includeexpr&
endfunc
func Test_complete_wildmenu()
- call mkdir('Xdir1/Xdir2', 'p')
- call writefile(['testfile1'], 'Xdir1/Xtestfile1')
- call writefile(['testfile2'], 'Xdir1/Xtestfile2')
- call writefile(['testfile3'], 'Xdir1/Xdir2/Xtestfile3')
- call writefile(['testfile3'], 'Xdir1/Xdir2/Xtestfile4')
+ call mkdir('Xwilddir1/Xdir2', 'p')
+ call writefile(['testfile1'], 'Xwilddir1/Xtestfile1')
+ call writefile(['testfile2'], 'Xwilddir1/Xtestfile2')
+ call writefile(['testfile3'], 'Xwilddir1/Xdir2/Xtestfile3')
+ call writefile(['testfile3'], 'Xwilddir1/Xdir2/Xtestfile4')
set wildmenu
" Pressing <Tab> completes, and moves to next files when pressing again.
- call feedkeys(":e Xdir1/\<Tab>\<Tab>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Tab>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
- call feedkeys(":e Xdir1/\<Tab>\<Tab>\<Tab>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Tab>\<Tab>\<CR>", 'tx')
call assert_equal('testfile2', getline(1))
" <S-Tab> is like <Tab> but begin with the last match and then go to
" previous.
- call feedkeys(":e Xdir1/Xtest\<S-Tab>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/Xtest\<S-Tab>\<CR>", 'tx')
call assert_equal('testfile2', getline(1))
- call feedkeys(":e Xdir1/Xtest\<S-Tab>\<S-Tab>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/Xtest\<S-Tab>\<S-Tab>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
" <Left>/<Right> to move to previous/next file.
- call feedkeys(":e Xdir1/\<Tab>\<Right>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Right>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
- call feedkeys(":e Xdir1/\<Tab>\<Right>\<Right>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Right>\<Right>\<CR>", 'tx')
call assert_equal('testfile2', getline(1))
- call feedkeys(":e Xdir1/\<Tab>\<Right>\<Right>\<Left>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Right>\<Right>\<Left>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
" <Up>/<Down> to go up/down directories.
- call feedkeys(":e Xdir1/\<Tab>\<Down>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Down>\<CR>", 'tx')
call assert_equal('testfile3', getline(1))
- call feedkeys(":e Xdir1/\<Tab>\<Down>\<Up>\<Right>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<Down>\<Up>\<Right>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
" this fails in some Unix GUIs, not sure why
set wildcharm=<C-Z>
cnoremap <C-J> <Down><C-Z>
cnoremap <C-K> <Up><C-Z>
- call feedkeys(":e Xdir1/\<Tab>\<C-J>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<C-J>\<CR>", 'tx')
call assert_equal('testfile3', getline(1))
- call feedkeys(":e Xdir1/\<Tab>\<C-J>\<C-K>\<CR>", 'tx')
+ call feedkeys(":e Xwilddir1/\<Tab>\<C-J>\<C-K>\<CR>", 'tx')
call assert_equal('testfile1', getline(1))
set wildcharm=0
cunmap <C-J>
" Test for canceling the wild menu by adding a character
redrawstatus
- call feedkeys(":e Xdir1/\<Tab>x\<C-B>\"\<CR>", 'xt')
- call assert_equal('"e Xdir1/Xdir2/x', @:)
+ call feedkeys(":e Xwilddir1/\<Tab>x\<C-B>\"\<CR>", 'xt')
+ call assert_equal('"e Xwilddir1/Xdir2/x', @:)
" Completion using a relative path
- cd Xdir1/Xdir2
+ cd Xwilddir1/Xdir2
call feedkeys(":e ../\<Tab>\<Right>\<Down>\<C-A>\<C-B>\"\<CR>", 'tx')
call assert_equal('"e Xtestfile3 Xtestfile4', @:)
cd -
" test for wildmenumode()
cnoremap <expr> <F2> wildmenumode()
- call feedkeys(":cd Xdir\<Tab>\<F2>\<C-B>\"\<CR>", 'tx')
- call assert_equal('"cd Xdir1/0', @:)
- call feedkeys(":e Xdir1/\<Tab>\<F2>\<C-B>\"\<CR>", 'tx')
- call assert_equal('"e Xdir1/Xdir2/1', @:)
+ call feedkeys(":cd Xwilddir\<Tab>\<F2>\<C-B>\"\<CR>", 'tx')
+ call assert_equal('"cd Xwilddir1/0', @:)
+ call feedkeys(":e Xwilddir1/\<Tab>\<F2>\<C-B>\"\<CR>", 'tx')
+ call assert_equal('"e Xwilddir1/Xdir2/1', @:)
cunmap <F2>
" Test for canceling the wild menu by pressing <PageDown> or <PageUp>.
" cleanup
%bwipe
- call delete('Xdir1', 'rf')
+ call delete('Xwilddir1', 'rf')
set nowildmenu
endfunc
func Test_wildmenu_dirstack()
CheckUnix
%bw!
- call mkdir('Xdir1/dir2/dir3/dir4', 'p')
- call writefile([], 'Xdir1/file1_1.txt')
- call writefile([], 'Xdir1/file1_2.txt')
- call writefile([], 'Xdir1/dir2/file2_1.txt')
- call writefile([], 'Xdir1/dir2/file2_2.txt')
- call writefile([], 'Xdir1/dir2/dir3/file3_1.txt')
- call writefile([], 'Xdir1/dir2/dir3/file3_2.txt')
- call writefile([], 'Xdir1/dir2/dir3/dir4/file4_1.txt')
- call writefile([], 'Xdir1/dir2/dir3/dir4/file4_2.txt')
+ call mkdir('Xwildmenu/dir2/dir3/dir4', 'p')
+ call writefile([], 'Xwildmenu/file1_1.txt')
+ call writefile([], 'Xwildmenu/file1_2.txt')
+ call writefile([], 'Xwildmenu/dir2/file2_1.txt')
+ call writefile([], 'Xwildmenu/dir2/file2_2.txt')
+ call writefile([], 'Xwildmenu/dir2/dir3/file3_1.txt')
+ call writefile([], 'Xwildmenu/dir2/dir3/file3_2.txt')
+ call writefile([], 'Xwildmenu/dir2/dir3/dir4/file4_1.txt')
+ call writefile([], 'Xwildmenu/dir2/dir3/dir4/file4_2.txt')
set wildmenu
- cd Xdir1/dir2/dir3/dir4
+ cd Xwildmenu/dir2/dir3/dir4
call feedkeys(":e \<Tab>\<C-B>\"\<CR>", 'xt')
call assert_equal('"e file4_1.txt', @:)
call feedkeys(":e \<Tab>\<Up>\<C-B>\"\<CR>", 'xt')
call feedkeys(":e \<Tab>\<Up>\<Up>\<Down>\<Down>\<C-B>\"\<CR>", 'xt')
call assert_equal('"e ../../dir3/dir4/file4_1.txt', @:)
cd -
- call feedkeys(":e Xdir1/\<Tab>\<Down>\<Down>\<Down>\<C-B>\"\<CR>", 'xt')
- call assert_equal('"e Xdir1/dir2/dir3/dir4/file4_1.txt', @:)
+ call feedkeys(":e Xwildmenu/\<Tab>\<Down>\<Down>\<Down>\<C-B>\"\<CR>", 'xt')
+ call assert_equal('"e Xwildmenu/dir2/dir3/dir4/file4_1.txt', @:)
- call delete('Xdir1', 'rf')
+ call delete('Xwildmenu', 'rf')
set wildmenu&
endfunc
endfunc
func Test_dir_delete()
- call mkdir('Xdir1')
- call assert_true(isdirectory('Xdir1'))
- call assert_equal(0, delete('Xdir1', 'd'))
- call assert_false(isdirectory('Xdir1'))
- call assert_equal(-1, delete('Xdir1', 'd'))
+ call mkdir('Xdirdel')
+ call assert_true(isdirectory('Xdirdel'))
+ call assert_equal(0, delete('Xdirdel', 'd'))
+ call assert_false(isdirectory('Xdirdel'))
+ call assert_equal(-1, delete('Xdirdel', 'd'))
endfunc
func Test_recursive_delete()
- call mkdir('Xdir1')
- call mkdir('Xdir1/subdir')
- call mkdir('Xdir1/empty')
- split Xdir1/Xfile
+ call mkdir('Xrecdel')
+ call mkdir('Xrecdel/subdir')
+ call mkdir('Xrecdel/empty')
+ split Xrecdel/Xfile
call setline(1, ['a', 'b'])
w
- w Xdir1/subdir/Xfile
+ w Xrecdel/subdir/Xfile
close
- call assert_true(isdirectory('Xdir1'))
- call assert_equal(['a', 'b'], readfile('Xdir1/Xfile'))
- call assert_true(isdirectory('Xdir1/subdir'))
- call assert_equal(['a', 'b'], readfile('Xdir1/subdir/Xfile'))
- call assert_true('Xdir1/empty'->isdirectory())
- call assert_equal(0, delete('Xdir1', 'rf'))
- call assert_false(isdirectory('Xdir1'))
- call assert_equal(-1, delete('Xdir1', 'd'))
- bwipe Xdir1/Xfile
- bwipe Xdir1/subdir/Xfile
+ call assert_true(isdirectory('Xrecdel'))
+ call assert_equal(['a', 'b'], readfile('Xrecdel/Xfile'))
+ call assert_true(isdirectory('Xrecdel/subdir'))
+ call assert_equal(['a', 'b'], readfile('Xrecdel/subdir/Xfile'))
+ call assert_true('Xrecdel/empty'->isdirectory())
+ call assert_equal(0, delete('Xrecdel', 'rf'))
+ call assert_false(isdirectory('Xrecdel'))
+ call assert_equal(-1, delete('Xrecdel', 'd'))
+ bwipe Xrecdel/Xfile
+ bwipe Xrecdel/subdir/Xfile
endfunc
func Test_symlink_delete()
split Xfile
call setline(1, ['a', 'b'])
wq
- silent !ln -s Xfile Xlink
+ silent !ln -s Xfile Xdellink
" Delete the link, not the file
- call assert_equal(0, delete('Xlink'))
- call assert_equal(-1, delete('Xlink'))
+ call assert_equal(0, delete('Xdellink'))
+ call assert_equal(-1, delete('Xdellink'))
call assert_equal(0, delete('Xfile'))
bwipe Xfile
endfunc
func Test_symlink_dir_delete()
CheckUnix
- call mkdir('Xdir1')
- silent !ln -s Xdir1 Xlink
- call assert_true(isdirectory('Xdir1'))
- call assert_true(isdirectory('Xlink'))
+ call mkdir('Xsymdir')
+ silent !ln -s Xsymdir Xdirlink
+ call assert_true(isdirectory('Xsymdir'))
+ call assert_true(isdirectory('Xdirlink'))
" Delete the link, not the directory
- call assert_equal(0, delete('Xlink'))
- call assert_equal(-1, delete('Xlink'))
- call assert_equal(0, delete('Xdir1', 'd'))
+ call assert_equal(0, delete('Xdirlink'))
+ call assert_equal(-1, delete('Xdirlink'))
+ call assert_equal(0, delete('Xsymdir', 'd'))
endfunc
func Test_symlink_recursive_delete()
CheckUnix
- call mkdir('Xdir3')
- call mkdir('Xdir3/subdir')
- call mkdir('Xdir4')
- split Xdir3/Xfile
+ call mkdir('Xrecdir3')
+ call mkdir('Xrecdir3/subdir')
+ call mkdir('Xrecdir4')
+ split Xrecdir3/Xfile
call setline(1, ['a', 'b'])
w
- w Xdir3/subdir/Xfile
- w Xdir4/Xfile
+ w Xrecdir3/subdir/Xfile
+ w Xrecdir4/Xfile
close
- silent !ln -s ../Xdir4 Xdir3/Xlink
+ silent !ln -s ../Xrecdir4 Xrecdir3/Xreclink
- call assert_true(isdirectory('Xdir3'))
- call assert_equal(['a', 'b'], readfile('Xdir3/Xfile'))
- call assert_true(isdirectory('Xdir3/subdir'))
- call assert_equal(['a', 'b'], readfile('Xdir3/subdir/Xfile'))
- call assert_true(isdirectory('Xdir4'))
- call assert_true(isdirectory('Xdir3/Xlink'))
- call assert_equal(['a', 'b'], readfile('Xdir4/Xfile'))
+ call assert_true(isdirectory('Xrecdir3'))
+ call assert_equal(['a', 'b'], readfile('Xrecdir3/Xfile'))
+ call assert_true(isdirectory('Xrecdir3/subdir'))
+ call assert_equal(['a', 'b'], readfile('Xrecdir3/subdir/Xfile'))
+ call assert_true(isdirectory('Xrecdir4'))
+ call assert_true(isdirectory('Xrecdir3/Xreclink'))
+ call assert_equal(['a', 'b'], readfile('Xrecdir4/Xfile'))
- call assert_equal(0, delete('Xdir3', 'rf'))
- call assert_false(isdirectory('Xdir3'))
- call assert_equal(-1, delete('Xdir3', 'd'))
+ call assert_equal(0, delete('Xrecdir3', 'rf'))
+ call assert_false(isdirectory('Xrecdir3'))
+ call assert_equal(-1, delete('Xrecdir3', 'd'))
" symlink is deleted, not the directory it points to
- call assert_true(isdirectory('Xdir4'))
- call assert_equal(['a', 'b'], readfile('Xdir4/Xfile'))
- call assert_equal(0, delete('Xdir4/Xfile'))
- call assert_equal(0, delete('Xdir4', 'd'))
+ call assert_true(isdirectory('Xrecdir4'))
+ call assert_equal(['a', 'b'], readfile('Xrecdir4/Xfile'))
+ call assert_equal(0, delete('Xrecdir4/Xfile'))
+ call assert_equal(0, delete('Xrecdir4', 'd'))
- bwipe Xdir3/Xfile
- bwipe Xdir3/subdir/Xfile
- bwipe Xdir4/Xfile
+ bwipe Xrecdir3/Xfile
+ bwipe Xrecdir3/subdir/Xfile
+ bwipe Xrecdir4/Xfile
endfunc
func Test_delete_errors()
" Long directory names only work on Unix.
CheckUnix
- let dirname = getcwd() . "/Xdir"
+ let dirname = getcwd() . "/Xlongdir"
let longdirname = dirname . repeat('/' . repeat('d', 255), 4)
try
call mkdir(longdirname, 'p')
" Test for editing a directory
func Test_edit_is_a_directory()
CheckEnglish
- let dirname = getcwd() . "/Xdir"
+ let dirname = getcwd() . "/Xeditdir"
call mkdir(dirname, 'p')
new
if has('unix')
" Redirecting to a directory name
- call mkdir('Xdir')
- call assert_fails('redir > Xdir', 'E17:')
- call delete('Xdir', 'd')
+ call mkdir('Xredir')
+ call assert_fails('redir > Xredir', 'E17:')
+ call delete('Xredir', 'd')
endif
" Test for redirecting to a register
" Test findfile() and finddir()
-let s:files = [ 'Xdir1/foo',
- \ 'Xdir1/bar',
- \ 'Xdir1/Xdir2/foo',
- \ 'Xdir1/Xdir2/foobar',
- \ 'Xdir1/Xdir2/Xdir3/bar',
- \ 'Xdir1/Xdir2/Xdir3/barfoo' ]
+let s:files = [ 'Xfinddir1/foo',
+ \ 'Xfinddir1/bar',
+ \ 'Xfinddir1/Xdir2/foo',
+ \ 'Xfinddir1/Xdir2/foobar',
+ \ 'Xfinddir1/Xdir2/Xdir3/bar',
+ \ 'Xfinddir1/Xdir2/Xdir3/barfoo' ]
func CreateFiles()
- call mkdir('Xdir1/Xdir2/Xdir3/Xdir2', 'p')
+ call mkdir('Xfinddir1/Xdir2/Xdir3/Xdir2', 'p')
for f in s:files
call writefile([], f)
endfor
func CleanFiles()
" Safer to delete each file even if it's more verbose
- " than doing a recursive delete('Xdir1', 'rf').
+ " than doing a recursive delete('Xfinddir1', 'rf').
for f in s:files
call delete(f)
endfor
- call delete('Xdir1/Xdir2/Xdir3/Xdir2', 'd')
- call delete('Xdir1/Xdir2/Xdir3', 'd')
- call delete('Xdir1/Xdir2', 'd')
- call delete('Xdir1', 'd')
+ call delete('Xfinddir1/Xdir2/Xdir3/Xdir2', 'd')
+ call delete('Xfinddir1/Xdir2/Xdir3', 'd')
+ call delete('Xfinddir1/Xdir2', 'd')
+ call delete('Xfinddir1', 'd')
endfunc
" Test findfile({name} [, {path} [, {count}]])
let save_dir = getcwd()
set shellslash
call CreateFiles()
- cd Xdir1
+ cd Xfinddir1
e Xdir2/foo
" With ,, in path, findfile() searches in current directory.
" Test upwards search.
cd Xdir2/Xdir3
call assert_equal('bar', findfile('bar', ';'))
- call assert_match('.*/Xdir1/Xdir2/foo', findfile('foo', ';'))
- call assert_match('.*/Xdir1/Xdir2/foo', findfile('foo', ';', 1))
- call assert_match('.*/Xdir1/foo', findfile('foo', ';', 2))
- call assert_match('.*/Xdir1/foo', findfile('foo', ';', 2))
- call assert_match('.*/Xdir1/Xdir2/foo', findfile('foo', 'Xdir2;', 1))
+ call assert_match('.*/Xfinddir1/Xdir2/foo', findfile('foo', ';'))
+ call assert_match('.*/Xfinddir1/Xdir2/foo', findfile('foo', ';', 1))
+ call assert_match('.*/Xfinddir1/foo', findfile('foo', ';', 2))
+ call assert_match('.*/Xfinddir1/foo', findfile('foo', ';', 2))
+ call assert_match('.*/Xfinddir1/Xdir2/foo', findfile('foo', 'Xdir2;', 1))
call assert_equal('', findfile('foo', 'Xdir2;', 2))
" List l should have at least 2 values (possibly more if foo file
- " happens to be found upwards above Xdir1).
+ " happens to be found upwards above Xfinddir1).
let l = findfile('foo', ';', -1)
- call assert_match('.*/Xdir1/Xdir2/foo', l[0])
- call assert_match('.*/Xdir1/foo', l[1])
+ call assert_match('.*/Xfinddir1/Xdir2/foo', l[0])
+ call assert_match('.*/Xfinddir1/foo', l[1])
" Test upwards search with stop-directory.
cd Xdir2
- let l = findfile('bar', ';' . save_dir . '/Xdir1/Xdir2/', -1)
+ let l = findfile('bar', ';' . save_dir . '/Xfinddir1/Xdir2/', -1)
call assert_equal(1, len(l))
- call assert_match('.*/Xdir1/Xdir2/Xdir3/bar', l[0])
+ call assert_match('.*/Xfinddir1/Xdir2/Xdir3/bar', l[0])
- let l = findfile('bar', ';' . save_dir . '/Xdir1/', -1)
+ let l = findfile('bar', ';' . save_dir . '/Xfinddir1/', -1)
call assert_equal(2, len(l))
- call assert_match('.*/Xdir1/Xdir2/Xdir3/bar', l[0])
- call assert_match('.*/Xdir1/bar', l[1])
+ call assert_match('.*/Xfinddir1/Xdir2/Xdir3/bar', l[0])
+ call assert_match('.*/Xfinddir1/bar', l[1])
" Test combined downwards and upwards search from Xdir2/.
cd ../..
call assert_equal('Xdir3/bar', findfile('bar', '**;', 1))
- call assert_match('.*/Xdir1/bar', findfile('bar', '**;', 2))
+ call assert_match('.*/Xfinddir1/bar', findfile('bar', '**;', 2))
bwipe!
call chdir(save_dir)
let save_dir = getcwd()
set path=,,
call CreateFiles()
- cd Xdir1
+ cd Xfinddir1
call assert_equal('Xdir2', finddir('Xdir2'))
call assert_equal('', 'Xdir3'->finddir())
" Test upwards dir search.
cd Xdir2/Xdir3
- call assert_match('.*/Xdir1', finddir('Xdir1', ';'))
+ call assert_match('.*/Xfinddir1', finddir('Xfinddir1', ';'))
" Test upwards search with stop-directory.
- call assert_match('.*/Xdir1', finddir('Xdir1', ';' . save_dir . '/'))
- call assert_equal('', finddir('Xdir1', ';' . save_dir . '/Xdir1/'))
+ call assert_match('.*/Xfinddir1', finddir('Xfinddir1', ';' . save_dir . '/'))
+ call assert_equal('', finddir('Xfinddir1', ';' . save_dir . '/Xfinddir1/'))
" Test combined downwards and upwards dir search from Xdir2/.
cd ..
- call assert_match('.*/Xdir1', finddir('Xdir1', '**;', 1))
+ call assert_match('.*/Xfinddir1', finddir('Xfinddir1', '**;', 1))
call assert_equal('Xdir3/Xdir2', finddir('Xdir2', '**;', 1))
- call assert_match('.*/Xdir1/Xdir2', finddir('Xdir2', '**;', 2))
+ call assert_match('.*/Xfinddir1/Xdir2', finddir('Xdir2', '**;', 2))
call assert_equal('Xdir3', finddir('Xdir3', '**;', 1))
call chdir(save_dir)
let save_dir = getcwd()
set path=.,./**/*
call CreateFiles()
- cd Xdir1
+ cd Xfinddir1
" Test for :find
find foo
call delete('Xlink2')
call delete('Xlink3')
- silent !ln -s -f Xdir//Xfile Xlink
- call assert_equal('Xdir/Xfile', resolve('Xlink'))
- call delete('Xlink')
+ silent !ln -s -f Xresolvedir//Xfile Xresolvelink
+ call assert_equal('Xresolvedir/Xfile', resolve('Xresolvelink'))
+ call delete('Xresolvelink')
silent !ln -s -f Xlink2/ Xlink1
call assert_equal('Xlink2', 'Xlink1'->resolve())
" test for shortcut file
if executable('cscript')
- new Xfile
+ new Xresfile
wq
let lines =<< trim END
Set fs = CreateObject("Scripting.FileSystemObject")
Set ws = WScript.CreateObject("WScript.Shell")
Set shortcut = ws.CreateShortcut("Xlink.lnk")
- shortcut.TargetPath = fs.BuildPath(ws.CurrentDirectory, "Xfile")
+ shortcut.TargetPath = fs.BuildPath(ws.CurrentDirectory, "Xresfile")
shortcut.Save
END
call writefile(lines, 'link.vbs')
silent !cscript link.vbs
call delete('link.vbs')
- call assert_equal(s:normalize_fname(getcwd() . '\Xfile'), s:normalize_fname(resolve('./Xlink.lnk')))
- call delete('Xfile')
+ call assert_equal(s:normalize_fname(getcwd() . '\Xresfile'), s:normalize_fname(resolve('./Xlink.lnk')))
+ call delete('Xresfile')
- call assert_equal(s:normalize_fname(getcwd() . '\Xfile'), s:normalize_fname(resolve('./Xlink.lnk')))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xresfile'), s:normalize_fname(resolve('./Xlink.lnk')))
call delete('Xlink.lnk')
else
echomsg 'skipped test for shortcut file'
" remove files
call delete('Xlink')
- call delete('Xdir', 'd')
- call delete('Xfile')
+ call delete('Xresfile')
" test for symbolic link to a file
- new Xfile
+ new Xslinkfile
wq
- call assert_equal('Xfile', resolve('Xfile'))
- silent !mklink Xlink Xfile
+ call assert_equal('Xslinkfile', resolve('Xslinkfile'))
+ silent !mklink Xlink Xslinkfile
if !v:shell_error
- call assert_equal(s:normalize_fname(getcwd() . '\Xfile'), s:normalize_fname(resolve('./Xlink')))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xslinkfile'), s:normalize_fname(resolve('./Xlink')))
call delete('Xlink')
else
echomsg 'skipped test for symbolic link to a file'
endif
- call delete('Xfile')
+ call delete('Xslinkfile')
" test for junction to a directory
- call mkdir('Xdir')
- silent !mklink /J Xlink Xdir
+ call mkdir('Xjuncdir')
+ silent !mklink /J Xlink Xjuncdir
if !v:shell_error
- call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xjuncdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
- call delete('Xdir', 'd')
+ call delete('Xjuncdir', 'd')
" test for junction already removed
call assert_equal(s:normalize_fname(getcwd() . '\Xlink'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
call delete('Xlink')
else
echomsg 'skipped test for junction to a directory'
- call delete('Xdir', 'd')
+ call delete('Xjuncdir', 'd')
endif
" test for symbolic link to a directory
- call mkdir('Xdir')
- silent !mklink /D Xlink Xdir
+ call mkdir('Xjuncdir')
+ silent !mklink /D Xlink Xjuncdir
if !v:shell_error
- call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xjuncdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
- call delete('Xdir', 'd')
+ call delete('Xjuncdir', 'd')
" test for symbolic link already removed
call assert_equal(s:normalize_fname(getcwd() . '\Xlink'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
call delete('Xlink')
else
echomsg 'skipped test for symbolic link to a directory'
- call delete('Xdir', 'd')
+ call delete('Xjuncdir', 'd')
endif
" test for buffer name
call delete('Xfile')
" test for reparse point
- call mkdir('Xdir')
- call assert_equal('Xdir', resolve('Xdir'))
- silent !mklink /D Xdirlink Xdir
+ call mkdir('Xparsedir')
+ call assert_equal('Xdir', resolve('Xparsedir'))
+ silent !mklink /D Xdirlink Xparsedir
if !v:shell_error
- w Xdir/text.txt
- call assert_equal('Xdir/text.txt', resolve('Xdir/text.txt'))
- call assert_equal(s:normalize_fname(getcwd() . '\Xdir\text.txt'), s:normalize_fname(resolve('Xdirlink\text.txt')))
- call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve('Xdirlink')))
+ w Xparsedir/text.txt
+ call assert_equal('Xparsedir/text.txt', resolve('Xparsedir/text.txt'))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xparsedir\text.txt'), s:normalize_fname(resolve('Xdirlink\text.txt')))
+ call assert_equal(s:normalize_fname(getcwd() . '\Xparsedir'), s:normalize_fname(resolve('Xdirlink')))
call delete('Xdirlink')
else
echomsg 'skipped test for reparse point'
endif
- call delete('Xdir', 'rf')
+ call delete('Xparsedir', 'rf')
endfunc
func Test_simplify()
call assert_equal('./file', simplify('dir/.././file'))
call assert_equal('../dir', simplify('./../dir'))
call assert_equal('..', simplify('../testdir/..'))
- call mkdir('Xdir')
- call assert_equal('.', simplify('Xdir/../.'))
- call delete('Xdir', 'd')
+ call mkdir('Xsimpdir')
+ call assert_equal('.', simplify('Xsimpdir/../.'))
+ call delete('Xsimpdir', 'd')
call assert_fails('call simplify({->0})', 'E729:')
call assert_fails('call simplify([])', 'E730:')
call assert_equal(0, filewritable('doesnotexist'))
- call mkdir('Xdir')
- call assert_equal(2, filewritable('Xdir'))
- call delete('Xdir', 'd')
+ call mkdir('Xwritedir')
+ call assert_equal(2, filewritable('Xwritedir'))
+ call delete('Xwritedir', 'd')
call delete('Xfilewritable')
bw!
bwipe
" create "notepad.bat"
- call mkdir('Xdir')
- let notepadbat = fnamemodify('Xdir/notepad.bat', ':p')
+ call mkdir('Xnotedir')
+ let notepadbat = fnamemodify('Xnotedir/notepad.bat', ':p')
call writefile([], notepadbat)
new
" check that the path and the pathext order is valid
- lcd Xdir
+ lcd Xnotedir
let [pathext, $PATHEXT] = [$PATHEXT, '.com;.exe;.bat;.cmd']
call assert_equal(notepadbat, exepath('notepad'))
let $PATHEXT = pathext
bwipe
- eval 'Xdir'->delete('rf')
+ eval 'Xnotedir'->delete('rf')
elseif has('unix')
call assert_equal(1, 'cat'->executable())
call assert_equal(0, executable('nodogshere'))
endfunc
func Test_readdir()
- call mkdir('Xdir')
- call writefile([], 'Xdir/foo.txt')
- call writefile([], 'Xdir/bar.txt')
- call mkdir('Xdir/dir')
+ call mkdir('Xreaddir')
+ call writefile([], 'Xreaddir/foo.txt')
+ call writefile([], 'Xreaddir/bar.txt')
+ call mkdir('Xreaddir/dir')
" All results
- let files = readdir('Xdir')
+ let files = readdir('Xreaddir')
call assert_equal(['bar.txt', 'dir', 'foo.txt'], sort(files))
" Only results containing "f"
- let files = 'Xdir'->readdir({ x -> stridx(x, 'f') != -1 })
+ let files = 'Xreaddir'->readdir({ x -> stridx(x, 'f') != -1 })
call assert_equal(['foo.txt'], sort(files))
" Only .txt files
- let files = readdir('Xdir', { x -> x =~ '.txt$' })
+ let files = readdir('Xreaddir', { x -> x =~ '.txt$' })
call assert_equal(['bar.txt', 'foo.txt'], sort(files))
" Only .txt files with string
- let files = readdir('Xdir', 'v:val =~ ".txt$"')
+ let files = readdir('Xreaddir', 'v:val =~ ".txt$"')
call assert_equal(['bar.txt', 'foo.txt'], sort(files))
" Limit to 1 result.
let l = []
- let files = readdir('Xdir', {x -> len(add(l, x)) == 2 ? -1 : 1})
+ let files = readdir('Xreaddir', {x -> len(add(l, x)) == 2 ? -1 : 1})
call assert_equal(1, len(files))
" Nested readdir() must not crash
- let files = readdir('Xdir', 'readdir("Xdir", "1") != []')
+ let files = readdir('Xreaddir', 'readdir("Xreaddir", "1") != []')
call sort(files)->assert_equal(['bar.txt', 'dir', 'foo.txt'])
- eval 'Xdir'->delete('rf')
+ eval 'Xreaddir'->delete('rf')
endfunc
func Test_readdirex()
- call mkdir('Xdir')
- call writefile(['foo'], 'Xdir/foo.txt')
- call writefile(['barbar'], 'Xdir/bar.txt')
- call mkdir('Xdir/dir')
+ call mkdir('Xexdir')
+ call writefile(['foo'], 'Xexdir/foo.txt')
+ call writefile(['barbar'], 'Xexdir/bar.txt')
+ call mkdir('Xexdir/dir')
" All results
- let files = readdirex('Xdir')->map({-> v:val.name})
+ let files = readdirex('Xexdir')->map({-> v:val.name})
call assert_equal(['bar.txt', 'dir', 'foo.txt'], sort(files))
- let sizes = readdirex('Xdir')->map({-> v:val.size})
+ let sizes = readdirex('Xexdir')->map({-> v:val.size})
call assert_equal([0, 4, 7], sort(sizes))
" Only results containing "f"
- let files = 'Xdir'->readdirex({ e -> stridx(e.name, 'f') != -1 })
+ let files = 'Xexdir'->readdirex({ e -> stridx(e.name, 'f') != -1 })
\ ->map({-> v:val.name})
call assert_equal(['foo.txt'], sort(files))
" Only .txt files
- let files = readdirex('Xdir', { e -> e.name =~ '.txt$' })
+ let files = readdirex('Xexdir', { e -> e.name =~ '.txt$' })
\ ->map({-> v:val.name})
call assert_equal(['bar.txt', 'foo.txt'], sort(files))
" Only .txt files with string
- let files = readdirex('Xdir', 'v:val.name =~ ".txt$"')
+ let files = readdirex('Xexdir', 'v:val.name =~ ".txt$"')
\ ->map({-> v:val.name})
call assert_equal(['bar.txt', 'foo.txt'], sort(files))
" Limit to 1 result.
let l = []
- let files = readdirex('Xdir', {e -> len(add(l, e.name)) == 2 ? -1 : 1})
+ let files = readdirex('Xexdir', {e -> len(add(l, e.name)) == 2 ? -1 : 1})
\ ->map({-> v:val.name})
call assert_equal(1, len(files))
" Nested readdirex() must not crash
- let files = readdirex('Xdir', 'readdirex("Xdir", "1") != []')
+ let files = readdirex('Xexdir', 'readdirex("Xexdir", "1") != []')
\ ->map({-> v:val.name})
call sort(files)->assert_equal(['bar.txt', 'dir', 'foo.txt'])
" report broken link correctly
if has("unix")
- call writefile([], 'Xdir/abc.txt')
- call system("ln -s Xdir/abc.txt Xdir/link")
- call delete('Xdir/abc.txt')
- let files = readdirex('Xdir', 'readdirex("Xdir", "1") != []')
+ call writefile([], 'Xexdir/abc.txt')
+ call system("ln -s Xexdir/abc.txt Xexdir/link")
+ call delete('Xexdir/abc.txt')
+ let files = readdirex('Xexdir', 'readdirex("Xexdir", "1") != []')
\ ->map({-> v:val.name .. '_' .. v:val.type})
call sort(files)->assert_equal(
\ ['bar.txt_file', 'dir_dir', 'foo.txt_file', 'link_link'])
endif
- eval 'Xdir'->delete('rf')
+ eval 'Xexdir'->delete('rf')
call assert_fails('call readdirex("doesnotexist")', 'E484:')
endfunc
throw 'Skipped: Test_readdirex_sort on systems that do not allow this using the default filesystem'
endif
let _collate = v:collate
- call mkdir('Xdir2')
- call writefile(['1'], 'Xdir2/README.txt')
- call writefile(['2'], 'Xdir2/Readme.txt')
- call writefile(['3'], 'Xdir2/readme.txt')
+ call mkdir('Xsortdir2')
+ call writefile(['1'], 'Xsortdir2/README.txt')
+ call writefile(['2'], 'Xsortdir2/Readme.txt')
+ call writefile(['3'], 'Xsortdir2/readme.txt')
" 1) default
- let files = readdirex('Xdir2')->map({-> v:val.name})
+ let files = readdirex('Xsortdir2')->map({-> v:val.name})
let default = copy(files)
call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], files, 'sort using default')
" 2) no sorting
- let files = readdirex('Xdir2', 1, #{sort: 'none'})->map({-> v:val.name})
+ let files = readdirex('Xsortdir2', 1, #{sort: 'none'})->map({-> v:val.name})
let unsorted = copy(files)
call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], sort(files), 'unsorted')
- call assert_fails("call readdirex('Xdir2', 1, #{slort: 'none'})", 'E857: Dictionary key "sort" required')
+ call assert_fails("call readdirex('Xsortdir2', 1, #{slort: 'none'})", 'E857: Dictionary key "sort" required')
" 3) sort by case (same as default)
- let files = readdirex('Xdir2', 1, #{sort: 'case'})->map({-> v:val.name})
+ let files = readdirex('Xsortdir2', 1, #{sort: 'case'})->map({-> v:val.name})
call assert_equal(default, files, 'sort by case')
" 4) sort by ignoring case
- let files = readdirex('Xdir2', 1, #{sort: 'icase'})->map({-> v:val.name})
+ let files = readdirex('Xsortdir2', 1, #{sort: 'icase'})->map({-> v:val.name})
call assert_equal(unsorted->sort('i'), files, 'sort by icase')
" 5) Default Collation
let collate = v:collate
lang collate C
- let files = readdirex('Xdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
+ let files = readdirex('Xsortdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], files, 'sort by C collation')
" 6) Collation de_DE
" available
try
lang collate de_DE
- let files = readdirex('Xdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
+ let files = readdirex('Xsortdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
call assert_equal(['readme.txt', 'Readme.txt', 'README.txt'], files, 'sort by de_DE collation')
catch
throw 'Skipped: de_DE collation is not available'
finally
exe 'lang collate' collate
- eval 'Xdir2'->delete('rf')
+ eval 'Xsortdir2'->delete('rf')
endtry
endfunc
func Test_readdir_sort()
" some more cases for testing sorting for readdirex
- let dir = 'Xdir3'
+ let dir = 'Xsortdir3'
call mkdir(dir)
call writefile(['1'], dir .. '/README.txt')
call writefile(['2'], dir .. '/Readm.txt')
endfunc
func Test_delete_rf()
- call mkdir('Xdir')
- call writefile([], 'Xdir/foo.txt')
- call writefile([], 'Xdir/bar.txt')
- call mkdir('Xdir/[a-1]') " issue #696
- call writefile([], 'Xdir/[a-1]/foo.txt')
- call writefile([], 'Xdir/[a-1]/bar.txt')
- call assert_true(filereadable('Xdir/foo.txt'))
- call assert_true('Xdir/[a-1]/foo.txt'->filereadable())
-
- call assert_equal(0, delete('Xdir', 'rf'))
- call assert_false(filereadable('Xdir/foo.txt'))
- call assert_false(filereadable('Xdir/[a-1]/foo.txt'))
+ call mkdir('Xrfdir')
+ call writefile([], 'Xrfdir/foo.txt')
+ call writefile([], 'Xrfdir/bar.txt')
+ call mkdir('Xrfdir/[a-1]') " issue #696
+ call writefile([], 'Xrfdir/[a-1]/foo.txt')
+ call writefile([], 'Xrfdir/[a-1]/bar.txt')
+ call assert_true(filereadable('Xrfdir/foo.txt'))
+ call assert_true('Xrfdir/[a-1]/foo.txt'->filereadable())
+
+ call assert_equal(0, delete('Xrfdir', 'rf'))
+ call assert_false(filereadable('Xrfdir/foo.txt'))
+ call assert_false(filereadable('Xrfdir/[a-1]/foo.txt'))
if has('unix')
- call mkdir('Xdir/Xdir2', 'p')
- silent !chmod 555 Xdir
- call assert_equal(-1, delete('Xdir/Xdir2', 'rf'))
- call assert_equal(-1, delete('Xdir', 'rf'))
- silent !chmod 755 Xdir
- call assert_equal(0, delete('Xdir', 'rf'))
+ call mkdir('Xrfdir/Xdir2', 'p')
+ silent !chmod 555 Xrfdir
+ call assert_equal(-1, delete('Xrfdir/Xdir2', 'rf'))
+ call assert_equal(-1, delete('Xrfdir', 'rf'))
+ silent !chmod 755 Xrfdir
+ call assert_equal(0, delete('Xrfdir', 'rf'))
endif
endfunc
eval 'Xtopdir'->mkdir()
cd Xtopdir
let g:topdir = getcwd()
- call mkdir('Xdir1')
- call mkdir('Xdir2')
- call mkdir('Xdir3')
+ call mkdir('Xcwdir1')
+ call mkdir('Xcwdir2')
+ call mkdir('Xcwdir3')
endfunction
let g:cwd=getcwd()
new b
new c
3wincmd w
- lcd Xdir1
- call assert_equal("a Xdir1 1", GetCwdInfo(0, 0))
+ lcd Xcwdir1
+ call assert_equal("a Xcwdir1 1", GetCwdInfo(0, 0))
call assert_equal(g:topdir, getcwd(-1))
wincmd W
call assert_equal("b Xtopdir 0", GetCwdInfo(0, 0))
call assert_equal(g:topdir, getcwd(-1))
wincmd W
- lcd Xdir3
- call assert_equal("c Xdir3 1", GetCwdInfo(0, 0))
- call assert_equal("a Xdir1 1", GetCwdInfo(bufwinnr("a"), 0))
+ lcd Xcwdir3
+ call assert_equal("c Xcwdir3 1", GetCwdInfo(0, 0))
+ call assert_equal("a Xcwdir1 1", GetCwdInfo(bufwinnr("a"), 0))
call assert_equal("b Xtopdir 0", GetCwdInfo(bufwinnr("b"), 0))
- call assert_equal("c Xdir3 1", GetCwdInfo(bufwinnr("c"), 0))
+ call assert_equal("c Xcwdir3 1", GetCwdInfo(bufwinnr("c"), 0))
call assert_equal(g:topdir, getcwd(-1))
wincmd W
- call assert_equal("a Xdir1 1", GetCwdInfo(bufwinnr("a"), tabpagenr()))
+ call assert_equal("a Xcwdir1 1", GetCwdInfo(bufwinnr("a"), tabpagenr()))
call assert_equal("b Xtopdir 0", GetCwdInfo(bufwinnr("b"), tabpagenr()))
- call assert_equal("c Xdir3 1", GetCwdInfo(bufwinnr("c"), tabpagenr()))
+ call assert_equal("c Xcwdir3 1", GetCwdInfo(bufwinnr("c"), tabpagenr()))
call assert_equal(g:topdir, getcwd(-1))
tabnew x
call assert_equal("x Xtopdir 0", GetCwdInfo(0, 0))
call assert_equal(g:topdir, getcwd(-1))
wincmd W
- lcd Xdir2
- call assert_equal("y Xdir2 1", GetCwdInfo(0, 0))
+ lcd Xcwdir2
+ call assert_equal("y Xcwdir2 1", GetCwdInfo(0, 0))
call assert_equal(g:topdir, getcwd(-1))
wincmd W
- lcd Xdir3
- call assert_equal("z Xdir3 1", GetCwdInfo(0, 0))
+ lcd Xcwdir3
+ call assert_equal("z Xcwdir3 1", GetCwdInfo(0, 0))
call assert_equal("x Xtopdir 0", GetCwdInfo(bufwinnr("x"), 0))
- call assert_equal("y Xdir2 1", GetCwdInfo(bufwinnr("y"), 0))
- call assert_equal("z Xdir3 1", GetCwdInfo(bufwinnr("z"), 0))
+ call assert_equal("y Xcwdir2 1", GetCwdInfo(bufwinnr("y"), 0))
+ call assert_equal("z Xcwdir3 1", GetCwdInfo(bufwinnr("z"), 0))
call assert_equal(g:topdir, getcwd(-1))
let tp_nr = tabpagenr()
tabrewind
call assert_equal("x Xtopdir 0", GetCwdInfo(3, tp_nr))
- call assert_equal("y Xdir2 1", GetCwdInfo(2, tp_nr))
- call assert_equal("z Xdir3 1", GetCwdInfo(1, tp_nr))
+ call assert_equal("y Xcwdir2 1", GetCwdInfo(2, tp_nr))
+ call assert_equal("z Xcwdir3 1", GetCwdInfo(1, tp_nr))
call assert_equal(g:topdir, getcwd(-1))
" Non existing windows and tab pages
call assert_equal('', getcwd(100))
" Change the global directory for the first tab page
tabrewind | 1wincmd w
- cd ../Xdir1
- call assert_equal("a Xdir1 0", GetCwdInfo(1, 1))
- call assert_equal("b Xdir1 0", GetCwdInfo(2, 1))
+ cd ../Xcwdir1
+ call assert_equal("a Xcwdir1 0", GetCwdInfo(1, 1))
+ call assert_equal("b Xcwdir1 0", GetCwdInfo(2, 1))
call assert_equal("m Xtabdir1 2", GetCwdInfo(1, 2))
call assert_equal("n Xwindir2 1", GetCwdInfo(2, 2))
" Change the global directory for the second tab page
tabnext | 1wincmd w
- cd ../Xdir3
- call assert_equal("m Xdir3 0", GetCwdInfo(1, 2))
+ cd ../Xcwdir3
+ call assert_equal("m Xcwdir3 0", GetCwdInfo(1, 2))
call assert_equal("n Xwindir2 1", GetCwdInfo(2, 2))
- call assert_equal("o Xdir3 0", GetCwdInfo(3, 2))
+ call assert_equal("o Xcwdir3 0", GetCwdInfo(3, 2))
" Change the tab-local directory for the third tab page
tabnext | 1wincmd w
- cd ../Xdir1
- call assert_equal("x Xdir1 0", GetCwdInfo(1, 3))
- call assert_equal("y Xdir1 0", GetCwdInfo(2, 3))
+ cd ../Xcwdir1
+ call assert_equal("x Xcwdir1 0", GetCwdInfo(1, 3))
+ call assert_equal("y Xcwdir1 0", GetCwdInfo(2, 3))
call assert_equal("z Xwindir3 1", GetCwdInfo(3, 3))
enew | only | tabonly
%argdelete
" pressing shift when dropping files should change directory
let save_cwd = getcwd()
- call mkdir('Xdir1')
- call writefile([], 'Xdir1/Xfile1')
- call writefile([], 'Xdir1/Xfile2')
- let d = #{files: ['Xdir1/Xfile1', 'Xdir1/Xfile2'], row: 1, col: 1,
+ call mkdir('Xdropdir1')
+ call writefile([], 'Xdropdir1/Xfile1')
+ call writefile([], 'Xdropdir1/Xfile2')
+ let d = #{files: ['Xdropdir1/Xfile1', 'Xdropdir1/Xfile2'], row: 1, col: 1,
\ modifiers: 0x4}
call test_gui_event('dropfiles', d)
- call assert_equal('Xdir1', fnamemodify(getcwd(), ':t'))
+ call assert_equal('Xdropdir1', fnamemodify(getcwd(), ':t'))
call assert_equal('Xfile1', @%)
call chdir(save_cwd)
" pressing shift when dropping directory and files should change directory
- let d = #{files: ['Xdir1', 'Xdir1/Xfile2'], row: 1, col: 1, modifiers: 0x4}
+ let d = #{files: ['Xdropdir1', 'Xdropdir1/Xfile2'], row: 1, col: 1, modifiers: 0x4}
call test_gui_event('dropfiles', d)
- call assert_equal('Xdir1', fnamemodify(getcwd(), ':t'))
- call assert_equal('Xdir1', fnamemodify(@%, ':t'))
+ call assert_equal('Xdropdir1', fnamemodify(getcwd(), ':t'))
+ call assert_equal('Xdropdir1', fnamemodify(@%, ':t'))
call chdir(save_cwd)
%bw!
%argdelete
" dropping a directory should edit it
- let d = #{files: ['Xdir1'], row: 1, col: 1, modifiers: 0}
+ let d = #{files: ['Xdropdir1'], row: 1, col: 1, modifiers: 0}
call test_gui_event('dropfiles', d)
- call assert_equal('Xdir1', @%)
+ call assert_equal('Xdropdir1', @%)
%bw!
%argdelete
" dropping only a directory name with Shift should ignore it
- let d = #{files: ['Xdir1'], row: 1, col: 1, modifiers: 0x4}
+ let d = #{files: ['Xdropdir1'], row: 1, col: 1, modifiers: 0x4}
call test_gui_event('dropfiles', d)
call assert_equal('', @%)
%bw!
%argdelete
- call delete('Xdir1', 'rf')
+ call delete('Xdropdir1', 'rf')
" drop files in the command line. The GUI drop files adds the file names to
" the low level input buffer. So need to use a cmdline map and feedkeys()
" Test for the :helptags command
" NOTE: if you run tests as root this will fail. Don't run tests as root!
func Test_helptag_cmd()
- call mkdir('Xdir/a/doc', 'p')
+ call mkdir('Xtagdir/a/doc', 'p')
" No help file to process in the directory
- call assert_fails('helptags Xdir', 'E151:')
+ call assert_fails('helptags Xtagdir', 'E151:')
- call writefile([], 'Xdir/a/doc/sample.txt')
+ call writefile([], 'Xtagdir/a/doc/sample.txt')
" Test for ++t argument
- helptags ++t Xdir
- call assert_equal(["help-tags\ttags\t1"], readfile('Xdir/tags'))
- call delete('Xdir/tags')
+ helptags ++t Xtagdir
+ call assert_equal(["help-tags\ttags\t1"], readfile('Xtagdir/tags'))
+ call delete('Xtagdir/tags')
" Test parsing tags
call writefile(['*tag1*', 'Example: >', ' *notag*', 'Example end: *tag2*'],
- \ 'Xdir/a/doc/sample.txt')
- helptags Xdir
+ \ 'Xtagdir/a/doc/sample.txt')
+ helptags Xtagdir
call assert_equal(["tag1\ta/doc/sample.txt\t/*tag1*",
- \ "tag2\ta/doc/sample.txt\t/*tag2*"], readfile('Xdir/tags'))
+ \ "tag2\ta/doc/sample.txt\t/*tag2*"], readfile('Xtagdir/tags'))
" Duplicate tags in the help file
- call writefile(['*tag1*', '*tag1*', '*tag2*'], 'Xdir/a/doc/sample.txt')
- call assert_fails('helptags Xdir', 'E154:')
+ call writefile(['*tag1*', '*tag1*', '*tag2*'], 'Xtagdir/a/doc/sample.txt')
+ call assert_fails('helptags Xtagdir', 'E154:')
- call delete('Xdir', 'rf')
+ call delete('Xtagdir', 'rf')
endfunc
func Test_helptag_cmd_readonly()
CheckNotRoot
" Read-only tags file
- call mkdir('Xdir/doc', 'p')
- call writefile([''], 'Xdir/doc/tags')
- call writefile([], 'Xdir/doc/sample.txt')
- call setfperm('Xdir/doc/tags', 'r-xr--r--')
- call assert_fails('helptags Xdir/doc', 'E152:', getfperm('Xdir/doc/tags'))
+ call mkdir('Xrodir/doc', 'p')
+ call writefile([''], 'Xrodir/doc/tags')
+ call writefile([], 'Xrodir/doc/sample.txt')
+ call setfperm('Xrodir/doc/tags', 'r-xr--r--')
+ call assert_fails('helptags Xrodir/doc', 'E152:', getfperm('Xrodir/doc/tags'))
let rtp = &rtp
- let &rtp = 'Xdir'
+ let &rtp = 'Xrodir'
helptags ALL
let &rtp = rtp
- call delete('Xdir/doc/tags')
+ call delete('Xrodir/doc/tags')
" No permission to read the help file
- call mkdir('Xdir/b/doc', 'p')
- call writefile([], 'Xdir/b/doc/sample.txt')
- call setfperm('Xdir/b/doc/sample.txt', '-w-------')
- call assert_fails('helptags Xdir', 'E153:', getfperm('Xdir/b/doc/sample.txt'))
- call delete('Xdir', 'rf')
+ call mkdir('Xrodir/b/doc', 'p')
+ call writefile([], 'Xrodir/b/doc/sample.txt')
+ call setfperm('Xrodir/b/doc/sample.txt', '-w-------')
+ call assert_fails('helptags Xrodir', 'E153:', getfperm('Xrodir/b/doc/sample.txt'))
+ call delete('Xrodir', 'rf')
endfunc
" Test for setting the 'helpheight' option in the help window
edit test_ins_complete.vim
" The files in the current directory interferes with the files
" used by this test. So use a separate directory for the test.
- call mkdir('Xdir')
- cd Xdir
+ call mkdir('Xcpldir')
+ cd Xcpldir
set ff=unix
call writefile(["test11\t36Gepeto\t/Tag/",
call delete('Xtestdata')
set cpt& cot& def& tags& tagbsearch& hidden&
cd ..
- call delete('Xdir', 'rf')
+ call delete('Xcpldir', 'rf')
endfunc
func Test_ins_complete_invalid_byte()
func Test_ins_completeslash()
CheckMSWindows
- call mkdir('Xdir')
+ call mkdir('Xcpldir')
let orig_shellslash = &shellslash
set cpt&
new
set completeslash=
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir\', getline('.'))
+ call assert_equal('Xcpldir\', getline('.'))
set completeslash=backslash
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir\', getline('.'))
+ call assert_equal('Xcpldir\', getline('.'))
set completeslash=slash
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir/', getline('.'))
+ call assert_equal('Xcpldir/', getline('.'))
set shellslash
set completeslash=
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir/', getline('.'))
+ call assert_equal('Xcpldir/', getline('.'))
set completeslash=backslash
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir\', getline('.'))
+ call assert_equal('Xcpldir\', getline('.'))
set completeslash=slash
exe "normal oXd\<C-X>\<C-F>"
- call assert_equal('Xdir/', getline('.'))
+ call assert_equal('Xcpldir/', getline('.'))
%bw!
- call delete('Xdir', 'rf')
+ call delete('Xcpldir', 'rf')
set noshellslash
set completeslash=slash
source check.vim
func SetUp()
- let s:topdir = getcwd() . '/Xdir'
+ let s:topdir = getcwd() . '/Xppdir'
exe 'set packpath=' . s:topdir
let s:plugdir = s:topdir . '/pack/mine/opt/mytest'
endfunc
call assert_equal(77, g:plugin_also_works)
call assert_equal(17, g:ftdetect_works)
call assert_true(len(&rtp) > len(rtp))
- call assert_match('/testdir/Xdir/pack/mine/opt/mytest\($\|,\)', &rtp)
+ call assert_match('/testdir/Xppdir/pack/mine/opt/mytest\($\|,\)', &rtp)
- let new_after = match(&rtp, '/testdir/Xdir/pack/mine/opt/mytest/after,')
+ let new_after = match(&rtp, '/testdir/Xppdir/pack/mine/opt/mytest/after,')
let forwarded = substitute(first_after_entry, '\\', '[/\\\\]', 'g')
let old_after = match(&rtp, ',' . forwarded . '\>')
call assert_true(new_after > 0, 'rtp is ' . &rtp)
" Check the path of 'myte' is added
call assert_true(len(&rtp) > len(rtp))
- call assert_match('/testdir/Xdir/pack/mine/opt/myte\($\|,\)', &rtp)
+ call assert_match('/testdir/Xppdir/pack/mine/opt/myte\($\|,\)', &rtp)
" Check exception
call assert_fails("packadd directorynotfound", 'E919:')
call assert_equal(24, g:plugin_works)
call assert_true(len(&rtp) > len(rtp))
- call assert_match('/testdir/Xdir/pack/mine/start/other\($\|,\)', &rtp)
+ call assert_match('/testdir/Xppdir/pack/mine/start/other\($\|,\)', &rtp)
endfunc
func Test_packadd_noload()
packadd! mytest
call assert_true(len(&rtp) > len(rtp))
- call assert_match('testdir/Xdir/pack/mine/opt/mytest\($\|,\)', &rtp)
+ call assert_match('testdir/Xppdir/pack/mine/opt/mytest\($\|,\)', &rtp)
call assert_equal(0, g:plugin_works)
" check the path is not added twice
autocmd BufRead * silent cd %:p:h
augroup END
- 10Xvimgrep /vim/ Xdir/**
+ 10Xvimgrep /vim/ Xgrepdir/**
let l = g:Xgetlist()
call assert_equal('f1.txt', bufname(l[0].bufnr))
call assert_equal('f2.txt', fnamemodify(bufname(l[2].bufnr), ':t'))
endfunc
func Test_vimgrep_autocmd_cd()
- call mkdir('Xdir/a', 'p')
- call mkdir('Xdir/b', 'p')
- call writefile(['a_L1_vim', 'a_L2_vim'], 'Xdir/a/f1.txt')
- call writefile(['b_L1_vim', 'b_L2_vim'], 'Xdir/b/f2.txt')
+ call mkdir('Xgrepdir/a', 'p')
+ call mkdir('Xgrepdir/b', 'p')
+ call writefile(['a_L1_vim', 'a_L2_vim'], 'Xgrepdir/a/f1.txt')
+ call writefile(['b_L1_vim', 'b_L2_vim'], 'Xgrepdir/b/f2.txt')
call Xvimgrep_autocmd_cd('c')
call Xvimgrep_autocmd_cd('l')
%bwipe
- call delete('Xdir', 'rf')
+ call delete('Xgrepdir', 'rf')
endfunc
" The following test used to crash Vim
call writefile(v:errors, 'Xtestout')
qall
[CODE]
- call mkdir('Xdir')
- call writefile(['let exrc_found=37'], 'Xdir/.exrc')
- call writefile(after, 'Xdir/Xafter')
- let cmd = GetVimProg() . ' --not-a-term -S Xafter --cmd "cd Xdir" --cmd "set enc=utf8 exrc secure"'
+ call mkdir('Xrcdir')
+ call writefile(['let exrc_found=37'], 'Xrcdir/.exrc')
+ call writefile(after, 'Xrcdir/Xafter')
+ let cmd = GetVimProg() . ' --not-a-term -S Xafter --cmd "cd Xrcdir" --cmd "set enc=utf8 exrc secure"'
exe "silent !" . cmd
- call assert_equal([], readfile('Xdir/Xtestout'))
- call delete('Xdir', 'rf')
+ call assert_equal([], readfile('Xrcdir/Xtestout'))
+ call delete('Xrcdir', 'rf')
endfunc
" Test for starting Vim with a non-terminal as input/output
" Test for failing to open the script output file. This test works only when
" the language is English.
if v:lang == "C" || v:lang =~ '^[Ee]n'
- call mkdir("Xdir")
- let m = system(GetVimCommand() .. " -w Xdir")
- call assert_equal("Cannot open for script output: \"Xdir\"\n", m)
- call delete("Xdir", 'rf')
+ call mkdir("Xargdir")
+ let m = system(GetVimCommand() .. " -w Xargdir")
+ call assert_equal("Cannot open for script output: \"Xargdir\"\n", m)
+ call delete("Xargdir", 'rf')
endif
" A number argument sets the 'window' option
CheckExecutable pwd
let cmd = 'pwd'
endif
- call mkdir('Xdir')
- let buf = term_start(cmd, {'cwd': 'Xdir'})
- call WaitForAssert({-> assert_equal('Xdir', fnamemodify(getline(1), ":t"))})
+ call mkdir('Xtermdir')
+ let buf = term_start(cmd, {'cwd': 'Xtermdir'})
+ call WaitForAssert({-> assert_equal('Xtermdir', fnamemodify(getline(1), ":t"))})
exe buf . 'bwipe'
- call delete('Xdir', 'rf')
+ call delete('Xtermdir', 'rf')
endfunc
func Test_terminal_cwd_failure()
enddef
def Test_disassemble_push()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xdisdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xdisdir'
var lines =<< trim END
vim9script
END
- writefile(lines, 'Xdir/autoload/autoscript.vim')
+ writefile(lines, 'Xdisdir/autoload/autoscript.vim')
lines =<< trim END
vim9script
END
v9.CheckScriptSuccess(lines)
- delete('Xdir', 'rf')
+ delete('Xdisdir', 'rf')
&rtp = save_rtp
enddef
enddef
def TestCompilingErrorInTry()
- var dir = 'Xdir/autoload'
+ var dir = 'Xcompdir/autoload'
mkdir(dir, 'p')
var lines =<< trim END
catch /nothing/
endtry
END
- lines[1] = 'set rtp=' .. getcwd() .. '/Xdir'
+ lines[1] = 'set rtp=' .. getcwd() .. '/Xcompdir'
writefile(lines, 'XTest_compile_error')
var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
# clean up
g:StopVimInTerminal(buf)
delete('XTest_compile_error')
- delete('Xdir', 'rf')
+ delete('Xcompdir', 'rf')
enddef
def Test_comment_error()
enddef
def Test_autoload_name_mismatch()
- var dir = 'Xdir/autoload'
+ var dir = 'Xnamedir/autoload'
mkdir(dir, 'p')
var lines =<< trim END
writefile(lines, dir .. '/script.vim')
var save_rtp = &rtp
- exe 'set rtp=' .. getcwd() .. '/Xdir'
+ exe 'set rtp=' .. getcwd() .. '/Xnamedir'
lines =<< trim END
call script#Function()
END
v9.CheckScriptFailure(lines, 'E117:', 1)
&rtp = save_rtp
- delete(dir, 'rf')
+ delete('Xnamdir', 'rf')
enddef
def Test_autoload_names()
- var dir = 'Xdir/autoload'
+ var dir = 'Xandir/autoload'
mkdir(dir, 'p')
var lines =<< trim END
writefile(lines, dir .. '/foobar.vim')
var save_rtp = &rtp
- exe 'set rtp=' .. getcwd() .. '/Xdir'
+ exe 'set rtp=' .. getcwd() .. '/Xandir'
lines =<< trim END
assert_equal('yes', foobar#function())
v9.CheckDefAndScriptSuccess(lines)
&rtp = save_rtp
- delete(dir, 'rf')
+ delete('Xandir', 'rf')
enddef
def Test_autoload_error_in_script()
- var dir = 'Xdir/autoload'
+ var dir = 'Xaedir/autoload'
mkdir(dir, 'p')
var lines =<< trim END
writefile(lines, dir .. '/scripterror.vim')
var save_rtp = &rtp
- exe 'set rtp=' .. getcwd() .. '/Xdir'
+ exe 'set rtp=' .. getcwd() .. '/Xaedir'
g:called_function = 'no'
# The error in the autoload script cannot be checked with assert_fails(), use
assert_equal('yes', g:called_function)
&rtp = save_rtp
- delete(dir, 'rf')
+ delete('Xaedir', 'rf')
enddef
def s:CallRecursive(n: number): number
g:result = 49
enddef
END
- mkdir('Xdir/autoload', 'p')
- writefile(lines, 'Xdir/autoload/XautoloadExport.vim')
+ mkdir('Ximpdir/autoload', 'p')
+ writefile(lines, 'Ximpdir/autoload/XautoloadExport.vim')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Ximpdir'
lines =<< trim END
vim9script
unlet g:result
delete('Xmapscript.vim')
nunmap <F3>
- delete('Xdir', 'rf')
+ delete('Ximpdir', 'rf')
&rtp = save_rtp
enddef
enddef
def Test_use_autoload_import_in_insert_completion()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xinsdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xinsdir'
var lines =<< trim END
vim9script
enddef
g:completion_loaded = 'yes'
END
- writefile(lines, 'Xdir/autoload/completion.vim')
+ writefile(lines, 'Xinsdir/autoload/completion.vim')
new
lines =<< trim END
set thesaurusfunc=
bwipe!
- delete('Xdir', 'rf')
+ delete('Xinsdir', 'rf')
&rtp = save_rtp
enddef
def Test_use_autoload_import_partial_in_opfunc()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xpartdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xpartdir'
var lines =<< trim END
vim9script
- export def Opfunc(..._)
+ export def Opfunc1(..._)
g:opfunc_called = 'yes'
enddef
END
- writefile(lines, 'Xdir/autoload/opfunc.vim')
+ writefile(lines, 'Xpartdir/autoload/opfunc.vim')
new
lines =<< trim END
import autoload 'opfunc.vim'
nnoremap <expr> <F3> TheFunc()
def TheFunc(): string
- &operatorfunc = function('opfunc.Opfunc', [0])
+ &operatorfunc = function('opfunc.Opfunc1', [0])
return 'g@'
enddef
feedkeys("\<F3>l", 'xt')
set opfunc=
bwipe!
- delete('Xdir', 'rf')
+ delete('Xpartdir', 'rf')
nunmap <F3>
&rtp = save_rtp
enddef
def Test_set_opfunc_to_autoload_func_directly()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xdirdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xdirdir'
var lines =<< trim END
vim9script
- export def Opfunc(..._)
+ export def Opfunc2(..._)
g:opfunc_called = 'yes'
enddef
END
- writefile(lines, 'Xdir/autoload/opfunc.vim')
+ writefile(lines, 'Xdirdir/autoload/opfunc.vim')
new
lines =<< trim END
import autoload 'opfunc.vim'
nnoremap <expr> <F3> TheFunc()
def TheFunc(): string
- &operatorfunc = opfunc.Opfunc
+ &operatorfunc = opfunc.Opfunc2
return 'g@'
enddef
feedkeys("\<F3>l", 'xt')
set opfunc=
bwipe!
- delete('Xdir', 'rf')
+ delete('Xdirdir', 'rf')
nunmap <F3>
&rtp = save_rtp
enddef
def Test_use_autoload_import_in_fold_expression()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xfolddir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xfolddir'
var lines =<< trim END
vim9script
enddef
g:fold_loaded = 'yes'
END
- writefile(lines, 'Xdir/autoload/fold.vim')
+ writefile(lines, 'Xfolddir/autoload/fold.vim')
lines =<< trim END
vim9script
set foldexpr= foldtext& foldmethod& debug=
bwipe!
- delete('Xdir', 'rf')
+ delete('Xfolddir', 'rf')
&rtp = save_rtp
enddef
END
v9.CheckScriptFailure(lines, 'E484:')
- delete('Xdir', 'rf')
+ delete('Xa.vim')
enddef
func Test_import_in_diffexpr()
enddef
def Test_export_shadows_global_function()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xglobdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xglobdir'
var lines =<< trim END
vim9script
return 'Shadow()'
enddef
END
- writefile(lines, 'Xdir/autoload/shadow.vim')
+ writefile(lines, 'Xglobdir/autoload/shadow.vim')
lines =<< trim END
vim9script
delfunc g:Shadow
bwipe!
- delete('Xdir', 'rf')
+ delete('Xglobdir', 'rf')
&rtp = save_rtp
enddef
enddef
END
- mkdir('Xdir/autoload', 'p')
- writefile(lines, 'Xdir/autoload/some.vim')
+ mkdir('Xfulldir/autoload', 'p')
+ writefile(lines, 'Xfulldir/autoload/some.vim')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xfulldir'
assert_equal('test', g:some#Gettest())
assert_equal('name', g:some#name)
return 'other'
enddef
END
- writefile(lines, 'Xdir/autoload/Other.vim')
+ writefile(lines, 'Xfulldir/autoload/Other.vim')
assert_equal('other', g:Other#GetOther())
- delete('Xdir', 'rf')
+ delete('Xfulldir', 'rf')
&rtp = save_rtp
enddef
def Test_vim9script_autoload()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xaldir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xaldir'
# when the path has "/autoload/" prefix is not needed
var lines =<< trim END
export final fname = 'final'
export const cname = 'const'
END
- writefile(lines, 'Xdir/autoload/prefixed.vim')
+ writefile(lines, 'Xaldir/autoload/prefixed.vim')
g:prefixed_loaded = 0
g:expected_loaded = 0
unlet g:prefixed_loaded
unlet g:expected_loaded
- delete('Xdir', 'rf')
+ delete('Xaldir', 'rf')
&rtp = save_rtp
enddef
def Test_import_autoload_not_exported()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xnimdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xnimdir'
# error when using an item that is not exported from an autoload script
var exportLines =<< trim END
echo 'nop'
enddef
END
- writefile(exportLines, 'Xdir/autoload/notExport1.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport1.vim')
var lines =<< trim END
vim9script
# using a :def function we use a different autoload script every time so that
# the function is compiled without the script loaded
- writefile(exportLines, 'Xdir/autoload/notExport2.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport2.vim')
lines =<< trim END
vim9script
import autoload 'notExport2.vim'
END
v9.CheckScriptFailure(lines, 'E1048: Item not found in script: notExport2#notFound')
- writefile(exportLines, 'Xdir/autoload/notExport3.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport3.vim')
lines =<< trim END
vim9script
import autoload 'notExport3.vim'
# don't get E1049 because it is too complicated to figure out
v9.CheckScriptFailure(lines, 'E1048: Item not found in script: notExport3#notExported')
- writefile(exportLines, 'Xdir/autoload/notExport4.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport4.vim')
lines =<< trim END
vim9script
import autoload 'notExport4.vim'
END
v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport4#NotFunc')
- writefile(exportLines, 'Xdir/autoload/notExport5.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport5.vim')
lines =<< trim END
vim9script
import autoload 'notExport5.vim'
END
v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport5#NotExport')
- writefile(exportLines, 'Xdir/autoload/notExport6.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport6.vim')
lines =<< trim END
vim9script
import autoload 'notExport6.vim'
END
v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport6#NotFunc')
- writefile(exportLines, 'Xdir/autoload/notExport7.vim')
+ writefile(exportLines, 'Xnimdir/autoload/notExport7.vim')
lines =<< trim END
vim9script
import autoload 'notExport7.vim'
END
v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport7#NotExport')
- delete('Xdir', 'rf')
+ delete('Xnimdir', 'rf')
&rtp = save_rtp
enddef
def Test_vim9script_autoload_call()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xcalldir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xcalldir'
var lines =<< trim END
vim9script
g:result = 'other'
enddef
END
- writefile(lines, 'Xdir/autoload/another.vim')
+ writefile(lines, 'Xcalldir/autoload/another.vim')
lines =<< trim END
vim9script
v9.CheckScriptSuccess(lines)
unlet g:result
- delete('Xdir', 'rf')
+ delete('Xcalldir', 'rf')
&rtp = save_rtp
enddef
def Test_vim9script_noclear_autoload()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xnocdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xnocdir'
var lines =<< trim END
vim9script
enddef
g:double_loaded = 'yes'
END
- writefile(lines, 'Xdir/autoload/double.vim')
+ writefile(lines, 'Xnocdir/autoload/double.vim')
lines =<< trim END
vim9script noclear
unlet g:double_loaded
unlet g:script_loaded
unlet g:result
- delete('Xdir', 'rf')
+ delete('Xnocdir', 'rf')
&rtp = save_rtp
enddef
def Test_vim9script_autoload_duplicate()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xdupdir/autoload', 'p')
var lines =<< trim END
vim9script
def Func()
enddef
END
- writefile(lines, 'Xdir/autoload/dupfunc.vim')
- assert_fails('source Xdir/autoload/dupfunc.vim', 'E1073:')
+ writefile(lines, 'Xdupdir/autoload/dupfunc.vim')
+ assert_fails('source Xdupdir/autoload/dupfunc.vim', 'E1073:')
lines =<< trim END
vim9script
export def Func()
enddef
END
- writefile(lines, 'Xdir/autoload/dup2func.vim')
- assert_fails('source Xdir/autoload/dup2func.vim', 'E1073:')
+ writefile(lines, 'Xdupdir/autoload/dup2func.vim')
+ assert_fails('source Xdupdir/autoload/dup2func.vim', 'E1073:')
lines =<< trim END
vim9script
export var Func = 'asdf'
END
- writefile(lines, 'Xdir/autoload/dup3func.vim')
- assert_fails('source Xdir/autoload/dup3func.vim', 'E1041: Redefining script item: "Func"')
+ writefile(lines, 'Xdupdir/autoload/dup3func.vim')
+ assert_fails('source Xdupdir/autoload/dup3func.vim', 'E1041: Redefining script item: "Func"')
lines =<< trim END
vim9script
def Func()
enddef
END
- writefile(lines, 'Xdir/autoload/dup4func.vim')
- assert_fails('source Xdir/autoload/dup4func.vim', 'E707:')
+ writefile(lines, 'Xdupdir/autoload/dup4func.vim')
+ assert_fails('source Xdupdir/autoload/dup4func.vim', 'E707:')
lines =<< trim END
vim9script
export def Func()
enddef
END
- writefile(lines, 'Xdir/autoload/dup5func.vim')
- assert_fails('source Xdir/autoload/dup5func.vim', 'E707:')
+ writefile(lines, 'Xdupdir/autoload/dup5func.vim')
+ assert_fails('source Xdupdir/autoload/dup5func.vim', 'E707:')
lines =<< trim END
vim9script
var Func = 'asdf'
END
- writefile(lines, 'Xdir/autoload/dup6func.vim')
- assert_fails('source Xdir/autoload/dup6func.vim', 'E1041: Redefining script item: "Func"')
+ writefile(lines, 'Xdupdir/autoload/dup6func.vim')
+ assert_fails('source Xdupdir/autoload/dup6func.vim', 'E1041: Redefining script item: "Func"')
- delete('Xdir', 'rf')
+ delete('Xdupdir', 'rf')
enddef
def Test_autoload_missing_function_name()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xmisdir/autoload', 'p')
var lines =<< trim END
vim9script
def loadme#()
enddef
END
- writefile(lines, 'Xdir/autoload/loadme.vim')
- assert_fails('source Xdir/autoload/loadme.vim', 'E129:')
+ writefile(lines, 'Xmisdir/autoload/loadme.vim')
+ assert_fails('source Xmisdir/autoload/loadme.vim', 'E129:')
- delete('Xdir', 'rf')
+ delete('Xmisdir', 'rf')
enddef
def Test_autoload_name_wrong()
v9.CheckScriptFailure(lines, 'E746:')
delete('Xscriptname.vim')
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xwrodir/autoload', 'p')
lines =<< trim END
vim9script
def somescript#Func()
enddef
END
- writefile(lines, 'Xdir/autoload/somescript.vim')
- assert_fails('source Xdir/autoload/somescript.vim', 'E1263:')
+ writefile(lines, 'Xwrodir/autoload/somescript.vim')
+ assert_fails('source Xwrodir/autoload/somescript.vim', 'E1263:')
- delete('Xdir', 'rf')
+ delete('Xwrodir', 'rf')
enddef
def Test_import_autoload_postponed()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xpostdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xpostdir'
var lines =<< trim END
vim9script
return 'bla'
enddef
END
- writefile(lines, 'Xdir/autoload/postponed.vim')
+ writefile(lines, 'Xpostdir/autoload/postponed.vim')
lines =<< trim END
vim9script
assert_equal('true', g:loaded_postponed)
unlet g:loaded_postponed
- delete('Xdir', 'rf')
+ delete('Xpostdir', 'rf')
&rtp = save_rtp
enddef
def Test_import_autoload_override()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xoverdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xoverdir'
test_override('autoload', 1)
var lines =<< trim END
return 'bla'
enddef
END
- writefile(lines, 'Xdir/autoload/override.vim')
+ writefile(lines, 'Xoverdir/autoload/override.vim')
lines =<< trim END
vim9script
test_override('autoload', 0)
unlet g:loaded_override
- delete('Xdir', 'rf')
+ delete('Xoverdir', 'rf')
&rtp = save_rtp
enddef
def Test_autoload_mapping()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xmapdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xmapdir'
var lines =<< trim END
vim9script
g:doit_called = 'yes'
enddef
END
- writefile(lines, 'Xdir/autoload/toggle.vim')
+ writefile(lines, 'Xmapdir/autoload/toggle.vim')
lines =<< trim END
vim9script
nunmap yy
unlet g:toggle_loaded
unlet g:toggle_called
- delete('Xdir', 'rf')
+ delete('Xmapdir', 'rf')
&rtp = save_rtp
enddef
" test disassembling an auto-loaded function starting with "debug"
def Test_vim9_autoload_disass()
- mkdir('Xdir/autoload', 'p')
+ mkdir('Xdasdir/autoload', 'p')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xdasdir'
var lines =<< trim END
vim9script
return 'debug'
enddef
END
- writefile(lines, 'Xdir/autoload/debugit.vim')
+ writefile(lines, 'Xdasdir/autoload/debugit.vim')
lines =<< trim END
vim9script
return 'profile'
enddef
END
- writefile(lines, 'Xdir/autoload/profileit.vim')
+ writefile(lines, 'Xdasdir/autoload/profileit.vim')
lines =<< trim END
vim9script
END
v9.CheckScriptSuccess(lines)
- delete('Xdir', 'rf')
+ delete('Xdasdir', 'rf')
&rtp = save_rtp
enddef
enddef
END
- mkdir('Xdir/autoload', 'p')
- writefile(lines, 'Xdir/autoload/foo.vim')
+ mkdir('Xauldir/autoload', 'p')
+ writefile(lines, 'Xauldir/autoload/foo.vim')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xauldir'
augroup test
autocmd TextYankPost * call foo#Test()
augroup END
augroup test
autocmd!
augroup END
- delete('Xdir', 'rf')
+ delete('Xauldir', 'rf')
&rtp = save_rtp
enddef
enddef
END
- mkdir('Xdir/autoload', 'p')
- writefile(lines, 'Xdir/autoload/CaseSensitive.vim')
+ mkdir('Xcasedir/autoload', 'p')
+ writefile(lines, 'Xcasedir/autoload/CaseSensitive.vim')
var save_rtp = &rtp
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xcasedir'
lines =<< trim END
vim9script
v9.CheckScriptFailure(lines, 'E1262:')
endif
- delete('Xdir', 'rf')
+ delete('Xcasedir', 'rf')
&rtp = save_rtp
enddef
export def Func()
enddef
END
- mkdir('Xdir/autoload', 'p')
- writefile(lines, 'Xdir/autoload/script.vim')
+ mkdir('Xnordir/autoload', 'p')
+ writefile(lines, 'Xnordir/autoload/script.vim')
lines =<< trim END
vim9script
set cpo+=M
- exe 'set rtp^=' .. getcwd() .. '/Xdir'
+ exe 'set rtp^=' .. getcwd() .. '/Xnordir'
au CmdlineEnter : ++once timer_start(0, (_) => script#Func())
setline(1, 'some text')
END
term_sendkeys(buf, "\<Esc>u")
g:StopVimInTerminal(buf)
delete('XTest_redraw_cpo')
- delete('Xdir', 'rf')
+ delete('Xnordir', 'rf')
enddef
func Test_reject_declaration()
call delete('Xviminfo')
" Try to write the viminfo to a directory
- call mkdir('Xdir')
- call assert_fails('wviminfo Xdir', 'E137:')
- call assert_fails('rviminfo Xdir', 'E195:')
- call delete('Xdir', 'rf')
+ call mkdir('Xvifdir')
+ call assert_fails('wviminfo Xvifdir', 'E137:')
+ call assert_fails('rviminfo Xvifdir', 'E195:')
+ call delete('Xvifdir', 'rf')
endfunc
" Test for writing to an existing viminfo file merges the file marks
" Try to overwrite a directory
if has('unix')
- call mkdir('Xdir1')
- call assert_fails('write Xdir1', 'E17:')
- call delete('Xdir1', 'd')
+ call mkdir('Xwerdir1')
+ call assert_fails('write Xwerdir1', 'E17:')
+ call delete('Xwerdir1', 'd')
endif
" Test for :wall for a buffer with no name
" Root can do it too.
CheckNotRoot
- call mkdir('Xdir/')
- call writefile(['one'], 'Xdir/Xfile1')
- call setfperm('Xdir', 'r-xr--r--')
+ call mkdir('Xrodir/')
+ call writefile(['one'], 'Xrodir/Xfile1')
+ call setfperm('Xrodir', 'r-xr--r--')
" try to create a new file in the directory
- new Xdir/Xfile2
+ new Xrodir/Xfile2
call setline(1, 'two')
call assert_fails('write', 'E212:')
" try to create a backup file in the directory
- edit! Xdir/Xfile1
- set backupdir=./Xdir backupskip=
+ edit! Xrodir/Xfile1
+ set backupdir=./Xrodir backupskip=
set patchmode=.orig
call assert_fails('write', 'E509:')
- call setfperm('Xdir', 'rwxr--r--')
- call delete('Xdir', 'rf')
+ call setfperm('Xrodir', 'rwxr--r--')
+ call delete('Xrodir', 'rf')
set backupdir& backupskip& patchmode&
endfunc
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 323,
/**/
322,
/**/
projects / vim / commitdiff