2017-03-13 05:07:36 -07:00
|
|
|
|
" Tests for mappings and abbreviations
|
|
|
|
|
|
2019-04-25 20:58:44 -07:00
|
|
|
|
source shared.vim
|
2022-02-16 16:18:10 -07:00
|
|
|
|
source check.vim
|
|
|
|
|
source screendump.vim
|
2019-04-25 20:58:44 -07:00
|
|
|
|
|
2017-03-13 05:07:36 -07:00
|
|
|
|
func Test_abbreviation()
|
|
|
|
|
" abbreviation with 0x80 should work
|
|
|
|
|
inoreab чкпр vim
|
|
|
|
|
call feedkeys("Goчкпр \<Esc>", "xt")
|
|
|
|
|
call assert_equal('vim ', getline('$'))
|
|
|
|
|
iunab чкпр
|
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
|
|
|
|
|
2019-06-08 05:53:32 -07:00
|
|
|
|
func Test_abclear()
|
|
|
|
|
abbrev foo foobar
|
|
|
|
|
iabbrev fooi foobari
|
|
|
|
|
cabbrev fooc foobarc
|
|
|
|
|
call assert_equal("\n\nc fooc foobarc\ni fooi foobari\n! foo foobar", execute('abbrev'))
|
|
|
|
|
|
|
|
|
|
iabclear
|
|
|
|
|
call assert_equal("\n\nc fooc foobarc\nc foo foobar", execute('abbrev'))
|
|
|
|
|
abbrev foo foobar
|
|
|
|
|
iabbrev fooi foobari
|
|
|
|
|
|
|
|
|
|
cabclear
|
|
|
|
|
call assert_equal("\n\ni fooi foobari\ni foo foobar", execute('abbrev'))
|
|
|
|
|
abbrev foo foobar
|
|
|
|
|
cabbrev fooc foobarc
|
|
|
|
|
|
|
|
|
|
abclear
|
|
|
|
|
call assert_equal("\n\nNo abbreviation found", execute('abbrev'))
|
2022-07-01 18:52:05 -07:00
|
|
|
|
call assert_fails('%abclear', 'E481:')
|
2019-06-08 05:53:32 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_abclear_buffer()
|
|
|
|
|
abbrev foo foobar
|
|
|
|
|
new X1
|
|
|
|
|
abbrev <buffer> foo1 foobar1
|
|
|
|
|
new X2
|
|
|
|
|
abbrev <buffer> foo2 foobar2
|
|
|
|
|
|
|
|
|
|
call assert_equal("\n\n! foo2 @foobar2\n! foo foobar", execute('abbrev'))
|
|
|
|
|
|
|
|
|
|
abclear <buffer>
|
|
|
|
|
call assert_equal("\n\n! foo foobar", execute('abbrev'))
|
|
|
|
|
|
|
|
|
|
b X1
|
|
|
|
|
call assert_equal("\n\n! foo1 @foobar1\n! foo foobar", execute('abbrev'))
|
|
|
|
|
abclear <buffer>
|
|
|
|
|
call assert_equal("\n\n! foo foobar", execute('abbrev'))
|
|
|
|
|
|
|
|
|
|
abclear
|
|
|
|
|
call assert_equal("\n\nNo abbreviation found", execute('abbrev'))
|
|
|
|
|
|
|
|
|
|
%bwipe
|
|
|
|
|
endfunc
|
|
|
|
|
|
2017-03-13 05:07:36 -07:00
|
|
|
|
func Test_map_ctrl_c_insert()
|
|
|
|
|
" mapping of ctrl-c in Insert mode
|
|
|
|
|
set cpo-=< cpo-=k
|
|
|
|
|
inoremap <c-c> <ctrl-c>
|
|
|
|
|
cnoremap <c-c> dummy
|
|
|
|
|
cunmap <c-c>
|
2022-04-26 00:31:29 -07:00
|
|
|
|
call feedkeys("GoTEST2: CTRL-C |\<*C-C>A|\<Esc>", "xt")
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call assert_equal('TEST2: CTRL-C |<ctrl-c>A|', getline('$'))
|
|
|
|
|
unmap! <c-c>
|
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_map_ctrl_c_visual()
|
|
|
|
|
" mapping of ctrl-c in Visual mode
|
|
|
|
|
vnoremap <c-c> :<C-u>$put ='vmap works'
|
2022-04-26 00:31:29 -07:00
|
|
|
|
call feedkeys("GV\<*C-C>\<CR>", "xt")
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call assert_equal('vmap works', getline('$'))
|
|
|
|
|
vunmap <c-c>
|
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_map_langmap()
|
2017-03-21 21:24:07 -07:00
|
|
|
|
if !has('langmap')
|
|
|
|
|
return
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
" check langmap applies in normal mode
|
|
|
|
|
set langmap=+- nolangremap
|
|
|
|
|
new
|
|
|
|
|
call setline(1, ['a', 'b', 'c'])
|
|
|
|
|
2
|
|
|
|
|
call assert_equal('b', getline('.'))
|
|
|
|
|
call feedkeys("+", "xt")
|
|
|
|
|
call assert_equal('a', getline('.'))
|
|
|
|
|
|
|
|
|
|
" check no remapping
|
|
|
|
|
map x +
|
|
|
|
|
2
|
|
|
|
|
call feedkeys("x", "xt")
|
|
|
|
|
call assert_equal('c', getline('.'))
|
|
|
|
|
|
|
|
|
|
" check with remapping
|
|
|
|
|
set langremap
|
|
|
|
|
2
|
|
|
|
|
call feedkeys("x", "xt")
|
|
|
|
|
call assert_equal('a', getline('.'))
|
|
|
|
|
|
|
|
|
|
unmap x
|
|
|
|
|
bwipe!
|
|
|
|
|
|
|
|
|
|
" 'langnoremap' follows 'langremap' and vise versa
|
|
|
|
|
set langremap
|
|
|
|
|
set langnoremap
|
|
|
|
|
call assert_equal(0, &langremap)
|
|
|
|
|
set langremap
|
|
|
|
|
call assert_equal(0, &langnoremap)
|
|
|
|
|
set nolangremap
|
|
|
|
|
call assert_equal(1, &langnoremap)
|
|
|
|
|
|
2017-03-21 21:52:15 -07:00
|
|
|
|
" check default values
|
|
|
|
|
set langnoremap&
|
|
|
|
|
call assert_equal(1, &langnoremap)
|
|
|
|
|
call assert_equal(0, &langremap)
|
|
|
|
|
set langremap&
|
|
|
|
|
call assert_equal(1, &langnoremap)
|
|
|
|
|
call assert_equal(0, &langremap)
|
|
|
|
|
|
2017-03-21 21:24:07 -07:00
|
|
|
|
" langmap should not apply in insert mode, 'langremap' doesn't matter
|
|
|
|
|
set langmap=+{ nolangremap
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call feedkeys("Go+\<Esc>", "xt")
|
|
|
|
|
call assert_equal('+', getline('$'))
|
2017-03-21 21:24:07 -07:00
|
|
|
|
set langmap=+{ langremap
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call feedkeys("Go+\<Esc>", "xt")
|
|
|
|
|
call assert_equal('+', getline('$'))
|
|
|
|
|
|
2017-03-21 21:24:07 -07:00
|
|
|
|
" langmap used for register name in insert mode.
|
|
|
|
|
call setreg('a', 'aaaa')
|
|
|
|
|
call setreg('b', 'bbbb')
|
|
|
|
|
call setreg('c', 'cccc')
|
|
|
|
|
set langmap=ab langremap
|
|
|
|
|
call feedkeys("Go\<C-R>a\<Esc>", "xt")
|
|
|
|
|
call assert_equal('bbbb', getline('$'))
|
|
|
|
|
call feedkeys("Go\<C-R>\<C-R>a\<Esc>", "xt")
|
|
|
|
|
call assert_equal('bbbb', getline('$'))
|
|
|
|
|
" mapping does not apply
|
|
|
|
|
imap c a
|
|
|
|
|
call feedkeys("Go\<C-R>c\<Esc>", "xt")
|
|
|
|
|
call assert_equal('cccc', getline('$'))
|
|
|
|
|
imap a c
|
|
|
|
|
call feedkeys("Go\<C-R>a\<Esc>", "xt")
|
|
|
|
|
call assert_equal('bbbb', getline('$'))
|
2018-06-07 17:36:22 -07:00
|
|
|
|
|
2017-03-21 21:24:07 -07:00
|
|
|
|
" langmap should not apply in Command-line mode
|
|
|
|
|
set langmap=+{ nolangremap
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call feedkeys(":call append(line('$'), '+')\<CR>", "xt")
|
|
|
|
|
call assert_equal('+', getline('$'))
|
|
|
|
|
|
2017-11-19 04:15:03 -07:00
|
|
|
|
iunmap a
|
|
|
|
|
iunmap c
|
2017-03-13 05:07:36 -07:00
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_map_feedkeys()
|
|
|
|
|
" issue #212 (feedkeys insert mapping at current position)
|
|
|
|
|
nnoremap . :call feedkeys(".", "in")<cr>
|
|
|
|
|
call setline('$', ['a b c d', 'a b c d'])
|
|
|
|
|
$-1
|
|
|
|
|
call feedkeys("0qqdw.ifoo\<Esc>qj0@q\<Esc>", "xt")
|
|
|
|
|
call assert_equal(['fooc d', 'fooc d'], getline(line('$') - 1, line('$')))
|
2017-11-19 04:15:03 -07:00
|
|
|
|
nunmap .
|
2017-03-13 05:07:36 -07:00
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_map_cursor()
|
|
|
|
|
" <c-g>U<cursor> works only within a single line
|
|
|
|
|
imapclear
|
|
|
|
|
imap ( ()<c-g>U<left>
|
|
|
|
|
call feedkeys("G2o\<Esc>ki\<CR>Test1: text with a (here some more text\<Esc>k.", "xt")
|
|
|
|
|
call assert_equal('Test1: text with a (here some more text)', getline(line('$') - 2))
|
|
|
|
|
call assert_equal('Test1: text with a (here some more text)', getline(line('$') - 1))
|
|
|
|
|
|
|
|
|
|
" test undo
|
|
|
|
|
call feedkeys("G2o\<Esc>ki\<CR>Test2: text wit a (here some more text [und undo]\<C-G>u\<Esc>k.u", "xt")
|
|
|
|
|
call assert_equal('', getline(line('$') - 2))
|
|
|
|
|
call assert_equal('Test2: text wit a (here some more text [und undo])', getline(line('$') - 1))
|
|
|
|
|
set nomodified
|
|
|
|
|
imapclear
|
|
|
|
|
endfunc
|
|
|
|
|
|
2019-06-23 16:37:58 -07:00
|
|
|
|
func Test_map_cursor_ctrl_gU()
|
|
|
|
|
" <c-g>U<cursor> works only within a single line
|
|
|
|
|
nnoremap c<* *Ncgn<C-r>"<C-G>U<S-Left>
|
|
|
|
|
call setline(1, ['foo', 'foobar', '', 'foo'])
|
|
|
|
|
call cursor(1,2)
|
|
|
|
|
call feedkeys("c<*PREFIX\<esc>.", 'xt')
|
|
|
|
|
call assert_equal(['PREFIXfoo', 'foobar', '', 'PREFIXfoo'], getline(1,'$'))
|
|
|
|
|
" break undo manually
|
|
|
|
|
set ul=1000
|
|
|
|
|
exe ":norm! uu"
|
|
|
|
|
call assert_equal(['foo', 'foobar', '', 'foo'], getline(1,'$'))
|
|
|
|
|
|
|
|
|
|
" Test that it does not work if the cursor moves to the previous line
|
|
|
|
|
" 2 times <S-Left> move to the previous line
|
|
|
|
|
nnoremap c<* *Ncgn<C-r>"<C-G>U<S-Left><C-G>U<S-Left>
|
|
|
|
|
call setline(1, ['', ' foo', 'foobar', '', 'foo'])
|
|
|
|
|
call cursor(2,3)
|
|
|
|
|
call feedkeys("c<*PREFIX\<esc>.", 'xt')
|
|
|
|
|
call assert_equal(['PREFIXPREFIX', ' foo', 'foobar', '', 'foo'], getline(1,'$'))
|
|
|
|
|
nmapclear
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
|
2017-03-13 05:07:36 -07:00
|
|
|
|
" This isn't actually testing a mapping, but similar use of CTRL-G U as above.
|
|
|
|
|
func Test_break_undo()
|
2019-06-23 16:37:58 -07:00
|
|
|
|
set whichwrap=<,>,[,]
|
2017-03-13 05:07:36 -07:00
|
|
|
|
call feedkeys("G4o2k", "xt")
|
|
|
|
|
exe ":norm! iTest3: text with a (parenthesis here\<C-G>U\<Right>new line here\<esc>\<up>\<up>."
|
|
|
|
|
call assert_equal('new line here', getline(line('$') - 3))
|
|
|
|
|
call assert_equal('Test3: text with a (parenthesis here', getline(line('$') - 2))
|
|
|
|
|
call assert_equal('new line here', getline(line('$') - 1))
|
|
|
|
|
set nomodified
|
|
|
|
|
endfunc
|
2017-04-15 10:54:40 -07:00
|
|
|
|
|
|
|
|
|
func Test_map_meta_quotes()
|
|
|
|
|
imap <M-"> foo
|
2022-04-26 00:31:29 -07:00
|
|
|
|
call feedkeys("Go-\<*M-\">-\<Esc>", "xt")
|
2017-04-15 10:54:40 -07:00
|
|
|
|
call assert_equal("-foo-", getline('$'))
|
|
|
|
|
set nomodified
|
|
|
|
|
iunmap <M-">
|
|
|
|
|
endfunc
|
2018-06-07 23:07:31 -07:00
|
|
|
|
|
2019-08-16 18:15:33 -07:00
|
|
|
|
func Test_map_meta_multibyte()
|
|
|
|
|
imap <M-á> foo
|
2019-08-16 18:20:45 -07:00
|
|
|
|
call assert_match('i <M-á>\s*foo', execute('imap'))
|
2019-08-16 18:15:33 -07:00
|
|
|
|
iunmap <M-á>
|
|
|
|
|
endfunc
|
|
|
|
|
|
2018-06-07 17:36:22 -07:00
|
|
|
|
func Test_abbr_after_line_join()
|
|
|
|
|
new
|
|
|
|
|
abbr foo bar
|
|
|
|
|
set backspace=indent,eol,start
|
|
|
|
|
exe "normal o\<BS>foo "
|
|
|
|
|
call assert_equal("bar ", getline(1))
|
|
|
|
|
bwipe!
|
|
|
|
|
unabbr foo
|
|
|
|
|
set backspace&
|
|
|
|
|
endfunc
|
|
|
|
|
|
2018-06-07 23:07:31 -07:00
|
|
|
|
func Test_map_timeout()
|
2019-04-25 20:58:44 -07:00
|
|
|
|
if !has('timers')
|
|
|
|
|
return
|
|
|
|
|
endif
|
2018-06-07 23:07:31 -07:00
|
|
|
|
nnoremap aaaa :let got_aaaa = 1<CR>
|
|
|
|
|
nnoremap bb :let got_bb = 1<CR>
|
|
|
|
|
nmap b aaa
|
|
|
|
|
new
|
|
|
|
|
func ExitInsert(timer)
|
|
|
|
|
let g:line = getline(1)
|
|
|
|
|
call feedkeys("\<Esc>", "t")
|
|
|
|
|
endfunc
|
|
|
|
|
set timeout timeoutlen=200
|
2019-04-25 20:58:44 -07:00
|
|
|
|
let timer = timer_start(300, 'ExitInsert')
|
2018-06-07 23:07:31 -07:00
|
|
|
|
" After the 'b' Vim waits for another character to see if it matches 'bb'.
|
|
|
|
|
" When it times out it is expanded to "aaa", but there is no wait for
|
|
|
|
|
" "aaaa". Can't check that reliably though.
|
|
|
|
|
call feedkeys("b", "xt!")
|
|
|
|
|
call assert_equal("aa", g:line)
|
|
|
|
|
call assert_false(exists('got_aaa'))
|
|
|
|
|
call assert_false(exists('got_bb'))
|
|
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
|
nunmap aaaa
|
|
|
|
|
nunmap bb
|
|
|
|
|
nunmap b
|
|
|
|
|
set timeoutlen&
|
|
|
|
|
delfunc ExitInsert
|
2019-04-25 20:58:44 -07:00
|
|
|
|
call timer_stop(timer)
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
func Test_map_timeout_with_timer_interrupt()
|
|
|
|
|
if !has('job') || !has('timers')
|
|
|
|
|
return
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
" Confirm the timer invoked in exit_cb of the job doesn't disturb mapped key
|
|
|
|
|
" sequence.
|
|
|
|
|
new
|
|
|
|
|
let g:val = 0
|
|
|
|
|
nnoremap \12 :let g:val = 1<CR>
|
|
|
|
|
nnoremap \123 :let g:val = 2<CR>
|
2019-08-16 18:22:16 -07:00
|
|
|
|
set timeout timeoutlen=200
|
2019-04-25 20:58:44 -07:00
|
|
|
|
|
|
|
|
|
func ExitCb(job, status)
|
2020-01-03 20:58:09 -07:00
|
|
|
|
let g:timer = timer_start(1, {-> feedkeys("3\<Esc>", 't')})
|
2019-04-25 20:58:44 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
call job_start([&shell, &shellcmdflag, 'echo'], {'exit_cb': 'ExitCb'})
|
|
|
|
|
call feedkeys('\12', 'xt!')
|
|
|
|
|
call assert_equal(2, g:val)
|
|
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
|
nunmap \12
|
|
|
|
|
nunmap \123
|
|
|
|
|
set timeoutlen&
|
|
|
|
|
call WaitFor({-> exists('g:timer')})
|
|
|
|
|
call timer_stop(g:timer)
|
|
|
|
|
unlet g:timer
|
|
|
|
|
unlet g:val
|
|
|
|
|
delfunc ExitCb
|
2018-06-07 23:07:31 -07:00
|
|
|
|
endfunc
|
2018-10-10 20:19:52 -07:00
|
|
|
|
|
|
|
|
|
func Test_cabbr_visual_mode()
|
|
|
|
|
cabbr s su
|
|
|
|
|
call feedkeys(":s \<c-B>\"\<CR>", 'itx')
|
|
|
|
|
call assert_equal('"su ', getreg(':'))
|
|
|
|
|
call feedkeys(":'<,'>s \<c-B>\"\<CR>", 'itx')
|
|
|
|
|
let expected = '"'. "'<,'>su "
|
|
|
|
|
call assert_equal(expected, getreg(':'))
|
|
|
|
|
call feedkeys(": '<,'>s \<c-B>\"\<CR>", 'itx')
|
|
|
|
|
let expected = '" '. "'<,'>su "
|
|
|
|
|
call assert_equal(expected, getreg(':'))
|
|
|
|
|
call feedkeys(":'a,'bs \<c-B>\"\<CR>", 'itx')
|
|
|
|
|
let expected = '"'. "'a,'bsu "
|
|
|
|
|
call assert_equal(expected, getreg(':'))
|
|
|
|
|
cunabbr s
|
|
|
|
|
endfunc
|
2018-11-01 19:51:40 -07:00
|
|
|
|
|
|
|
|
|
func Test_abbreviation_CR()
|
|
|
|
|
new
|
|
|
|
|
func Eatchar(pat)
|
|
|
|
|
let c = nr2char(getchar(0))
|
|
|
|
|
return (c =~ a:pat) ? '' : c
|
|
|
|
|
endfunc
|
|
|
|
|
iabbrev <buffer><silent> ~~7 <c-r>=repeat('~', 7)<CR><c-r>=Eatchar('\s')<cr>
|
|
|
|
|
call feedkeys("GA~~7 \<esc>", 'xt')
|
|
|
|
|
call assert_equal('~~~~~~~', getline('$'))
|
|
|
|
|
%d
|
|
|
|
|
call feedkeys("GA~~7\<cr>\<esc>", 'xt')
|
|
|
|
|
call assert_equal(['~~~~~~~', ''], getline(1,'$'))
|
|
|
|
|
delfunc Eatchar
|
|
|
|
|
bw!
|
|
|
|
|
endfunc
|
2019-01-07 08:48:44 -07:00
|
|
|
|
|
|
|
|
|
func Test_motionforce_omap()
|
|
|
|
|
func GetCommand()
|
|
|
|
|
let g:m=mode(1)
|
|
|
|
|
let [g:lnum1, g:col1] = searchpos('-', 'Wb')
|
|
|
|
|
if g:lnum1 == 0
|
|
|
|
|
return "\<Esc>"
|
|
|
|
|
endif
|
|
|
|
|
let [g:lnum2, g:col2] = searchpos('-', 'W')
|
|
|
|
|
if g:lnum2 == 0
|
|
|
|
|
return "\<Esc>"
|
|
|
|
|
endif
|
|
|
|
|
return ":call Select()\<CR>"
|
|
|
|
|
endfunc
|
|
|
|
|
func Select()
|
|
|
|
|
call cursor([g:lnum1, g:col1])
|
|
|
|
|
exe "normal! 1 ". (strlen(g:m) == 2 ? 'v' : g:m[2])
|
|
|
|
|
call cursor([g:lnum2, g:col2])
|
|
|
|
|
execute "normal! \<BS>"
|
|
|
|
|
endfunc
|
|
|
|
|
new
|
|
|
|
|
onoremap <buffer><expr> i- GetCommand()
|
|
|
|
|
" 1) default omap mapping
|
|
|
|
|
%d_
|
|
|
|
|
call setline(1, ['aaa - bbb', 'x', 'ddd - eee'])
|
|
|
|
|
call cursor(2, 1)
|
|
|
|
|
norm di-
|
|
|
|
|
call assert_equal('no', g:m)
|
|
|
|
|
call assert_equal(['aaa -- eee'], getline(1, '$'))
|
|
|
|
|
" 2) forced characterwise operation
|
|
|
|
|
%d_
|
|
|
|
|
call setline(1, ['aaa - bbb', 'x', 'ddd - eee'])
|
|
|
|
|
call cursor(2, 1)
|
|
|
|
|
norm dvi-
|
|
|
|
|
call assert_equal('nov', g:m)
|
|
|
|
|
call assert_equal(['aaa -- eee'], getline(1, '$'))
|
|
|
|
|
" 3) forced linewise operation
|
|
|
|
|
%d_
|
|
|
|
|
call setline(1, ['aaa - bbb', 'x', 'ddd - eee'])
|
|
|
|
|
call cursor(2, 1)
|
|
|
|
|
norm dVi-
|
|
|
|
|
call assert_equal('noV', g:m)
|
|
|
|
|
call assert_equal([''], getline(1, '$'))
|
|
|
|
|
" 4) forced blockwise operation
|
|
|
|
|
%d_
|
|
|
|
|
call setline(1, ['aaa - bbb', 'x', 'ddd - eee'])
|
|
|
|
|
call cursor(2, 1)
|
|
|
|
|
exe "norm d\<C-V>i-"
|
|
|
|
|
call assert_equal("no\<C-V>", g:m)
|
|
|
|
|
call assert_equal(['aaabbb', 'x', 'dddeee'], getline(1, '$'))
|
|
|
|
|
bwipe!
|
|
|
|
|
delfunc Select
|
|
|
|
|
delfunc GetCommand
|
|
|
|
|
endfunc
|
2020-04-01 15:45:38 -07:00
|
|
|
|
|
2020-09-26 09:03:20 -07:00
|
|
|
|
func Test_error_in_map_expr()
|
2022-10-26 06:53:11 -07:00
|
|
|
|
" Unlike CheckRunVimInTerminal this does work in a win32 console
|
|
|
|
|
CheckFeature terminal
|
|
|
|
|
if has('win32') && has('gui_running')
|
2020-09-26 09:03:20 -07:00
|
|
|
|
throw 'Skipped: cannot run Vim in a terminal window'
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
let lines =<< trim [CODE]
|
|
|
|
|
func Func()
|
|
|
|
|
" fail to create list
|
|
|
|
|
let x = [
|
|
|
|
|
endfunc
|
|
|
|
|
nmap <expr> ! Func()
|
|
|
|
|
set updatetime=50
|
|
|
|
|
[CODE]
|
|
|
|
|
call writefile(lines, 'Xtest.vim')
|
|
|
|
|
|
2020-10-05 21:53:55 -07:00
|
|
|
|
let buf = term_start(GetVimCommandCleanTerm() .. ' -S Xtest.vim', {'term_rows': 8})
|
2020-09-26 09:03:20 -07:00
|
|
|
|
let job = term_getjob(buf)
|
|
|
|
|
call WaitForAssert({-> assert_notequal('', term_getline(buf, 8))})
|
|
|
|
|
|
|
|
|
|
" GC must not run during map-expr processing, which can make Vim crash.
|
|
|
|
|
call term_sendkeys(buf, '!')
|
|
|
|
|
call term_wait(buf, 100)
|
|
|
|
|
call term_sendkeys(buf, "\<CR>")
|
|
|
|
|
call term_wait(buf, 100)
|
|
|
|
|
call assert_equal('run', job_status(job))
|
|
|
|
|
|
|
|
|
|
call term_sendkeys(buf, ":qall!\<CR>")
|
|
|
|
|
call WaitFor({-> job_status(job) ==# 'dead'})
|
|
|
|
|
if has('unix')
|
|
|
|
|
call assert_equal('', job_info(job).termsig)
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
call delete('Xtest.vim')
|
|
|
|
|
exe buf .. 'bwipe!'
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-03-31 06:06:34 -07:00
|
|
|
|
func Test_list_mappings()
|
2022-04-24 23:38:39 -07:00
|
|
|
|
" Remove default mappings
|
|
|
|
|
imapclear
|
2022-04-24 23:38:28 -07:00
|
|
|
|
|
2022-04-26 21:31:24 -07:00
|
|
|
|
" reset 'isident' to check it isn't used
|
|
|
|
|
set isident=
|
|
|
|
|
inoremap <C-m> CtrlM
|
2022-03-31 06:06:34 -07:00
|
|
|
|
inoremap <A-S> AltS
|
|
|
|
|
inoremap <S-/> ShiftSlash
|
2022-04-26 21:31:24 -07:00
|
|
|
|
set isident&
|
2022-03-31 06:06:34 -07:00
|
|
|
|
call assert_equal([
|
|
|
|
|
\ 'i <S-/> * ShiftSlash',
|
|
|
|
|
\ 'i <M-S> * AltS',
|
|
|
|
|
\ 'i <C-M> * CtrlM',
|
|
|
|
|
\], execute('imap')->trim()->split("\n"))
|
|
|
|
|
iunmap <C-M>
|
|
|
|
|
iunmap <A-S>
|
|
|
|
|
call assert_equal(['i <S-/> * ShiftSlash'], execute('imap')->trim()->split("\n"))
|
|
|
|
|
iunmap <S-/>
|
|
|
|
|
call assert_equal(['No mapping found'], execute('imap')->trim()->split("\n"))
|
2022-04-29 23:00:53 -07:00
|
|
|
|
|
|
|
|
|
" List global, buffer local and script local mappings
|
|
|
|
|
nmap ,f /^\k\+ (<CR>
|
|
|
|
|
nmap <buffer> ,f /^\k\+ (<CR>
|
|
|
|
|
nmap <script> ,fs /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(['n ,f @/^\k\+ (<CR>',
|
|
|
|
|
\ 'n ,fs & /^\k\+ (<CR>',
|
|
|
|
|
\ 'n ,f /^\k\+ (<CR>'],
|
|
|
|
|
\ execute('nmap ,f')->trim()->split("\n"))
|
|
|
|
|
|
|
|
|
|
" List <Nop> mapping
|
|
|
|
|
nmap ,n <Nop>
|
|
|
|
|
call assert_equal(['n ,n <Nop>'],
|
|
|
|
|
\ execute('nmap ,n')->trim()->split("\n"))
|
|
|
|
|
|
2022-05-04 16:23:27 -07:00
|
|
|
|
" verbose map
|
|
|
|
|
call assert_match("\tLast set from .*/test_mapping.vim line \\d\\+$",
|
|
|
|
|
\ execute('verbose map ,n')->trim()->split("\n")[1])
|
|
|
|
|
|
|
|
|
|
" character with K_SPECIAL byte in rhs
|
|
|
|
|
nmap foo …
|
|
|
|
|
call assert_equal(['n foo …'],
|
|
|
|
|
\ execute('nmap foo')->trim()->split("\n"))
|
|
|
|
|
|
|
|
|
|
" modified character with K_SPECIAL byte in rhs
|
|
|
|
|
nmap foo <M-…>
|
|
|
|
|
call assert_equal(['n foo <M-…>'],
|
|
|
|
|
\ execute('nmap foo')->trim()->split("\n"))
|
|
|
|
|
|
|
|
|
|
" character with K_SPECIAL byte in lhs
|
|
|
|
|
nmap … foo
|
|
|
|
|
call assert_equal(['n … foo'],
|
|
|
|
|
\ execute('nmap …')->trim()->split("\n"))
|
|
|
|
|
|
|
|
|
|
" modified character with K_SPECIAL byte in lhs
|
|
|
|
|
nmap <M-…> foo
|
|
|
|
|
call assert_equal(['n <M-…> foo'],
|
|
|
|
|
\ execute('nmap <M-…>')->trim()->split("\n"))
|
|
|
|
|
|
2022-05-09 04:19:07 -07:00
|
|
|
|
" illegal bytes
|
|
|
|
|
let str = ":\x7f:\x80:\x90:\xd0:"
|
|
|
|
|
exe 'nmap foo ' .. str
|
|
|
|
|
call assert_equal(['n foo ' .. strtrans(str)],
|
|
|
|
|
\ execute('nmap foo')->trim()->split("\n"))
|
|
|
|
|
unlet str
|
|
|
|
|
|
2022-05-04 16:23:27 -07:00
|
|
|
|
" map to CTRL-V
|
|
|
|
|
exe "nmap ,k \<C-V>"
|
|
|
|
|
call assert_equal(['n ,k <Nop>'],
|
|
|
|
|
\ execute('nmap ,k')->trim()->split("\n"))
|
|
|
|
|
|
|
|
|
|
" map with space at the beginning
|
|
|
|
|
exe "nmap \<C-V> w <Nop>"
|
|
|
|
|
call assert_equal(['n <Space>w <Nop>'],
|
|
|
|
|
\ execute("nmap \<C-V> w")->trim()->split("\n"))
|
|
|
|
|
|
2022-04-29 23:00:53 -07:00
|
|
|
|
nmapclear
|
2022-03-31 06:06:34 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
2021-03-29 16:39:28 -07:00
|
|
|
|
func Test_expr_map_gets_cursor()
|
|
|
|
|
new
|
|
|
|
|
call setline(1, ['one', 'some w!rd'])
|
|
|
|
|
func StoreColumn()
|
|
|
|
|
let g:exprLine = line('.')
|
|
|
|
|
let g:exprCol = col('.')
|
|
|
|
|
return 'x'
|
|
|
|
|
endfunc
|
|
|
|
|
nnoremap <expr> x StoreColumn()
|
|
|
|
|
2
|
|
|
|
|
nmap ! f!<Ignore>x
|
|
|
|
|
call feedkeys("!", 'xt')
|
|
|
|
|
call assert_equal('some wrd', getline(2))
|
|
|
|
|
call assert_equal(2, g:exprLine)
|
|
|
|
|
call assert_equal(7, g:exprCol)
|
|
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
|
unlet g:exprLine
|
|
|
|
|
unlet g:exprCol
|
2021-03-29 16:46:21 -07:00
|
|
|
|
delfunc StoreColumn
|
2021-03-29 16:39:28 -07:00
|
|
|
|
nunmap x
|
|
|
|
|
nunmap !
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-02-16 16:18:10 -07:00
|
|
|
|
func Test_expr_map_restore_cursor()
|
|
|
|
|
CheckScreendump
|
|
|
|
|
|
|
|
|
|
let lines =<< trim END
|
|
|
|
|
call setline(1, ['one', 'two', 'three'])
|
|
|
|
|
2
|
|
|
|
|
set ls=2
|
|
|
|
|
hi! link StatusLine ErrorMsg
|
|
|
|
|
noremap <expr> <C-B> Func()
|
|
|
|
|
func Func()
|
|
|
|
|
let g:on = !get(g:, 'on', 0)
|
|
|
|
|
redraws
|
|
|
|
|
return ''
|
|
|
|
|
endfunc
|
|
|
|
|
func Status()
|
|
|
|
|
return get(g:, 'on', 0) ? '[on]' : ''
|
|
|
|
|
endfunc
|
|
|
|
|
set stl=%{Status()}
|
|
|
|
|
END
|
|
|
|
|
call writefile(lines, 'XtestExprMap')
|
|
|
|
|
let buf = RunVimInTerminal('-S XtestExprMap', #{rows: 10})
|
|
|
|
|
call term_sendkeys(buf, "\<C-B>")
|
|
|
|
|
call VerifyScreenDump(buf, 'Test_map_expr_1', {})
|
|
|
|
|
|
|
|
|
|
" clean up
|
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
|
call delete('XtestExprMap')
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-02-16 16:18:10 -07:00
|
|
|
|
func Test_map_listing()
|
|
|
|
|
CheckScreendump
|
|
|
|
|
|
|
|
|
|
let lines =<< trim END
|
|
|
|
|
nmap a b
|
|
|
|
|
END
|
|
|
|
|
call writefile(lines, 'XtestMapList')
|
|
|
|
|
let buf = RunVimInTerminal('-S XtestMapList', #{rows: 6})
|
|
|
|
|
call term_sendkeys(buf, ": nmap a\<CR>")
|
|
|
|
|
call VerifyScreenDump(buf, 'Test_map_list_1', {})
|
|
|
|
|
|
|
|
|
|
" clean up
|
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
|
call delete('XtestMapList')
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-02-16 16:18:10 -07:00
|
|
|
|
func Test_expr_map_error()
|
|
|
|
|
CheckScreendump
|
|
|
|
|
|
|
|
|
|
let lines =<< trim END
|
|
|
|
|
func Func()
|
|
|
|
|
throw 'test'
|
|
|
|
|
return ''
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
nnoremap <expr> <F2> Func()
|
|
|
|
|
cnoremap <expr> <F2> Func()
|
|
|
|
|
|
|
|
|
|
call test_override('ui_delay', 10)
|
|
|
|
|
END
|
|
|
|
|
call writefile(lines, 'XtestExprMap')
|
|
|
|
|
let buf = RunVimInTerminal('-S XtestExprMap', #{rows: 10})
|
|
|
|
|
call term_sendkeys(buf, "\<F2>")
|
|
|
|
|
call TermWait(buf)
|
|
|
|
|
call term_sendkeys(buf, "\<CR>")
|
|
|
|
|
call VerifyScreenDump(buf, 'Test_map_expr_2', {})
|
|
|
|
|
|
|
|
|
|
call term_sendkeys(buf, ":abc\<F2>")
|
|
|
|
|
call VerifyScreenDump(buf, 'Test_map_expr_3', {})
|
|
|
|
|
call term_sendkeys(buf, "\<Esc>0")
|
|
|
|
|
call VerifyScreenDump(buf, 'Test_map_expr_4', {})
|
|
|
|
|
|
|
|
|
|
" clean up
|
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
|
call delete('XtestExprMap')
|
|
|
|
|
endfunc
|
|
|
|
|
|
2020-04-01 15:45:38 -07:00
|
|
|
|
" Test for mapping errors
|
|
|
|
|
func Test_map_error()
|
|
|
|
|
call assert_fails('unmap', 'E474:')
|
|
|
|
|
call assert_fails("exe 'map ' .. repeat('a', 51) .. ' :ls'", 'E474:')
|
|
|
|
|
call assert_fails('unmap abc', 'E31:')
|
|
|
|
|
call assert_fails('unabbr abc', 'E24:')
|
|
|
|
|
call assert_equal('', maparg(''))
|
|
|
|
|
call assert_fails('echo maparg("abc", [])', 'E730:')
|
|
|
|
|
|
|
|
|
|
" unique map
|
|
|
|
|
map ,w /[#&!]<CR>
|
|
|
|
|
call assert_fails("map <unique> ,w /[#&!]<CR>", 'E227:')
|
|
|
|
|
" unique buffer-local map
|
|
|
|
|
call assert_fails("map <buffer> <unique> ,w /[.,;]<CR>", 'E225:')
|
|
|
|
|
unmap ,w
|
|
|
|
|
|
|
|
|
|
" unique abbreviation
|
|
|
|
|
abbr SP special
|
|
|
|
|
call assert_fails("abbr <unique> SP special", 'E226:')
|
|
|
|
|
" unique buffer-local map
|
|
|
|
|
call assert_fails("abbr <buffer> <unique> SP special", 'E224:')
|
|
|
|
|
unabbr SP
|
|
|
|
|
|
|
|
|
|
call assert_fails('mapclear abc', 'E474:')
|
|
|
|
|
call assert_fails('abclear abc', 'E474:')
|
2022-04-29 23:00:53 -07:00
|
|
|
|
call assert_fails('abbr $xyz abc', 'E474:')
|
|
|
|
|
|
|
|
|
|
" space character in an abbreviation
|
|
|
|
|
call assert_fails('abbr ab<space> ABC', 'E474:')
|
|
|
|
|
|
|
|
|
|
" invalid <expr> map
|
|
|
|
|
map <expr> ,f abc
|
|
|
|
|
call assert_fails('normal ,f', 'E121:')
|
|
|
|
|
unmap <expr> ,f
|
2022-07-08 02:43:05 -07:00
|
|
|
|
|
|
|
|
|
" Recursive use of :normal in a map
|
|
|
|
|
set maxmapdepth=100
|
|
|
|
|
map gq :normal gq<CR>
|
|
|
|
|
call assert_fails('normal gq', 'E192:')
|
|
|
|
|
unmap gq
|
|
|
|
|
set maxmapdepth&
|
2020-04-01 15:45:38 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for <special> key mapping
|
|
|
|
|
func Test_map_special()
|
|
|
|
|
throw 'skipped: Nvim does not support cpoptions flag "<"'
|
|
|
|
|
new
|
|
|
|
|
let old_cpo = &cpo
|
|
|
|
|
set cpo+=<
|
|
|
|
|
imap <F12> Blue
|
|
|
|
|
call feedkeys("i\<F12>", "x")
|
|
|
|
|
call assert_equal("<F12>", getline(1))
|
|
|
|
|
call feedkeys("ddi<F12>", "x")
|
|
|
|
|
call assert_equal("Blue", getline(1))
|
|
|
|
|
iunmap <F12>
|
|
|
|
|
imap <special> <F12> Green
|
|
|
|
|
call feedkeys("ddi\<F12>", "x")
|
|
|
|
|
call assert_equal("Green", getline(1))
|
|
|
|
|
call feedkeys("ddi<F12>", "x")
|
|
|
|
|
call assert_equal("<F12>", getline(1))
|
|
|
|
|
iunmap <special> <F12>
|
|
|
|
|
let &cpo = old_cpo
|
|
|
|
|
%bwipe!
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for hasmapto()
|
|
|
|
|
func Test_hasmapto()
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ ('))
|
2022-04-29 23:00:53 -07:00
|
|
|
|
map ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ ('))
|
|
|
|
|
unmap ,f
|
|
|
|
|
|
|
|
|
|
" Insert mode mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'i'))
|
|
|
|
|
imap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'i'))
|
|
|
|
|
iunmap ,f
|
|
|
|
|
|
|
|
|
|
" Normal mode mapping
|
2020-04-01 15:45:38 -07:00
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'n'))
|
|
|
|
|
nmap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ ('))
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'n'))
|
2022-04-29 23:00:53 -07:00
|
|
|
|
nunmap ,f
|
|
|
|
|
|
|
|
|
|
" Visual and Select mode mapping
|
2020-04-01 15:45:38 -07:00
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'v'))
|
2022-04-29 23:00:53 -07:00
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'x'))
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 's'))
|
|
|
|
|
vmap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'v'))
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'x'))
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 's'))
|
|
|
|
|
vunmap ,f
|
|
|
|
|
|
|
|
|
|
" Visual mode mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'x'))
|
|
|
|
|
xmap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'v'))
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'x'))
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 's'))
|
|
|
|
|
xunmap ,f
|
|
|
|
|
|
|
|
|
|
" Select mode mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 's'))
|
|
|
|
|
smap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'v'))
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'x'))
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 's'))
|
|
|
|
|
sunmap ,f
|
|
|
|
|
|
|
|
|
|
" Operator-pending mode mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'o'))
|
|
|
|
|
omap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'o'))
|
|
|
|
|
ounmap ,f
|
|
|
|
|
|
|
|
|
|
" Language mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'l'))
|
|
|
|
|
lmap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'l'))
|
|
|
|
|
lunmap ,f
|
|
|
|
|
|
|
|
|
|
" Cmdline mode mapping
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'c'))
|
|
|
|
|
cmap ,f /^\k\+ (<CR>
|
|
|
|
|
call assert_equal(1, hasmapto('/^\k\+ (', 'c'))
|
|
|
|
|
cunmap ,f
|
2020-04-01 15:45:38 -07:00
|
|
|
|
|
|
|
|
|
call assert_equal(0, hasmapto('/^\k\+ (', 'n', 1))
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for command-line completion of maps
|
|
|
|
|
func Test_mapcomplete()
|
|
|
|
|
call assert_equal(['<buffer>', '<expr>', '<nowait>', '<script>',
|
|
|
|
|
\ '<silent>', '<special>', '<unique>'],
|
|
|
|
|
\ getcompletion('', 'mapping'))
|
|
|
|
|
call assert_equal([], getcompletion(',d', 'mapping'))
|
|
|
|
|
|
2022-04-29 23:00:53 -07:00
|
|
|
|
call feedkeys(":unmap <buf\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
|
call assert_equal('"unmap <buffer>', @:)
|
|
|
|
|
|
|
|
|
|
call feedkeys(":unabbr <buf\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
|
call assert_equal('"unabbr <buffer>', @:)
|
|
|
|
|
|
2020-04-01 15:45:38 -07:00
|
|
|
|
call feedkeys(":abbr! \<C-A>\<C-B>\"\<CR>", 'tx')
|
2022-04-29 23:00:53 -07:00
|
|
|
|
call assert_equal("\"abbr! \x01", @:)
|
|
|
|
|
|
|
|
|
|
" Multiple matches for a map
|
|
|
|
|
nmap ,f /H<CR>
|
|
|
|
|
omap ,f /H<CR>
|
|
|
|
|
call feedkeys(":map ,\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
|
call assert_equal('"map ,f', @:)
|
|
|
|
|
mapclear
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-12-24 01:32:50 -07:00
|
|
|
|
func GetAbbrText()
|
|
|
|
|
unabbr hola
|
|
|
|
|
return 'hello'
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-04-29 23:00:53 -07:00
|
|
|
|
" Test for <expr> in abbreviation
|
|
|
|
|
func Test_expr_abbr()
|
|
|
|
|
new
|
|
|
|
|
iabbr <expr> teh "the"
|
|
|
|
|
call feedkeys("iteh ", "tx")
|
|
|
|
|
call assert_equal('the ', getline(1))
|
|
|
|
|
iabclear
|
|
|
|
|
call setline(1, '')
|
|
|
|
|
|
|
|
|
|
" invalid <expr> abbreviation
|
|
|
|
|
abbr <expr> hte GetAbbr()
|
|
|
|
|
call assert_fails('normal ihte ', 'E117:')
|
2022-11-11 02:50:52 -07:00
|
|
|
|
call assert_equal('', getline(1))
|
2022-04-29 23:00:53 -07:00
|
|
|
|
unabbr <expr> hte
|
|
|
|
|
|
2022-12-24 01:32:50 -07:00
|
|
|
|
" evaluating the expression deletes the abbreviation
|
|
|
|
|
abbr <expr> hola GetAbbrText()
|
|
|
|
|
call assert_equal('GetAbbrText()', maparg('hola', 'i', '1'))
|
|
|
|
|
call feedkeys("ahola \<Esc>", 'xt')
|
|
|
|
|
call assert_equal('hello ', getline('.'))
|
|
|
|
|
call assert_equal('', maparg('hola', 'i', '1'))
|
|
|
|
|
|
|
|
|
|
bwipe!
|
2022-04-29 23:00:53 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for storing mappings in different modes in a vimrc file
|
|
|
|
|
func Test_mkvimrc_mapmodes()
|
|
|
|
|
map a1 /a1
|
|
|
|
|
nmap a2 /a2
|
|
|
|
|
vmap a3 /a3
|
|
|
|
|
smap a4 /a4
|
|
|
|
|
xmap a5 /a5
|
|
|
|
|
omap a6 /a6
|
|
|
|
|
map! a7 /a7
|
|
|
|
|
imap a8 /a8
|
|
|
|
|
lmap a9 /a9
|
|
|
|
|
cmap a10 /a10
|
|
|
|
|
tmap a11 /a11
|
|
|
|
|
" Normal + Visual map
|
|
|
|
|
map a12 /a12
|
|
|
|
|
sunmap a12
|
|
|
|
|
ounmap a12
|
|
|
|
|
" Normal + Selectmode map
|
|
|
|
|
map a13 /a13
|
|
|
|
|
xunmap a13
|
|
|
|
|
ounmap a13
|
|
|
|
|
" Normal + OpPending map
|
|
|
|
|
map a14 /a14
|
|
|
|
|
vunmap a14
|
|
|
|
|
" Visual + Selectmode map
|
|
|
|
|
map a15 /a15
|
|
|
|
|
nunmap a15
|
|
|
|
|
ounmap a15
|
|
|
|
|
" Visual + OpPending map
|
|
|
|
|
map a16 /a16
|
|
|
|
|
nunmap a16
|
|
|
|
|
sunmap a16
|
|
|
|
|
" Selectmode + OpPending map
|
|
|
|
|
map a17 /a17
|
|
|
|
|
nunmap a17
|
|
|
|
|
xunmap a17
|
|
|
|
|
" Normal + Visual + Selectmode map
|
|
|
|
|
map a18 /a18
|
|
|
|
|
ounmap a18
|
|
|
|
|
" Normal + Visual + OpPending map
|
|
|
|
|
map a19 /a19
|
|
|
|
|
sunmap a19
|
|
|
|
|
" Normal + Selectmode + OpPending map
|
|
|
|
|
map a20 /a20
|
|
|
|
|
xunmap a20
|
|
|
|
|
" Visual + Selectmode + OpPending map
|
|
|
|
|
map a21 /a21
|
|
|
|
|
nunmap a21
|
|
|
|
|
" Mapping to Nop
|
|
|
|
|
map a22 <Nop>
|
|
|
|
|
" Script local mapping
|
|
|
|
|
map <script> a23 /a23
|
|
|
|
|
|
|
|
|
|
" Newline in {lhs} and {rhs} of a map
|
|
|
|
|
exe "map a24\<C-V>\<C-J> ia24\<C-V>\<C-J><Esc>"
|
|
|
|
|
|
|
|
|
|
" Abbreviation
|
|
|
|
|
abbr a25 A25
|
|
|
|
|
cabbr a26 A26
|
|
|
|
|
iabbr a27 A27
|
|
|
|
|
|
|
|
|
|
mkvimrc! Xvimrc
|
|
|
|
|
let l = readfile('Xvimrc')
|
|
|
|
|
call assert_equal(['map a1 /a1'], filter(copy(l), 'v:val =~ " a1 "'))
|
|
|
|
|
call assert_equal(['nmap a2 /a2'], filter(copy(l), 'v:val =~ " a2 "'))
|
|
|
|
|
call assert_equal(['vmap a3 /a3'], filter(copy(l), 'v:val =~ " a3 "'))
|
|
|
|
|
call assert_equal(['smap a4 /a4'], filter(copy(l), 'v:val =~ " a4 "'))
|
|
|
|
|
call assert_equal(['xmap a5 /a5'], filter(copy(l), 'v:val =~ " a5 "'))
|
|
|
|
|
call assert_equal(['omap a6 /a6'], filter(copy(l), 'v:val =~ " a6 "'))
|
|
|
|
|
call assert_equal(['map! a7 /a7'], filter(copy(l), 'v:val =~ " a7 "'))
|
|
|
|
|
call assert_equal(['imap a8 /a8'], filter(copy(l), 'v:val =~ " a8 "'))
|
|
|
|
|
call assert_equal(['lmap a9 /a9'], filter(copy(l), 'v:val =~ " a9 "'))
|
|
|
|
|
call assert_equal(['cmap a10 /a10'], filter(copy(l), 'v:val =~ " a10 "'))
|
|
|
|
|
call assert_equal(['tmap a11 /a11'], filter(copy(l), 'v:val =~ " a11 "'))
|
|
|
|
|
call assert_equal(['nmap a12 /a12', 'xmap a12 /a12'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a12 "'))
|
|
|
|
|
call assert_equal(['nmap a13 /a13', 'smap a13 /a13'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a13 "'))
|
|
|
|
|
call assert_equal(['nmap a14 /a14', 'omap a14 /a14'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a14 "'))
|
|
|
|
|
call assert_equal(['vmap a15 /a15'], filter(copy(l), 'v:val =~ " a15 "'))
|
|
|
|
|
call assert_equal(['xmap a16 /a16', 'omap a16 /a16'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a16 "'))
|
|
|
|
|
call assert_equal(['smap a17 /a17', 'omap a17 /a17'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a17 "'))
|
|
|
|
|
call assert_equal(['nmap a18 /a18', 'vmap a18 /a18'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a18 "'))
|
|
|
|
|
call assert_equal(['nmap a19 /a19', 'xmap a19 /a19', 'omap a19 /a19'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a19 "'))
|
|
|
|
|
call assert_equal(['nmap a20 /a20', 'smap a20 /a20', 'omap a20 /a20'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a20 "'))
|
|
|
|
|
call assert_equal(['vmap a21 /a21', 'omap a21 /a21'],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a21 "'))
|
|
|
|
|
call assert_equal(['map a22 <Nop>'], filter(copy(l), 'v:val =~ " a22 "'))
|
|
|
|
|
call assert_equal([], filter(copy(l), 'v:val =~ " a23 "'))
|
|
|
|
|
call assert_equal(["map a24<NL> ia24<NL>\x16\e"],
|
|
|
|
|
\ filter(copy(l), 'v:val =~ " a24"'))
|
|
|
|
|
|
|
|
|
|
call assert_equal(['abbr a25 A25'], filter(copy(l), 'v:val =~ " a25 "'))
|
|
|
|
|
call assert_equal(['cabbr a26 A26'], filter(copy(l), 'v:val =~ " a26 "'))
|
|
|
|
|
call assert_equal(['iabbr a27 A27'], filter(copy(l), 'v:val =~ " a27 "'))
|
|
|
|
|
call delete('Xvimrc')
|
|
|
|
|
|
|
|
|
|
mapclear
|
|
|
|
|
nmapclear
|
|
|
|
|
vmapclear
|
|
|
|
|
xmapclear
|
|
|
|
|
smapclear
|
|
|
|
|
omapclear
|
|
|
|
|
imapclear
|
|
|
|
|
lmapclear
|
|
|
|
|
cmapclear
|
|
|
|
|
tmapclear
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for recursive mapping ('maxmapdepth')
|
|
|
|
|
func Test_map_recursive()
|
|
|
|
|
map x y
|
|
|
|
|
map y x
|
|
|
|
|
call assert_fails('normal x', 'E223:')
|
|
|
|
|
unmap x
|
|
|
|
|
unmap y
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for removing an abbreviation using {rhs} and with space after {lhs}
|
|
|
|
|
func Test_abbr_remove()
|
|
|
|
|
abbr foo bar
|
|
|
|
|
let d = maparg('foo', 'i', 1, 1)
|
|
|
|
|
call assert_equal(['foo', 'bar', '!'], [d.lhs, d.rhs, d.mode])
|
|
|
|
|
unabbr bar
|
|
|
|
|
call assert_equal({}, maparg('foo', 'i', 1, 1))
|
|
|
|
|
|
|
|
|
|
abbr foo bar
|
|
|
|
|
unabbr foo<space><tab>
|
|
|
|
|
call assert_equal({}, maparg('foo', 'i', 1, 1))
|
2020-04-01 15:45:38 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
2023-02-16 16:59:22 -07:00
|
|
|
|
" Trigger an abbreviation using a special key
|
|
|
|
|
func Test_abbr_trigger_special()
|
|
|
|
|
new
|
|
|
|
|
iabbr teh the
|
|
|
|
|
call feedkeys("iteh\<F2>\<Esc>", 'xt')
|
|
|
|
|
call assert_equal('the<F2>', getline(1))
|
|
|
|
|
iunab teh
|
|
|
|
|
close!
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
" Test for '<' in 'cpoptions'
|
|
|
|
|
func Test_map_cpo_special_keycode()
|
|
|
|
|
set cpo-=<
|
|
|
|
|
imap x<Bslash>k Test
|
|
|
|
|
let d = maparg('x<Bslash>k', 'i', 0, 1)
|
|
|
|
|
call assert_equal(['x\k', 'Test', 'i'], [d.lhs, d.rhs, d.mode])
|
|
|
|
|
call feedkeys(":imap x\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
|
call assert_equal('"imap x\k', @:)
|
|
|
|
|
iunmap x<Bslash>k
|
|
|
|
|
" Nvim: no "<" flag in 'cpoptions'.
|
|
|
|
|
" set cpo+=<
|
|
|
|
|
" imap x<Bslash>k Test
|
|
|
|
|
" let d = maparg('x<Bslash>k', 'i', 0, 1)
|
|
|
|
|
" call assert_equal(['x<Bslash>k', 'Test', 'i'], [d.lhs, d.rhs, d.mode])
|
|
|
|
|
" call feedkeys(":imap x\<C-A>\<C-B>\"\<CR>", 'tx')
|
|
|
|
|
" call assert_equal('"imap x<Bslash>k', @:)
|
|
|
|
|
" iunmap x<Bslash>k
|
|
|
|
|
set cpo-=<
|
|
|
|
|
" Modifying 'cpo' above adds some default mappings, remove them
|
|
|
|
|
mapclear
|
|
|
|
|
mapclear!
|
|
|
|
|
endfunc
|
|
|
|
|
|
2020-11-18 06:49:25 -07:00
|
|
|
|
func Test_map_cmdkey_redo()
|
|
|
|
|
func SelectDash()
|
|
|
|
|
call search('^---\n\zs', 'bcW')
|
|
|
|
|
norm! V
|
|
|
|
|
call search('\n\ze---$', 'W')
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
let text =<< trim END
|
|
|
|
|
---
|
|
|
|
|
aaa
|
|
|
|
|
---
|
|
|
|
|
bbb
|
|
|
|
|
bbb
|
|
|
|
|
---
|
|
|
|
|
ccc
|
|
|
|
|
ccc
|
|
|
|
|
ccc
|
|
|
|
|
---
|
|
|
|
|
END
|
|
|
|
|
new Xcmdtext
|
|
|
|
|
call setline(1, text)
|
|
|
|
|
|
|
|
|
|
onoremap <silent> i- <Cmd>call SelectDash()<CR>
|
|
|
|
|
call feedkeys('2Gdi-', 'xt')
|
|
|
|
|
call assert_equal(['---', '---'], getline(1, 2))
|
|
|
|
|
call feedkeys('j.', 'xt')
|
|
|
|
|
call assert_equal(['---', '---', '---'], getline(1, 3))
|
|
|
|
|
call feedkeys('j.', 'xt')
|
|
|
|
|
call assert_equal(['---', '---', '---', '---'], getline(1, 4))
|
|
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
|
call delete('Xcmdtext')
|
|
|
|
|
delfunc SelectDash
|
|
|
|
|
ounmap i-
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-07-16 06:56:47 -07:00
|
|
|
|
" Test for using <script> with a map to remap characters in rhs
|
|
|
|
|
func Test_script_local_remap()
|
|
|
|
|
new
|
|
|
|
|
inoremap <buffer> <SID>xyz mno
|
|
|
|
|
inoremap <buffer> <script> abc st<SID>xyzre
|
|
|
|
|
normal iabc
|
|
|
|
|
call assert_equal('stmnore', getline(1))
|
|
|
|
|
bwipe!
|
|
|
|
|
endfunc
|
|
|
|
|
|
2021-05-05 18:53:10 -07:00
|
|
|
|
func Test_abbreviate_multi_byte()
|
|
|
|
|
new
|
|
|
|
|
iabbrev foo bar
|
|
|
|
|
call feedkeys("ifoo…\<Esc>", 'xt')
|
|
|
|
|
call assert_equal("bar…", getline(1))
|
|
|
|
|
iunabbrev foo
|
|
|
|
|
bwipe!
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-09-21 20:17:41 -07:00
|
|
|
|
" Test for abbreviations with 'latin1' encoding
|
|
|
|
|
func Test_abbreviate_latin1_encoding()
|
|
|
|
|
" set encoding=latin1
|
|
|
|
|
call assert_fails('abbr ab#$c ABC', 'E474:')
|
|
|
|
|
new
|
|
|
|
|
iabbr <buffer> #i #include
|
|
|
|
|
iabbr <buffer> ## #enddef
|
|
|
|
|
exe "normal i#i\<C-]>"
|
|
|
|
|
call assert_equal('#include', getline(1))
|
|
|
|
|
exe "normal 0Di##\<C-]>"
|
|
|
|
|
call assert_equal('#enddef', getline(1))
|
|
|
|
|
%bw!
|
|
|
|
|
set encoding=utf-8
|
|
|
|
|
endfunc
|
|
|
|
|
+
|
2022-03-03 06:59:28 -07:00
|
|
|
|
" Test for <Plug> always being mapped, even when used with "noremap".
|
|
|
|
|
func Test_plug_remap()
|
|
|
|
|
let g:foo = 0
|
|
|
|
|
nnoremap <Plug>(Increase_x) <Cmd>let g:foo += 1<CR>
|
|
|
|
|
nmap <F2> <Plug>(Increase_x)
|
|
|
|
|
nnoremap <F3> <Plug>(Increase_x)
|
|
|
|
|
call feedkeys("\<F2>", 'xt')
|
|
|
|
|
call assert_equal(1, g:foo)
|
|
|
|
|
call feedkeys("\<F3>", 'xt')
|
|
|
|
|
call assert_equal(2, g:foo)
|
|
|
|
|
nnoremap x <Nop>
|
|
|
|
|
nmap <F4> x<Plug>(Increase_x)x
|
|
|
|
|
nnoremap <F5> x<Plug>(Increase_x)x
|
|
|
|
|
call setline(1, 'Some text')
|
|
|
|
|
normal! gg$
|
|
|
|
|
call feedkeys("\<F4>", 'xt')
|
|
|
|
|
call assert_equal(3, g:foo)
|
|
|
|
|
call assert_equal('Some text', getline(1))
|
|
|
|
|
call feedkeys("\<F5>", 'xt')
|
|
|
|
|
call assert_equal(4, g:foo)
|
|
|
|
|
call assert_equal('Some te', getline(1))
|
|
|
|
|
nunmap <Plug>(Increase_x)
|
|
|
|
|
nunmap <F2>
|
|
|
|
|
nunmap <F3>
|
|
|
|
|
nunmap <F4>
|
|
|
|
|
nunmap <F5>
|
|
|
|
|
unlet g:foo
|
|
|
|
|
%bw!
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-04-24 15:41:01 -07:00
|
|
|
|
func Test_mouse_drag_mapped_start_select()
|
|
|
|
|
set mouse=a
|
|
|
|
|
set selectmode=key,mouse
|
|
|
|
|
func ClickExpr()
|
2022-09-16 18:40:19 -07:00
|
|
|
|
call Ntest_setmouse(1, 1)
|
2022-04-24 15:41:01 -07:00
|
|
|
|
return "\<LeftMouse>"
|
|
|
|
|
endfunc
|
|
|
|
|
func DragExpr()
|
2022-09-16 18:40:19 -07:00
|
|
|
|
call Ntest_setmouse(1, 2)
|
2022-04-24 15:41:01 -07:00
|
|
|
|
return "\<LeftDrag>"
|
|
|
|
|
endfunc
|
|
|
|
|
nnoremap <expr> <F2> ClickExpr()
|
|
|
|
|
nmap <expr> <F3> DragExpr()
|
|
|
|
|
|
|
|
|
|
nnoremap <LeftDrag> <LeftDrag><Cmd><CR>
|
|
|
|
|
exe "normal \<F2>\<F3>"
|
|
|
|
|
call assert_equal('s', mode())
|
|
|
|
|
exe "normal! \<C-\>\<C-N>"
|
|
|
|
|
|
|
|
|
|
nunmap <LeftDrag>
|
|
|
|
|
nunmap <F2>
|
|
|
|
|
nunmap <F3>
|
|
|
|
|
delfunc ClickExpr
|
|
|
|
|
delfunc DragExpr
|
|
|
|
|
set selectmode&
|
|
|
|
|
set mouse&
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-10-31 16:13:02 -07:00
|
|
|
|
func Test_mouse_drag_statusline()
|
|
|
|
|
set laststatus=2
|
|
|
|
|
set mouse=a
|
|
|
|
|
func ClickExpr()
|
2022-11-01 05:22:48 -07:00
|
|
|
|
call Ntest_setmouse(&lines - 1, 1)
|
|
|
|
|
return "\<LeftMouse>"
|
2022-10-31 16:13:02 -07:00
|
|
|
|
endfunc
|
|
|
|
|
func DragExpr()
|
2022-11-01 05:22:48 -07:00
|
|
|
|
call Ntest_setmouse(&lines - 2, 1)
|
|
|
|
|
return "\<LeftDrag>"
|
2022-10-31 16:13:02 -07:00
|
|
|
|
endfunc
|
|
|
|
|
nnoremap <expr> <F2> ClickExpr()
|
|
|
|
|
nnoremap <expr> <F3> DragExpr()
|
|
|
|
|
|
|
|
|
|
" this was causing a crash in win_drag_status_line()
|
|
|
|
|
call feedkeys("\<F2>:tabnew\<CR>\<F3>", 'tx')
|
2022-11-01 05:22:48 -07:00
|
|
|
|
|
|
|
|
|
nunmap <F2>
|
|
|
|
|
nunmap <F3>
|
|
|
|
|
delfunc ClickExpr
|
|
|
|
|
delfunc DragExpr
|
|
|
|
|
set laststatus& mouse&
|
2022-10-31 16:13:02 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
2022-04-05 06:38:53 -07:00
|
|
|
|
" Test for mapping <LeftDrag> in Insert mode
|
|
|
|
|
func Test_mouse_drag_insert_map()
|
|
|
|
|
set mouse=a
|
|
|
|
|
func ClickExpr()
|
2022-09-16 18:40:19 -07:00
|
|
|
|
call Ntest_setmouse(1, 1)
|
2022-04-05 06:38:53 -07:00
|
|
|
|
return "\<LeftMouse>"
|
|
|
|
|
endfunc
|
|
|
|
|
func DragExpr()
|
2022-09-16 18:40:19 -07:00
|
|
|
|
call Ntest_setmouse(1, 2)
|
2022-04-05 06:38:53 -07:00
|
|
|
|
return "\<LeftDrag>"
|
|
|
|
|
endfunc
|
|
|
|
|
inoremap <expr> <F2> ClickExpr()
|
|
|
|
|
imap <expr> <F3> DragExpr()
|
|
|
|
|
|
|
|
|
|
inoremap <LeftDrag> <LeftDrag><Cmd>let g:dragged = 1<CR>
|
|
|
|
|
exe "normal i\<F2>\<F3>"
|
|
|
|
|
call assert_equal(1, g:dragged)
|
|
|
|
|
call assert_equal('v', mode())
|
|
|
|
|
exe "normal! \<C-\>\<C-N>"
|
|
|
|
|
unlet g:dragged
|
|
|
|
|
|
|
|
|
|
inoremap <LeftDrag> <LeftDrag><C-\><C-N>
|
|
|
|
|
exe "normal i\<F2>\<F3>"
|
|
|
|
|
call assert_equal('n', mode())
|
|
|
|
|
|
|
|
|
|
iunmap <LeftDrag>
|
|
|
|
|
iunmap <F2>
|
|
|
|
|
iunmap <F3>
|
|
|
|
|
delfunc ClickExpr
|
|
|
|
|
delfunc DragExpr
|
|
|
|
|
set mouse&
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-04-27 05:27:38 -07:00
|
|
|
|
func Test_unmap_simplifiable()
|
2022-04-27 05:21:04 -07:00
|
|
|
|
map <C-I> foo
|
|
|
|
|
map <Tab> bar
|
|
|
|
|
call assert_equal('foo', maparg('<C-I>'))
|
|
|
|
|
call assert_equal('bar', maparg('<Tab>'))
|
|
|
|
|
unmap <C-I>
|
|
|
|
|
call assert_equal('', maparg('<C-I>'))
|
|
|
|
|
call assert_equal('bar', maparg('<Tab>'))
|
|
|
|
|
unmap <Tab>
|
2022-04-27 05:27:38 -07:00
|
|
|
|
|
|
|
|
|
map <C-I> foo
|
|
|
|
|
unmap <Tab>
|
|
|
|
|
" This should not error
|
|
|
|
|
unmap <C-I>
|
2022-04-27 05:21:04 -07:00
|
|
|
|
endfunc
|
|
|
|
|
|
2022-05-02 15:11:22 -07:00
|
|
|
|
func Test_expr_map_escape_special()
|
|
|
|
|
nnoremap … <Cmd>let g:got_ellipsis += 1<CR>
|
|
|
|
|
func Func()
|
|
|
|
|
return '…'
|
|
|
|
|
endfunc
|
|
|
|
|
nmap <expr> <F2> Func()
|
|
|
|
|
let g:got_ellipsis = 0
|
|
|
|
|
call feedkeys("\<F2>", 'xt')
|
|
|
|
|
call assert_equal(1, g:got_ellipsis)
|
|
|
|
|
delfunc Func
|
|
|
|
|
nunmap <F2>
|
|
|
|
|
unlet g:got_ellipsis
|
|
|
|
|
nunmap …
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-06-06 09:19:57 -07:00
|
|
|
|
" Testing for mapping after an <Nop> mapping is triggered on timeout.
|
|
|
|
|
" Test for what patch 8.1.0052 fixes.
|
|
|
|
|
func Test_map_after_timed_out_nop()
|
|
|
|
|
CheckRunVimInTerminal
|
|
|
|
|
|
|
|
|
|
let lines =<< trim END
|
|
|
|
|
set timeout timeoutlen=400
|
|
|
|
|
inoremap ab TEST
|
|
|
|
|
inoremap a <Nop>
|
|
|
|
|
END
|
|
|
|
|
call writefile(lines, 'Xtest_map_after_timed_out_nop')
|
|
|
|
|
let buf = RunVimInTerminal('-S Xtest_map_after_timed_out_nop', #{rows: 6})
|
|
|
|
|
|
|
|
|
|
" Enter Insert mode
|
|
|
|
|
call term_sendkeys(buf, 'i')
|
|
|
|
|
" Wait for the "a" mapping to timeout
|
|
|
|
|
call term_sendkeys(buf, 'a')
|
|
|
|
|
call term_wait(buf, 500)
|
|
|
|
|
" Send "a" and wait for a period shorter than 'timeoutlen'
|
|
|
|
|
call term_sendkeys(buf, 'a')
|
|
|
|
|
call term_wait(buf, 100)
|
|
|
|
|
" Send "b", should trigger the "ab" mapping
|
|
|
|
|
call term_sendkeys(buf, 'b')
|
|
|
|
|
call WaitForAssert({-> assert_equal("TEST", term_getline(buf, 1))})
|
|
|
|
|
|
|
|
|
|
" clean up
|
|
|
|
|
call StopVimInTerminal(buf)
|
|
|
|
|
call delete('Xtest_map_after_timed_out_nop')
|
|
|
|
|
endfunc
|
|
|
|
|
|
2022-09-20 20:06:39 -07:00
|
|
|
|
func Test_using_past_typeahead()
|
|
|
|
|
nnoremap :00 0
|
|
|
|
|
exe "norm :set \x80\xfb0=0\<CR>"
|
|
|
|
|
exe "sil norm :0\x0f\<C-U>\<CR>"
|
|
|
|
|
|
|
|
|
|
exe "norm :set \x80\xfb0=\<CR>"
|
|
|
|
|
nunmap :00
|
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
|
|
|
2020-04-01 15:45:38 -07:00
|
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|