2016-08-10 20:52:25 -07:00
|
|
|
" Tests for user defined commands
|
|
|
|
|
|
|
|
" Test for <mods> in user defined commands
|
|
|
|
function Test_cmdmods()
|
|
|
|
let g:mods = ''
|
|
|
|
|
2022-06-13 07:04:39 -07:00
|
|
|
command! -nargs=* MyCmd let g:mods = '<mods>'
|
2016-08-10 20:52:25 -07:00
|
|
|
|
|
|
|
MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
aboveleft MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('aboveleft', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
abo MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('aboveleft', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
belowright MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('belowright', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
bel MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('belowright', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
botright MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('botright', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
bo MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('botright', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
browse MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('browse', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
bro MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('browse', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
confirm MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('confirm', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
conf MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('confirm', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
hide MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('hide', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
hid MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('hide', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
keepalt MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepalt', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
keepa MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepalt', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
keepjumps MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepjumps', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
keepj MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepjumps', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
keepmarks MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepmarks', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
kee MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keepmarks', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
keeppatterns MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keeppatterns', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
keepp MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('keeppatterns', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
leftabove MyCmd " results in :aboveleft
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('aboveleft', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
lefta MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('aboveleft', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
lockmarks MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('lockmarks', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
loc MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('lockmarks', g:mods)
|
2022-07-03 06:17:03 -07:00
|
|
|
noautocmd MyCmd
|
|
|
|
call assert_equal('noautocmd', g:mods)
|
|
|
|
noa MyCmd
|
|
|
|
call assert_equal('noautocmd', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
noswapfile MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('noswapfile', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
nos MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('noswapfile', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
rightbelow MyCmd " results in :belowright
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('belowright', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
rightb MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('belowright', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
" sandbox MyCmd
|
2016-08-10 20:52:25 -07:00
|
|
|
silent MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('silent', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
sil MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('silent', g:mods)
|
2022-07-03 06:17:03 -07:00
|
|
|
silent! MyCmd
|
|
|
|
call assert_equal('silent!', g:mods)
|
|
|
|
sil! MyCmd
|
|
|
|
call assert_equal('silent!', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
tab MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('tab', g:mods)
|
2022-10-18 05:46:42 -07:00
|
|
|
0tab MyCmd
|
|
|
|
call assert_equal('0tab', g:mods)
|
|
|
|
tab split
|
|
|
|
tab MyCmd
|
|
|
|
call assert_equal('tab', g:mods)
|
|
|
|
1tab MyCmd
|
|
|
|
call assert_equal('1tab', g:mods)
|
|
|
|
tabprev
|
|
|
|
tab MyCmd
|
|
|
|
call assert_equal('tab', g:mods)
|
|
|
|
2tab MyCmd
|
|
|
|
call assert_equal('2tab', g:mods)
|
|
|
|
2tabclose
|
2016-08-10 20:52:25 -07:00
|
|
|
topleft MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('topleft', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
to MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('topleft', g:mods)
|
2022-07-03 06:17:03 -07:00
|
|
|
unsilent MyCmd
|
|
|
|
call assert_equal('unsilent', g:mods)
|
|
|
|
uns MyCmd
|
|
|
|
call assert_equal('unsilent', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
verbose MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('verbose', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
verb MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('verbose', g:mods)
|
2022-07-03 06:17:03 -07:00
|
|
|
0verbose MyCmd
|
|
|
|
call assert_equal('0verbose', g:mods)
|
|
|
|
3verbose MyCmd
|
|
|
|
call assert_equal('3verbose', g:mods)
|
|
|
|
999verbose MyCmd
|
|
|
|
call assert_equal('999verbose', g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
vertical MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('vertical', g:mods)
|
2017-01-05 05:22:07 -07:00
|
|
|
vert MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
call assert_equal('vertical', g:mods)
|
2022-09-01 05:25:34 -07:00
|
|
|
horizontal MyCmd
|
|
|
|
call assert_equal('horizontal', g:mods)
|
|
|
|
hor MyCmd
|
|
|
|
call assert_equal('horizontal', g:mods)
|
2016-08-25 18:54:00 -07:00
|
|
|
|
2016-08-10 20:52:25 -07:00
|
|
|
aboveleft belowright botright browse confirm hide keepalt keepjumps
|
2022-07-03 06:17:03 -07:00
|
|
|
\ keepmarks keeppatterns lockmarks noautocmd noswapfile silent
|
|
|
|
\ tab topleft unsilent verbose vertical MyCmd
|
2022-06-13 07:04:39 -07:00
|
|
|
|
|
|
|
call assert_equal('browse confirm hide keepalt keepjumps ' .
|
2022-07-03 06:17:03 -07:00
|
|
|
\ 'keepmarks keeppatterns lockmarks noswapfile unsilent noautocmd ' .
|
|
|
|
\ 'silent verbose aboveleft belowright botright tab topleft vertical',
|
|
|
|
\ g:mods)
|
2016-08-10 20:52:25 -07:00
|
|
|
|
2016-08-25 18:54:00 -07:00
|
|
|
let g:mods = ''
|
2016-08-10 20:52:25 -07:00
|
|
|
command! -nargs=* MyQCmd let g:mods .= '<q-mods> '
|
2016-08-25 18:54:00 -07:00
|
|
|
|
2016-08-10 20:52:25 -07:00
|
|
|
vertical MyQCmd
|
|
|
|
call assert_equal('"vertical" ', g:mods)
|
|
|
|
|
|
|
|
delcommand MyCmd
|
|
|
|
delcommand MyQCmd
|
|
|
|
unlet g:mods
|
|
|
|
endfunction
|
2017-01-05 05:55:32 -07:00
|
|
|
|
2019-06-11 04:56:16 -07:00
|
|
|
func SaveCmdArgs(...)
|
|
|
|
let g:args = a:000
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_f_args()
|
|
|
|
command -nargs=* TestFArgs call SaveCmdArgs(<f-args>)
|
|
|
|
|
|
|
|
TestFArgs
|
|
|
|
call assert_equal([], g:args)
|
|
|
|
|
|
|
|
TestFArgs one two three
|
|
|
|
call assert_equal(['one', 'two', 'three'], g:args)
|
|
|
|
|
|
|
|
TestFArgs one\\two three
|
|
|
|
call assert_equal(['one\two', 'three'], g:args)
|
|
|
|
|
|
|
|
TestFArgs one\ two three
|
|
|
|
call assert_equal(['one two', 'three'], g:args)
|
|
|
|
|
|
|
|
TestFArgs one\"two three
|
|
|
|
call assert_equal(['one\"two', 'three'], g:args)
|
|
|
|
|
|
|
|
delcommand TestFArgs
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_q_args()
|
|
|
|
command -nargs=* TestQArgs call SaveCmdArgs(<q-args>)
|
|
|
|
|
|
|
|
TestQArgs
|
|
|
|
call assert_equal([''], g:args)
|
|
|
|
|
|
|
|
TestQArgs one two three
|
|
|
|
call assert_equal(['one two three'], g:args)
|
|
|
|
|
|
|
|
TestQArgs one\\two three
|
|
|
|
call assert_equal(['one\\two three'], g:args)
|
|
|
|
|
|
|
|
TestQArgs one\ two three
|
|
|
|
call assert_equal(['one\ two three'], g:args)
|
|
|
|
|
|
|
|
TestQArgs one\"two three
|
|
|
|
call assert_equal(['one\"two three'], g:args)
|
|
|
|
|
|
|
|
delcommand TestQArgs
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_reg_arg()
|
|
|
|
command -nargs=* -reg TestRegArg call SaveCmdArgs("<reg>", "<register>")
|
|
|
|
|
|
|
|
TestRegArg
|
|
|
|
call assert_equal(['', ''], g:args)
|
|
|
|
|
|
|
|
TestRegArg x
|
|
|
|
call assert_equal(['x', 'x'], g:args)
|
|
|
|
|
|
|
|
delcommand TestRegArg
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_no_arg()
|
|
|
|
command -nargs=* TestNoArg call SaveCmdArgs("<args>", "<>", "<x>", "<lt>")
|
|
|
|
|
|
|
|
TestNoArg
|
|
|
|
call assert_equal(['', '<>', '<x>', '<'], g:args)
|
|
|
|
|
|
|
|
TestNoArg one
|
|
|
|
call assert_equal(['one', '<>', '<x>', '<'], g:args)
|
|
|
|
|
|
|
|
delcommand TestNoArg
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_range_arg()
|
|
|
|
command -range TestRangeArg call SaveCmdArgs(<range>, <line1>, <line2>)
|
|
|
|
new
|
|
|
|
call setline(1, range(100))
|
|
|
|
let lnum = line('.')
|
|
|
|
|
|
|
|
TestRangeArg
|
|
|
|
call assert_equal([0, lnum, lnum], g:args)
|
|
|
|
|
|
|
|
99TestRangeArg
|
|
|
|
call assert_equal([1, 99, 99], g:args)
|
|
|
|
|
|
|
|
88,99TestRangeArg
|
|
|
|
call assert_equal([2, 88, 99], g:args)
|
|
|
|
|
|
|
|
call assert_fails('102TestRangeArg', 'E16:')
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
delcommand TestRangeArg
|
|
|
|
endfunc
|
|
|
|
|
2017-01-05 05:55:32 -07:00
|
|
|
func Test_Ambiguous()
|
|
|
|
command Doit let g:didit = 'yes'
|
|
|
|
command Dothat let g:didthat = 'also'
|
|
|
|
call assert_fails('Do', 'E464:')
|
|
|
|
Doit
|
|
|
|
call assert_equal('yes', g:didit)
|
|
|
|
Dothat
|
|
|
|
call assert_equal('also', g:didthat)
|
|
|
|
unlet g:didit
|
|
|
|
unlet g:didthat
|
|
|
|
|
|
|
|
delcommand Doit
|
|
|
|
Do
|
|
|
|
call assert_equal('also', g:didthat)
|
|
|
|
delcommand Dothat
|
2019-06-11 04:56:16 -07:00
|
|
|
|
|
|
|
" Nvim removed the ":Ni!" easter egg in 87e107d92.
|
|
|
|
call assert_fails("\x4ei\041", 'E492: Not an editor command: Ni!')
|
2017-01-05 05:55:32 -07:00
|
|
|
endfunc
|
|
|
|
|
2019-10-30 19:22:23 -07:00
|
|
|
func Test_redefine_on_reload()
|
|
|
|
call writefile(['command ExistingCommand echo "yes"'], 'Xcommandexists')
|
|
|
|
call assert_equal(0, exists(':ExistingCommand'))
|
|
|
|
source Xcommandexists
|
|
|
|
call assert_equal(2, exists(':ExistingCommand'))
|
|
|
|
" Redefining a command when reloading a script is OK.
|
|
|
|
source Xcommandexists
|
|
|
|
call assert_equal(2, exists(':ExistingCommand'))
|
|
|
|
|
|
|
|
" But redefining in another script is not OK.
|
|
|
|
call writefile(['command ExistingCommand echo "yes"'], 'Xcommandexists2')
|
|
|
|
call assert_fails('source Xcommandexists2', 'E174:')
|
|
|
|
call delete('Xcommandexists2')
|
|
|
|
|
|
|
|
" And defining twice in one script is not OK.
|
|
|
|
delcommand ExistingCommand
|
|
|
|
call assert_equal(0, exists(':ExistingCommand'))
|
|
|
|
call writefile([
|
|
|
|
\ 'command ExistingCommand echo "yes"',
|
|
|
|
\ 'command ExistingCommand echo "no"',
|
|
|
|
\ ], 'Xcommandexists')
|
|
|
|
call assert_fails('source Xcommandexists', 'E174:')
|
|
|
|
call assert_equal(2, exists(':ExistingCommand'))
|
|
|
|
|
|
|
|
call delete('Xcommandexists')
|
|
|
|
delcommand ExistingCommand
|
|
|
|
endfunc
|
|
|
|
|
2017-01-05 05:55:32 -07:00
|
|
|
func Test_CmdUndefined()
|
|
|
|
call assert_fails('Doit', 'E492:')
|
|
|
|
au CmdUndefined Doit :command Doit let g:didit = 'yes'
|
|
|
|
Doit
|
|
|
|
call assert_equal('yes', g:didit)
|
|
|
|
delcommand Doit
|
|
|
|
|
|
|
|
call assert_fails('Dothat', 'E492:')
|
|
|
|
au CmdUndefined * let g:didnot = 'yes'
|
|
|
|
call assert_fails('Dothat', 'E492:')
|
|
|
|
call assert_equal('yes', g:didnot)
|
|
|
|
endfunc
|
2017-11-10 16:00:11 -07:00
|
|
|
|
|
|
|
func Test_CmdErrors()
|
|
|
|
call assert_fails('com! docmd :', 'E183:')
|
|
|
|
call assert_fails('com! \<Tab> :', 'E182:')
|
|
|
|
call assert_fails('com! _ :', 'E182:')
|
|
|
|
call assert_fails('com! - DoCmd :', 'E175:')
|
|
|
|
call assert_fails('com! -xxx DoCmd :', 'E181:')
|
|
|
|
call assert_fails('com! -addr DoCmd :', 'E179:')
|
2019-06-11 04:56:16 -07:00
|
|
|
call assert_fails('com! -addr=asdf DoCmd :', 'E180:')
|
2017-11-10 16:00:11 -07:00
|
|
|
call assert_fails('com! -complete DoCmd :', 'E179:')
|
|
|
|
call assert_fails('com! -complete=xxx DoCmd :', 'E180:')
|
|
|
|
call assert_fails('com! -complete=custom DoCmd :', 'E467:')
|
|
|
|
call assert_fails('com! -complete=customlist DoCmd :', 'E467:')
|
2023-04-13 04:07:42 -07:00
|
|
|
" call assert_fails('com! -complete=behave,CustomComplete DoCmd :', 'E468:')
|
2021-08-02 21:57:38 -07:00
|
|
|
call assert_fails('com! -complete=file DoCmd :', 'E1208:')
|
|
|
|
call assert_fails('com! -nargs=0 -complete=file DoCmd :', 'E1208:')
|
2017-11-10 16:00:11 -07:00
|
|
|
call assert_fails('com! -nargs=x DoCmd :', 'E176:')
|
|
|
|
call assert_fails('com! -count=1 -count=2 DoCmd :', 'E177:')
|
|
|
|
call assert_fails('com! -count=x DoCmd :', 'E178:')
|
|
|
|
call assert_fails('com! -range=x DoCmd :', 'E178:')
|
|
|
|
|
|
|
|
com! -nargs=0 DoCmd :
|
|
|
|
call assert_fails('DoCmd x', 'E488:')
|
|
|
|
|
|
|
|
com! -nargs=1 DoCmd :
|
|
|
|
call assert_fails('DoCmd', 'E471:')
|
|
|
|
|
|
|
|
com! -nargs=+ DoCmd :
|
|
|
|
call assert_fails('DoCmd', 'E471:')
|
|
|
|
|
|
|
|
call assert_fails('com DoCmd :', 'E174:')
|
|
|
|
comclear
|
|
|
|
call assert_fails('delcom DoCmd', 'E184:')
|
2022-12-19 14:24:03 -07:00
|
|
|
|
|
|
|
" These used to leak memory
|
|
|
|
call assert_fails('com! -complete=custom,CustomComplete _ :', 'E182:')
|
|
|
|
call assert_fails('com! -complete=custom,CustomComplete docmd :', 'E183:')
|
|
|
|
call assert_fails('com! -complete=custom,CustomComplete -xxx DoCmd :', 'E181:')
|
2017-11-10 16:00:11 -07:00
|
|
|
endfunc
|
|
|
|
|
|
|
|
func CustomComplete(A, L, P)
|
|
|
|
return "January\nFebruary\nMars\n"
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func CustomCompleteList(A, L, P)
|
2022-12-08 15:15:03 -07:00
|
|
|
return [ "Monday", "Tuesday", "Wednesday", {}, v:_null_string]
|
2017-11-10 16:00:11 -07:00
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_CmdCompletion()
|
|
|
|
call feedkeys(":com -\<C-A>\<C-B>\"\<CR>", 'tx')
|
2022-01-21 03:18:18 -07:00
|
|
|
call assert_equal('"com -addr bang bar buffer complete count keepscript nargs range register', @:)
|
2017-11-10 16:00:11 -07:00
|
|
|
|
|
|
|
call feedkeys(":com -nargs=0 -\<C-A>\<C-B>\"\<CR>", 'tx')
|
2022-01-21 03:18:18 -07:00
|
|
|
call assert_equal('"com -nargs=0 -addr bang bar buffer complete count keepscript nargs range register', @:)
|
2017-11-10 16:00:11 -07:00
|
|
|
|
|
|
|
call feedkeys(":com -nargs=\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"com -nargs=* + 0 1 ?', @:)
|
|
|
|
|
|
|
|
call feedkeys(":com -addr=\<C-A>\<C-B>\"\<CR>", 'tx')
|
2019-10-30 18:50:52 -07:00
|
|
|
call assert_equal('"com -addr=arguments buffers lines loaded_buffers other quickfix tabs windows', @:)
|
2017-11-10 16:00:11 -07:00
|
|
|
|
|
|
|
call feedkeys(":com -complete=co\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"com -complete=color command compiler', @:)
|
|
|
|
|
2023-01-14 08:44:38 -07:00
|
|
|
" try completion for unsupported argument values
|
|
|
|
call feedkeys(":com -newarg=\<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal("\"com -newarg=\t", @:)
|
|
|
|
|
|
|
|
" command completion after the name in a user defined command
|
|
|
|
call feedkeys(":com MyCmd chist\<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal("\"com MyCmd chistory", @:)
|
|
|
|
|
2017-11-10 16:00:11 -07:00
|
|
|
command! DoCmd1 :
|
|
|
|
command! DoCmd2 :
|
|
|
|
call feedkeys(":com \<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"com DoCmd1 DoCmd2', @:)
|
|
|
|
|
|
|
|
call feedkeys(":DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd1 DoCmd2', @:)
|
|
|
|
|
|
|
|
call feedkeys(":delcom DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"delcom DoCmd1 DoCmd2', @:)
|
|
|
|
|
2023-01-14 08:44:38 -07:00
|
|
|
" try argument completion for a command without completion
|
|
|
|
call feedkeys(":DoCmd1 \<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal("\"DoCmd1 \t", @:)
|
|
|
|
|
2017-11-10 16:00:11 -07:00
|
|
|
delcom DoCmd1
|
|
|
|
call feedkeys(":delcom DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"delcom DoCmd2', @:)
|
|
|
|
|
|
|
|
call feedkeys(":com DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"com DoCmd2', @:)
|
|
|
|
|
|
|
|
delcom DoCmd2
|
|
|
|
call feedkeys(":delcom DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"delcom DoC', @:)
|
|
|
|
|
|
|
|
call feedkeys(":com DoC\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"com DoC', @:)
|
|
|
|
|
2023-04-13 04:07:42 -07:00
|
|
|
" com! -nargs=1 -complete=behave DoCmd :
|
|
|
|
" call feedkeys(":DoCmd \<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
" call assert_equal('"DoCmd mswin xterm', @:)
|
|
|
|
|
2023-01-14 08:44:38 -07:00
|
|
|
" Test for file name completion
|
|
|
|
com! -nargs=1 -complete=file DoCmd :
|
|
|
|
call feedkeys(":DoCmd READM\<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd README.txt', @:)
|
|
|
|
|
|
|
|
" Test for buffer name completion
|
|
|
|
com! -nargs=1 -complete=buffer DoCmd :
|
|
|
|
let bnum = bufadd('BufForUserCmd')
|
|
|
|
call setbufvar(bnum, '&buflisted', 1)
|
|
|
|
call feedkeys(":DoCmd BufFor\<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd BufForUserCmd', @:)
|
|
|
|
bwipe BufForUserCmd
|
|
|
|
call feedkeys(":DoCmd BufFor\<Tab>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd BufFor', @:)
|
|
|
|
|
2021-08-02 21:57:38 -07:00
|
|
|
com! -nargs=* -complete=custom,CustomComplete DoCmd :
|
2017-11-10 16:00:11 -07:00
|
|
|
call feedkeys(":DoCmd \<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd January February Mars', @:)
|
|
|
|
|
2021-08-02 21:57:38 -07:00
|
|
|
com! -nargs=? -complete=customlist,CustomCompleteList DoCmd :
|
2017-11-10 16:00:11 -07:00
|
|
|
call feedkeys(":DoCmd \<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoCmd Monday Tuesday Wednesday', @:)
|
|
|
|
|
2021-08-02 21:57:38 -07:00
|
|
|
com! -nargs=+ -complete=custom,CustomCompleteList DoCmd :
|
2017-11-10 16:00:11 -07:00
|
|
|
call assert_fails("call feedkeys(':DoCmd \<C-D>', 'tx')", 'E730:')
|
|
|
|
|
2021-08-02 21:57:38 -07:00
|
|
|
com! -nargs=+ -complete=customlist,CustomComp DoCmd :
|
2017-11-10 16:00:11 -07:00
|
|
|
call assert_fails("call feedkeys(':DoCmd \<C-D>', 'tx')", 'E117:')
|
2021-08-02 21:57:38 -07:00
|
|
|
|
|
|
|
" custom completion without a function
|
|
|
|
com! -nargs=? -complete=custom, DoCmd
|
|
|
|
call assert_beeps("call feedkeys(':DoCmd \t', 'tx')")
|
|
|
|
|
|
|
|
" custom completion failure with the wrong function
|
|
|
|
com! -nargs=? -complete=custom,min DoCmd
|
|
|
|
call assert_fails("call feedkeys(':DoCmd \t', 'tx')", 'E118:')
|
|
|
|
|
2022-12-08 15:12:13 -07:00
|
|
|
" custom completion for a pattern with a backslash
|
|
|
|
let g:ArgLead = ''
|
|
|
|
func! CustCompl(A, L, P)
|
|
|
|
let g:ArgLead = a:A
|
|
|
|
return ['one', 'two', 'three']
|
|
|
|
endfunc
|
|
|
|
com! -nargs=? -complete=customlist,CustCompl DoCmd
|
|
|
|
call feedkeys(":DoCmd a\\\t", 'xt')
|
|
|
|
call assert_equal('a\', g:ArgLead)
|
|
|
|
delfunc CustCompl
|
|
|
|
|
2021-08-02 21:57:38 -07:00
|
|
|
delcom DoCmd
|
2017-11-10 16:00:11 -07:00
|
|
|
endfunc
|
2018-12-05 17:14:19 -07:00
|
|
|
|
|
|
|
func CallExecute(A, L, P)
|
|
|
|
" Drop first '\n'
|
|
|
|
return execute('echo "hi"')[1:]
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_use_execute_in_completion()
|
|
|
|
command! -nargs=* -complete=custom,CallExecute DoExec :
|
|
|
|
call feedkeys(":DoExec \<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
call assert_equal('"DoExec hi', @:)
|
|
|
|
delcommand DoExec
|
|
|
|
endfunc
|
2019-10-30 18:50:52 -07:00
|
|
|
|
|
|
|
func Test_addr_all()
|
|
|
|
command! -addr=lines DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
%DoSomething
|
|
|
|
call assert_equal(1, g:a1)
|
|
|
|
call assert_equal(line('$'), g:a2)
|
|
|
|
|
|
|
|
command! -addr=arguments DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
args one two three
|
|
|
|
%DoSomething
|
|
|
|
call assert_equal(1, g:a1)
|
|
|
|
call assert_equal(3, g:a2)
|
|
|
|
|
|
|
|
command! -addr=buffers DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
%DoSomething
|
|
|
|
for low in range(1, bufnr('$'))
|
|
|
|
if buflisted(low)
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endfor
|
|
|
|
call assert_equal(low, g:a1)
|
|
|
|
call assert_equal(bufnr('$'), g:a2)
|
|
|
|
|
|
|
|
command! -addr=loaded_buffers DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
%DoSomething
|
|
|
|
for low in range(1, bufnr('$'))
|
|
|
|
if bufloaded(low)
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endfor
|
|
|
|
call assert_equal(low, g:a1)
|
|
|
|
for up in range(bufnr('$'), 1, -1)
|
|
|
|
if bufloaded(up)
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endfor
|
|
|
|
call assert_equal(up, g:a2)
|
|
|
|
|
|
|
|
command! -addr=windows DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
new
|
|
|
|
%DoSomething
|
|
|
|
call assert_equal(1, g:a1)
|
|
|
|
call assert_equal(winnr('$'), g:a2)
|
|
|
|
bwipe
|
|
|
|
|
|
|
|
command! -addr=tabs DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
|
|
|
tabnew
|
|
|
|
%DoSomething
|
|
|
|
call assert_equal(1, g:a1)
|
|
|
|
call assert_equal(len(gettabinfo()), g:a2)
|
|
|
|
bwipe
|
|
|
|
|
2020-12-31 17:56:15 -07:00
|
|
|
command! -addr=other DoSomething let g:a1 = <line1> | let g:a2 = <line2>
|
2019-10-30 18:50:52 -07:00
|
|
|
DoSomething
|
2020-12-31 17:56:15 -07:00
|
|
|
call assert_equal(line('.'), g:a1)
|
|
|
|
call assert_equal(line('.'), g:a2)
|
|
|
|
%DoSomething
|
|
|
|
call assert_equal(1, g:a1)
|
|
|
|
call assert_equal(line('$'), g:a2)
|
2019-10-30 18:50:52 -07:00
|
|
|
|
|
|
|
delcommand DoSomething
|
|
|
|
endfunc
|
2019-10-31 02:39:24 -07:00
|
|
|
|
|
|
|
func Test_command_list()
|
|
|
|
command! DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test with various -range= and -count= argument values.
|
|
|
|
command! -range DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -range=% DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 % :",
|
|
|
|
\ execute('command! DoCmd'))
|
|
|
|
command! -range=2 DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 2 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -count=2 DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
2020-12-31 17:56:15 -07:00
|
|
|
\ .. "\n DoCmd 0 2c ? :",
|
2019-10-31 02:39:24 -07:00
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test with various -addr= argument values.
|
|
|
|
command! -addr=lines DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=arguments DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . arg :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=buffers DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . buf :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=loaded_buffers DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . load :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=windows DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . win :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=tabs DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . tab :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -addr=other DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 . ? :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test with various -complete= argument values (non-exhaustive list)
|
2021-08-02 21:57:38 -07:00
|
|
|
command! -nargs=1 -complete=arglist DoCmd :
|
2019-10-31 02:39:24 -07:00
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
2021-08-02 21:57:38 -07:00
|
|
|
\ .. "\n DoCmd 1 arglist :",
|
2019-10-31 02:39:24 -07:00
|
|
|
\ execute('command DoCmd'))
|
2021-08-02 21:57:38 -07:00
|
|
|
command! -nargs=* -complete=augroup DoCmd :
|
2019-10-31 02:39:24 -07:00
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
2021-08-02 21:57:38 -07:00
|
|
|
\ .. "\n DoCmd * augroup :",
|
2019-10-31 02:39:24 -07:00
|
|
|
\ execute('command DoCmd'))
|
2021-08-02 21:57:38 -07:00
|
|
|
command! -nargs=? -complete=custom,CustomComplete DoCmd :
|
2019-10-31 02:39:24 -07:00
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
2021-08-02 21:57:38 -07:00
|
|
|
\ .. "\n DoCmd ? custom :",
|
2019-10-31 02:39:24 -07:00
|
|
|
\ execute('command DoCmd'))
|
2021-08-02 21:57:38 -07:00
|
|
|
command! -nargs=+ -complete=customlist,CustomComplete DoCmd :
|
2019-10-31 02:39:24 -07:00
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
2021-08-02 21:57:38 -07:00
|
|
|
\ .. "\n DoCmd + customlist :",
|
2019-10-31 02:39:24 -07:00
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test with various -narg= argument values.
|
|
|
|
command! -nargs=0 DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -nargs=1 DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 1 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -nargs=* DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd * :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -nargs=? DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd ? :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -nargs=+ DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd + :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test with other arguments.
|
|
|
|
command! -bang DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n! DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -bar DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n| DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -register DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n\" DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
command! -buffer DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\nb DoCmd 0 :"
|
|
|
|
\ .. "\n\" DoCmd 0 :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
comclear
|
|
|
|
|
|
|
|
" Test with many args.
|
|
|
|
command! -bang -bar -register -buffer -nargs=+ -complete=environment -addr=windows -count=3 DoCmd :
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n!\"b|DoCmd + 3c win environment :",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
comclear
|
|
|
|
|
|
|
|
" Test with special characters in command definition.
|
|
|
|
command! DoCmd :<cr><tab><c-d>
|
|
|
|
call assert_equal("\n Name Args Address Complete Definition"
|
|
|
|
\ .. "\n DoCmd 0 :<CR><Tab><C-D>",
|
|
|
|
\ execute('command DoCmd'))
|
|
|
|
|
|
|
|
" Test output in verbose mode.
|
|
|
|
command! DoCmd :
|
|
|
|
call assert_match("^\n"
|
|
|
|
\ .. " Name Args Address Complete Definition\n"
|
|
|
|
\ .. " DoCmd 0 :\n"
|
|
|
|
\ .. "\tLast set from .*/test_usercommands.vim line \\d\\+$",
|
|
|
|
\ execute('verbose command DoCmd'))
|
|
|
|
|
|
|
|
comclear
|
|
|
|
call assert_equal("\nNo user-defined commands found", execute(':command Xxx'))
|
|
|
|
call assert_equal("\nNo user-defined commands found", execute('command'))
|
|
|
|
endfunc
|
2022-01-29 10:00:37 -07:00
|
|
|
|
2022-10-25 22:41:43 -07:00
|
|
|
" Test for a custom user completion returning the wrong value type
|
|
|
|
func Test_usercmd_custom()
|
|
|
|
func T1(a, c, p)
|
|
|
|
return "a\nb\n"
|
|
|
|
endfunc
|
|
|
|
command -nargs=* -complete=customlist,T1 TCmd1
|
2022-10-26 04:53:54 -07:00
|
|
|
call feedkeys(":TCmd1 \<C-A>\<C-B>\"\<CR>", 'xt')
|
|
|
|
call assert_equal('"TCmd1 ', @:)
|
2022-10-25 22:41:43 -07:00
|
|
|
delcommand TCmd1
|
|
|
|
delfunc T1
|
|
|
|
|
|
|
|
func T2(a, c, p)
|
2022-10-26 04:53:54 -07:00
|
|
|
return {}
|
2022-10-25 22:41:43 -07:00
|
|
|
endfunc
|
|
|
|
command -nargs=* -complete=customlist,T2 TCmd2
|
2022-10-26 04:53:54 -07:00
|
|
|
call feedkeys(":TCmd2 \<C-A>\<C-B>\"\<CR>", 'xt')
|
|
|
|
call assert_equal('"TCmd2 ', @:)
|
2022-10-25 22:41:43 -07:00
|
|
|
delcommand TCmd2
|
|
|
|
delfunc T2
|
|
|
|
endfunc
|
|
|
|
|
2022-01-29 10:00:37 -07:00
|
|
|
func Test_delcommand_buffer()
|
|
|
|
command Global echo 'global'
|
|
|
|
command -buffer OneBuffer echo 'one'
|
|
|
|
new
|
|
|
|
command -buffer TwoBuffer echo 'two'
|
|
|
|
call assert_equal(0, exists(':OneBuffer'))
|
|
|
|
call assert_equal(2, exists(':Global'))
|
|
|
|
call assert_equal(2, exists(':TwoBuffer'))
|
|
|
|
delcommand -buffer TwoBuffer
|
|
|
|
call assert_equal(0, exists(':TwoBuffer'))
|
|
|
|
call assert_fails('delcommand -buffer Global', 'E1237:')
|
|
|
|
call assert_fails('delcommand -buffer OneBuffer', 'E1237:')
|
|
|
|
bwipe!
|
|
|
|
call assert_equal(2, exists(':OneBuffer'))
|
|
|
|
delcommand -buffer OneBuffer
|
|
|
|
call assert_equal(0, exists(':OneBuffer'))
|
|
|
|
call assert_fails('delcommand -buffer Global', 'E1237:')
|
|
|
|
delcommand Global
|
|
|
|
call assert_equal(0, exists(':Global'))
|
|
|
|
endfunc
|
|
|
|
|
2022-03-12 01:25:28 -07:00
|
|
|
func DefCmd(name)
|
|
|
|
if len(a:name) > 30
|
|
|
|
return
|
|
|
|
endif
|
|
|
|
exe 'command ' .. a:name .. ' call DefCmd("' .. a:name .. 'x")'
|
|
|
|
echo a:name
|
|
|
|
exe a:name
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_recursive_define()
|
|
|
|
call DefCmd('Command')
|
|
|
|
|
|
|
|
let name = 'Command'
|
|
|
|
while len(name) < 30
|
|
|
|
exe 'delcommand ' .. name
|
|
|
|
let name ..= 'x'
|
|
|
|
endwhile
|
|
|
|
endfunc
|
|
|
|
|
2023-01-14 08:44:38 -07:00
|
|
|
" Test for using buffer-local ambiguous user-defined commands
|
|
|
|
func Test_buflocal_ambiguous_usercmd()
|
|
|
|
new
|
|
|
|
command -buffer -nargs=1 -complete=sign TestCmd1 echo "Hello"
|
|
|
|
command -buffer -nargs=1 -complete=sign TestCmd2 echo "World"
|
|
|
|
|
|
|
|
call assert_fails("call feedkeys(':TestCmd\<CR>', 'xt')", 'E464:')
|
|
|
|
call feedkeys(":TestCmd \<Tab>\<C-B>\"\<CR>", 'xt')
|
|
|
|
call assert_equal('"TestCmd ', @:)
|
|
|
|
|
|
|
|
delcommand TestCmd1
|
|
|
|
delcommand TestCmd2
|
|
|
|
bw!
|
|
|
|
endfunc
|
|
|
|
|
2023-02-20 08:55:42 -07:00
|
|
|
" Test for using buffer-local user command from cmdwin.
|
|
|
|
func Test_buflocal_usercmd_cmdwin()
|
|
|
|
new
|
|
|
|
command -buffer TestCmd edit Test
|
|
|
|
" This used to crash Vim
|
|
|
|
call assert_fails("norm q::TestCmd\<CR>", 'E11:')
|
|
|
|
bw!
|
|
|
|
endfunc
|
|
|
|
|
2023-01-14 08:44:38 -07:00
|
|
|
" Test for using a multibyte character in a user command
|
|
|
|
func Test_multibyte_in_usercmd()
|
|
|
|
command SubJapanesePeriodToDot exe "%s/\u3002/./g"
|
|
|
|
new
|
|
|
|
call setline(1, "Hello\u3002")
|
|
|
|
SubJapanesePeriodToDot
|
|
|
|
call assert_equal('Hello.', getline(1))
|
|
|
|
bw!
|
|
|
|
delcommand SubJapanesePeriodToDot
|
|
|
|
endfunc
|
2022-03-12 01:25:28 -07:00
|
|
|
|
2022-01-29 10:00:37 -07:00
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|