mirror of
https://github.com/neovim/neovim.git
synced 2025-10-26 12:27:24 +00:00
457ab65ff3
Problem: Code style is not check in test scripts.
Solution: Add basic code style check for test files.
94722c5107
Use Test_test_files() from latest Vim.
Co-authored-by: Bram Moolenaar <Bram@vim.org>
2722 lines
87 KiB
VimL
2722 lines
87 KiB
VimL
" Tests for various Visual modes.
|
||
|
||
source shared.vim
|
||
source check.vim
|
||
source screendump.vim
|
||
source vim9.vim
|
||
|
||
func Test_block_shift_multibyte()
|
||
" Uses double-wide character.
|
||
split
|
||
call setline(1, ['xヹxxx', 'ヹxxx'])
|
||
exe "normal 1G0l\<C-V>jl>"
|
||
call assert_equal('x ヹxxx', getline(1))
|
||
call assert_equal(' ヹxxx', getline(2))
|
||
q!
|
||
endfunc
|
||
|
||
func Test_block_shift_overflow()
|
||
" This used to cause a multiplication overflow followed by a crash.
|
||
new
|
||
normal ii
|
||
exe "normal \<C-V>876543210>"
|
||
q!
|
||
endfunc
|
||
|
||
func Test_dotregister_paste()
|
||
new
|
||
exe "norm! ihello world\<esc>"
|
||
norm! 0ve".p
|
||
call assert_equal('hello world world', getline(1))
|
||
q!
|
||
endfunc
|
||
|
||
func Test_Visual_ctrl_o()
|
||
new
|
||
call setline(1, ['one', 'two', 'three'])
|
||
call cursor(1,2)
|
||
set noshowmode
|
||
set tw=0
|
||
call feedkeys("\<c-v>jjlIa\<c-\>\<c-o>:set tw=88\<cr>\<esc>", 'tx')
|
||
call assert_equal(['oane', 'tawo', 'tahree'], getline(1, 3))
|
||
call assert_equal(88, &tw)
|
||
set tw&
|
||
bw!
|
||
endfu
|
||
|
||
func Test_Visual_vapo()
|
||
new
|
||
normal oxx
|
||
normal vapo
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_Visual_inner_quote()
|
||
new
|
||
normal oxX
|
||
normal vki'
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for Visual mode not being reset causing E315 error.
|
||
func TriggerTheProblem()
|
||
" At this point there is no visual selection because :call reset it.
|
||
" Let's restore the selection:
|
||
normal gv
|
||
'<,'>del _
|
||
try
|
||
exe "normal \<Esc>"
|
||
catch /^Vim\%((\a\+)\)\=:E315/
|
||
echom 'Snap! E315 error!'
|
||
let g:msg = 'Snap! E315 error!'
|
||
endtry
|
||
endfunc
|
||
|
||
func Test_visual_mode_reset()
|
||
enew
|
||
let g:msg = "Everything's fine."
|
||
enew
|
||
setl buftype=nofile
|
||
call append(line('$'), 'Delete this line.')
|
||
|
||
" NOTE: this has to be done by a call to a function because executing :del
|
||
" the ex-way will require the colon operator which resets the visual mode
|
||
" thus preventing the problem:
|
||
exe "normal! GV:call TriggerTheProblem()\<CR>"
|
||
call assert_equal("Everything's fine.", g:msg)
|
||
endfunc
|
||
|
||
" Test for visual block shift and tab characters.
|
||
func Test_block_shift_tab()
|
||
new
|
||
call append(0, repeat(['one two three'], 5))
|
||
call cursor(1,1)
|
||
exe "normal i\<C-G>u"
|
||
exe "normal fe\<C-V>4jR\<Esc>ugvr1"
|
||
call assert_equal('on1 two three', getline(1))
|
||
call assert_equal('on1 two three', getline(2))
|
||
call assert_equal('on1 two three', getline(5))
|
||
|
||
%d _
|
||
call append(0, repeat(['abcdefghijklmnopqrstuvwxyz'], 5))
|
||
call cursor(1,1)
|
||
exe "normal \<C-V>4jI \<Esc>j<<11|D"
|
||
exe "normal j7|a\<Tab>\<Tab>"
|
||
exe "normal j7|a\<Tab>\<Tab> "
|
||
exe "normal j7|a\<Tab> \<Tab>\<Esc>4k13|\<C-V>4j<"
|
||
call assert_equal(' abcdefghijklmnopqrstuvwxyz', getline(1))
|
||
call assert_equal('abcdefghij', getline(2))
|
||
call assert_equal(" abc\<Tab> defghijklmnopqrstuvwxyz", getline(3))
|
||
call assert_equal(" abc\<Tab> defghijklmnopqrstuvwxyz", getline(4))
|
||
call assert_equal(" abc\<Tab> defghijklmnopqrstuvwxyz", getline(5))
|
||
|
||
%s/\s\+//g
|
||
call cursor(1,1)
|
||
exe "normal \<C-V>4jI \<Esc>j<<"
|
||
exe "normal j7|a\<Tab>\<Tab>"
|
||
exe "normal j7|a\<Tab>\<Tab>\<Tab>\<Tab>\<Tab>"
|
||
exe "normal j7|a\<Tab> \<Tab>\<Tab>\<Esc>4k13|\<C-V>4j3<"
|
||
call assert_equal(' abcdefghijklmnopqrstuvwxyz', getline(1))
|
||
call assert_equal('abcdefghij', getline(2))
|
||
call assert_equal(" abc\<Tab> defghijklmnopqrstuvwxyz", getline(3))
|
||
call assert_equal(" abc\<Tab>\<Tab>defghijklmnopqrstuvwxyz", getline(4))
|
||
call assert_equal(" abc\<Tab> defghijklmnopqrstuvwxyz", getline(5))
|
||
|
||
" Test for block shift with space characters at the beginning and with
|
||
" 'noexpandtab' and 'expandtab'
|
||
%d _
|
||
call setline(1, [" 1", " 2", " 3"])
|
||
setlocal shiftwidth=2 noexpandtab
|
||
exe "normal gg\<C-V>3j>"
|
||
call assert_equal(["\t1", "\t2", "\t3"], getline(1, '$'))
|
||
%d _
|
||
call setline(1, [" 1", " 2", " 3"])
|
||
setlocal shiftwidth=2 expandtab
|
||
exe "normal gg\<C-V>3j>"
|
||
call assert_equal([" 1", " 2", " 3"], getline(1, '$'))
|
||
setlocal shiftwidth&
|
||
|
||
bw!
|
||
endfunc
|
||
|
||
" Tests Blockwise Visual when there are TABs before the text.
|
||
func Test_blockwise_visual()
|
||
new
|
||
call append(0, ['123456',
|
||
\ '234567',
|
||
\ '345678',
|
||
\ '',
|
||
\ 'test text test tex start here',
|
||
\ "\t\tsome text",
|
||
\ "\t\ttest text",
|
||
\ 'test text'])
|
||
call cursor(1,1)
|
||
exe "normal /start here$\<CR>"
|
||
exe 'normal "by$' . "\<C-V>jjlld"
|
||
exe "normal /456$\<CR>"
|
||
exe "normal \<C-V>jj" . '"bP'
|
||
call assert_equal(['123start here56',
|
||
\ '234start here67',
|
||
\ '345start here78',
|
||
\ '',
|
||
\ 'test text test tex rt here',
|
||
\ "\t\tsomext",
|
||
\ "\t\ttesext"], getline(1, 7))
|
||
|
||
bw!
|
||
endfunc
|
||
|
||
" Test swapping corners in blockwise visual mode with o and O
|
||
func Test_blockwise_visual_o_O()
|
||
new
|
||
|
||
exe "norm! 10i.\<Esc>Y4P3lj\<C-V>4l2jr "
|
||
exe "norm! gvO\<Esc>ra"
|
||
exe "norm! gvO\<Esc>rb"
|
||
exe "norm! gvo\<C-c>rc"
|
||
exe "norm! gvO\<C-c>rd"
|
||
set selection=exclusive
|
||
exe "norm! gvOo\<C-c>re"
|
||
call assert_equal('...a be.', getline(4))
|
||
exe "norm! gvOO\<C-c>rf"
|
||
set selection&
|
||
|
||
call assert_equal(['..........',
|
||
\ '...c d..',
|
||
\ '... ..',
|
||
\ '...a bf.',
|
||
\ '..........'], getline(1, '$'))
|
||
|
||
bw!
|
||
endfun
|
||
|
||
" Test Virtual replace mode.
|
||
func Test_virtual_replace()
|
||
if exists('&t_kD')
|
||
let save_t_kD = &t_kD
|
||
endif
|
||
if exists('&t_kb')
|
||
let save_t_kb = &t_kb
|
||
endif
|
||
exe "set t_kD=\<C-V>x7f t_kb=\<C-V>x08"
|
||
enew!
|
||
exe "normal a\nabcdefghi\njk\tlmn\n opq rst\n\<C-D>uvwxyz"
|
||
call cursor(1,1)
|
||
set ai bs=2
|
||
exe "normal gR0\<C-D> 1\nA\nBCDEFGHIJ\n\tKL\nMNO\nPQR"
|
||
call assert_equal([' 1',
|
||
\ ' A',
|
||
\ ' BCDEFGHIJ',
|
||
\ ' KL',
|
||
\ ' MNO',
|
||
\ ' PQR',
|
||
\ ], getline(1, 6))
|
||
normal G
|
||
mark a
|
||
exe "normal o0\<C-D>\nabcdefghi\njk\tlmn\n opq\trst\n\<C-D>uvwxyz\n"
|
||
exe "normal 'ajgR0\<C-D> 1\nA\nBCDEFGHIJ\n\tKL\nMNO\nPQR" . repeat("\<BS>", 29)
|
||
call assert_equal([' 1',
|
||
\ 'abcdefghi',
|
||
\ 'jk lmn',
|
||
\ ' opq rst',
|
||
\ 'uvwxyz'], getline(7, 11))
|
||
normal G
|
||
exe "normal iab\tcdefghi\tjkl"
|
||
exe "normal 0gRAB......CDEFGHI.J\<Esc>o"
|
||
exe "normal iabcdefghijklmnopqrst\<Esc>0gRAB\tIJKLMNO\tQR"
|
||
call assert_equal(['AB......CDEFGHI.Jkl',
|
||
\ 'AB IJKLMNO QRst'], getline(12, 13))
|
||
|
||
" Test inserting Tab with 'noexpandtab' and 'softabstop' set to 4
|
||
%d
|
||
call setline(1, 'aaaaaaaaaaaaa')
|
||
set softtabstop=4
|
||
exe "normal gggR\<Tab>\<Tab>x"
|
||
call assert_equal("\txaaaa", getline(1))
|
||
set softtabstop&
|
||
|
||
enew!
|
||
set noai bs&vim
|
||
if exists('save_t_kD')
|
||
let &t_kD = save_t_kD
|
||
endif
|
||
if exists('save_t_kb')
|
||
let &t_kb = save_t_kb
|
||
endif
|
||
endfunc
|
||
|
||
" Test Virtual replace mode.
|
||
func Test_virtual_replace2()
|
||
enew!
|
||
set bs=2
|
||
exe "normal a\nabcdefghi\njk\tlmn\n opq rst\n\<C-D>uvwxyz"
|
||
call cursor(1,1)
|
||
" Test 1: Test that del deletes the newline
|
||
exe "normal gR0\<del> 1\nA\nBCDEFGHIJ\n\tKL\nMNO\nPQR"
|
||
call assert_equal(['0 1',
|
||
\ 'A',
|
||
\ 'BCDEFGHIJ',
|
||
\ ' KL',
|
||
\ 'MNO',
|
||
\ 'PQR',
|
||
\ ], getline(1, 6))
|
||
" Test 2:
|
||
" a newline is not deleted, if no newline has been added in virtual replace mode
|
||
%d_
|
||
call setline(1, ['abcd', 'efgh', 'ijkl'])
|
||
call cursor(2,1)
|
||
exe "norm! gR1234\<cr>5\<bs>\<bs>\<bs>"
|
||
call assert_equal(['abcd',
|
||
\ '123h',
|
||
\ 'ijkl'], getline(1, '$'))
|
||
" Test 3:
|
||
" a newline is deleted, if a newline has been inserted before in virtual replace mode
|
||
%d_
|
||
call setline(1, ['abcd', 'efgh', 'ijkl'])
|
||
call cursor(2,1)
|
||
exe "norm! gR1234\<cr>\<cr>56\<bs>\<bs>\<bs>"
|
||
call assert_equal(['abcd',
|
||
\ '1234',
|
||
\ 'ijkl'], getline(1, '$'))
|
||
" Test 4:
|
||
" delete add a newline, delete it, add it again and check undo
|
||
%d_
|
||
call setline(1, ['abcd', 'efgh', 'ijkl'])
|
||
call cursor(2,1)
|
||
" break undo sequence explicitly
|
||
let &ul = &ul
|
||
exe "norm! gR1234\<cr>\<bs>\<del>56\<cr>"
|
||
let &ul = &ul
|
||
call assert_equal(['abcd',
|
||
\ '123456',
|
||
\ ''], getline(1, '$'))
|
||
norm! u
|
||
call assert_equal(['abcd',
|
||
\ 'efgh',
|
||
\ 'ijkl'], getline(1, '$'))
|
||
|
||
" Test for truncating spaces in a newly added line using 'autoindent' if
|
||
" characters are not added to that line.
|
||
%d_
|
||
call setline(1, [' app', ' bee', ' cat'])
|
||
setlocal autoindent
|
||
exe "normal gg$gRt\n\nr"
|
||
call assert_equal([' apt', '', ' rat'], getline(1, '$'))
|
||
|
||
" clean up
|
||
%d_
|
||
set bs&vim
|
||
endfunc
|
||
|
||
func Test_Visual_word_textobject()
|
||
new
|
||
call setline(1, ['First sentence. Second sentence.'])
|
||
|
||
" When start and end of visual area are identical, 'aw' or 'iw' select
|
||
" the whole word.
|
||
norm! 1go2fcvawy
|
||
call assert_equal('Second ', @")
|
||
norm! 1go2fcviwy
|
||
call assert_equal('Second', @")
|
||
|
||
" When start and end of visual area are not identical, 'aw' or 'iw'
|
||
" extend the word in direction of the end of the visual area.
|
||
norm! 1go2fcvlawy
|
||
call assert_equal('cond ', @")
|
||
norm! gv2awy
|
||
call assert_equal('cond sentence.', @")
|
||
|
||
norm! 1go2fcvliwy
|
||
call assert_equal('cond', @")
|
||
norm! gv2iwy
|
||
call assert_equal('cond sentence', @")
|
||
|
||
" Extend visual area in opposite direction.
|
||
norm! 1go2fcvhawy
|
||
call assert_equal(' Sec', @")
|
||
norm! gv2awy
|
||
call assert_equal(' sentence. Sec', @")
|
||
|
||
norm! 1go2fcvhiwy
|
||
call assert_equal('Sec', @")
|
||
norm! gv2iwy
|
||
call assert_equal('. Sec', @")
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_Visual_sentence_textobject()
|
||
new
|
||
call setline(1, ['First sentence. Second sentence. Third', 'sentence. Fourth sentence'])
|
||
|
||
" When start and end of visual area are identical, 'as' or 'is' select
|
||
" the whole sentence.
|
||
norm! 1gofdvasy
|
||
call assert_equal('Second sentence. ', @")
|
||
norm! 1gofdvisy
|
||
call assert_equal('Second sentence.', @")
|
||
|
||
" When start and end of visual area are not identical, 'as' or 'is'
|
||
" extend the sentence in direction of the end of the visual area.
|
||
norm! 1gofdvlasy
|
||
call assert_equal('d sentence. ', @")
|
||
norm! gvasy
|
||
call assert_equal("d sentence. Third\nsentence. ", @")
|
||
|
||
norm! 1gofdvlisy
|
||
call assert_equal('d sentence.', @")
|
||
norm! gvisy
|
||
call assert_equal('d sentence. ', @")
|
||
norm! gvisy
|
||
call assert_equal("d sentence. Third\nsentence.", @")
|
||
|
||
" Extend visual area in opposite direction.
|
||
norm! 1gofdvhasy
|
||
call assert_equal(' Second', @")
|
||
norm! gvasy
|
||
call assert_equal("First sentence. Second", @")
|
||
|
||
norm! 1gofdvhisy
|
||
call assert_equal('Second', @")
|
||
norm! gvisy
|
||
call assert_equal(' Second', @")
|
||
norm! gvisy
|
||
call assert_equal('First sentence. Second', @")
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_Visual_paragraph_textobject()
|
||
new
|
||
let lines =<< trim [END]
|
||
First line.
|
||
|
||
Second line.
|
||
Third line.
|
||
Fourth line.
|
||
Fifth line.
|
||
|
||
Sixth line.
|
||
[END]
|
||
call setline(1, lines)
|
||
|
||
" When start and end of visual area are identical, 'ap' or 'ip' select
|
||
" the whole paragraph.
|
||
norm! 4ggvapy
|
||
call assert_equal("Second line.\nThird line.\nFourth line.\nFifth line.\n\n", @")
|
||
norm! 4ggvipy
|
||
call assert_equal("Second line.\nThird line.\nFourth line.\nFifth line.\n", @")
|
||
|
||
" When start and end of visual area are not identical, 'ap' or 'ip'
|
||
" extend the sentence in direction of the end of the visual area.
|
||
" FIXME: actually, it is not sufficient to have different start and
|
||
" end of visual selection, the start line and end line have to differ,
|
||
" which is not consistent with the documentation.
|
||
norm! 4ggVjapy
|
||
call assert_equal("Third line.\nFourth line.\nFifth line.\n\n", @")
|
||
norm! gvapy
|
||
call assert_equal("Third line.\nFourth line.\nFifth line.\n\nSixth line.\n", @")
|
||
norm! 4ggVjipy
|
||
call assert_equal("Third line.\nFourth line.\nFifth line.\n", @")
|
||
norm! gvipy
|
||
call assert_equal("Third line.\nFourth line.\nFifth line.\n\n", @")
|
||
norm! gvipy
|
||
call assert_equal("Third line.\nFourth line.\nFifth line.\n\nSixth line.\n", @")
|
||
|
||
" Extend visual area in opposite direction.
|
||
norm! 5ggVkapy
|
||
call assert_equal("\nSecond line.\nThird line.\nFourth line.\n", @")
|
||
norm! gvapy
|
||
call assert_equal("First line.\n\nSecond line.\nThird line.\nFourth line.\n", @")
|
||
norm! 5ggVkipy
|
||
call assert_equal("Second line.\nThird line.\nFourth line.\n", @")
|
||
norma gvipy
|
||
call assert_equal("\nSecond line.\nThird line.\nFourth line.\n", @")
|
||
norm! gvipy
|
||
call assert_equal("First line.\n\nSecond line.\nThird line.\nFourth line.\n", @")
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_curswant_not_changed()
|
||
new
|
||
call setline(1, ['one', 'two'])
|
||
au InsertLeave * call getcurpos()
|
||
call feedkeys("gg0\<C-V>jI123 \<Esc>j", 'xt')
|
||
call assert_equal([0, 2, 1, 0, 1], getcurpos())
|
||
|
||
bwipe!
|
||
au! InsertLeave
|
||
endfunc
|
||
|
||
" Tests for "vaBiB", end could be wrong.
|
||
func Test_Visual_Block()
|
||
new
|
||
a
|
||
- Bug in "vPPPP" on this text:
|
||
{
|
||
cmd;
|
||
{
|
||
cmd;\t/* <-- Start cursor here */
|
||
{
|
||
}
|
||
}
|
||
}
|
||
.
|
||
normal gg
|
||
call search('Start cursor here')
|
||
normal vaBiBD
|
||
call assert_equal(['- Bug in "vPPPP" on this text:',
|
||
\ "\t{",
|
||
\ "\t}"], getline(1, '$'))
|
||
|
||
close!
|
||
endfunc
|
||
|
||
" Test for 'p'ut in visual block mode
|
||
func Test_visual_block_put()
|
||
new
|
||
call append(0, ['One', 'Two', 'Three'])
|
||
normal gg
|
||
yank
|
||
call feedkeys("jl\<C-V>ljp", 'xt')
|
||
call assert_equal(['One', 'T', 'Tee', 'One', ''], getline(1, '$'))
|
||
bw!
|
||
endfunc
|
||
|
||
func Test_visual_block_put_invalid()
|
||
enew!
|
||
" behave mswin
|
||
set selection=exclusive
|
||
norm yy
|
||
norm v)Ps/^/
|
||
" this was causing the column to become negative
|
||
silent norm ggv)P
|
||
|
||
bwipe!
|
||
" behave xterm
|
||
set selection&
|
||
endfunc
|
||
|
||
" Visual modes (v V CTRL-V) followed by an operator; count; repeating
|
||
func Test_visual_mode_op()
|
||
new
|
||
call append(0, '')
|
||
|
||
call setline(1, 'apple banana cherry')
|
||
call cursor(1, 1)
|
||
normal lvld.l3vd.
|
||
call assert_equal('a y', getline(1))
|
||
|
||
call setline(1, ['line 1 line 1', 'line 2 line 2', 'line 3 line 3',
|
||
\ 'line 4 line 4', 'line 5 line 5', 'line 6 line 6'])
|
||
call cursor(1, 1)
|
||
exe "normal Vcnewline\<Esc>j.j2Vd."
|
||
call assert_equal(['newline', 'newline'], getline(1, '$'))
|
||
|
||
call deletebufline('', 1, '$')
|
||
call setline(1, ['xxxxxxxxxxxxx', 'xxxxxxxxxxxxx', 'xxxxxxxxxxxxx',
|
||
\ 'xxxxxxxxxxxxx'])
|
||
exe "normal \<C-V>jlc \<Esc>l.l2\<C-V>c----\<Esc>l."
|
||
call assert_equal([' --------x',
|
||
\ ' --------x',
|
||
\ 'xxxx--------x',
|
||
\ 'xxxx--------x'], getline(1, '$'))
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Visual mode maps (movement and text object)
|
||
" Visual mode maps; count; repeating
|
||
" - Simple
|
||
" - With an Ex command (custom text object)
|
||
func Test_visual_mode_maps()
|
||
new
|
||
call append(0, '')
|
||
|
||
func SelectInCaps()
|
||
let [line1, col1] = searchpos('\u', 'bcnW')
|
||
let [line2, col2] = searchpos('.\u', 'nW')
|
||
call setpos("'<", [0, line1, col1, 0])
|
||
call setpos("'>", [0, line2, col2, 0])
|
||
normal! gv
|
||
endfunction
|
||
|
||
vnoremap W /\u/s-1<CR>
|
||
vnoremap iW :<C-U>call SelectInCaps()<CR>
|
||
|
||
call setline(1, 'KiwiRaspberryDateWatermelonPeach')
|
||
call cursor(1, 1)
|
||
exe "normal vWcNo\<Esc>l.fD2vd."
|
||
call assert_equal('NoNoberryach', getline(1))
|
||
|
||
call setline(1, 'JambuRambutanBananaTangerineMango')
|
||
call cursor(1, 1)
|
||
exe "normal llviWc-\<Esc>l.l2vdl."
|
||
call assert_equal('--ago', getline(1))
|
||
|
||
vunmap W
|
||
vunmap iW
|
||
bwipe!
|
||
delfunc SelectInCaps
|
||
endfunc
|
||
|
||
" Operator-pending mode maps (movement and text object)
|
||
" - Simple
|
||
" - With Ex command moving the cursor
|
||
" - With Ex command and Visual selection (custom text object)
|
||
func Test_visual_oper_pending_mode_maps()
|
||
new
|
||
call append(0, '')
|
||
|
||
func MoveToCap()
|
||
call search('\u', 'W')
|
||
endfunction
|
||
|
||
func SelectInCaps()
|
||
let [line1, col1] = searchpos('\u', 'bcnW')
|
||
let [line2, col2] = searchpos('.\u', 'nW')
|
||
call setpos("'<", [0, line1, col1, 0])
|
||
call setpos("'>", [0, line2, col2, 0])
|
||
normal! gv
|
||
endfunction
|
||
|
||
onoremap W /\u/<CR>
|
||
onoremap <Leader>W :<C-U>call MoveToCap()<CR>
|
||
onoremap iW :<C-U>call SelectInCaps()<CR>
|
||
|
||
call setline(1, 'PineappleQuinceLoganberryOrangeGrapefruitKiwiZ')
|
||
call cursor(1, 1)
|
||
exe "normal cW-\<Esc>l.l2.l."
|
||
call assert_equal('----Z', getline(1))
|
||
|
||
call setline(1, 'JuniperDurianZ')
|
||
call cursor(1, 1)
|
||
exe "normal g?\WfD."
|
||
call assert_equal('WhavcreQhevnaZ', getline(1))
|
||
|
||
call setline(1, 'LemonNectarineZ')
|
||
call cursor(1, 1)
|
||
exe "normal yiWPlciWNew\<Esc>fr."
|
||
call assert_equal('LemonNewNewZ', getline(1))
|
||
|
||
ounmap W
|
||
ounmap <Leader>W
|
||
ounmap iW
|
||
bwipe!
|
||
delfunc MoveToCap
|
||
delfunc SelectInCaps
|
||
endfunc
|
||
|
||
" Patch 7.3.879: Properly abort Operator-pending mode for "dv:<Esc>" etc.
|
||
func Test_op_pend_mode_abort()
|
||
new
|
||
call append(0, '')
|
||
|
||
call setline(1, ['zzzz', 'zzzz'])
|
||
call cursor(1, 1)
|
||
|
||
exe "normal dV:\<CR>dv:\<CR>"
|
||
call assert_equal(['zzz'], getline(1, 2))
|
||
set nomodifiable
|
||
call assert_fails('exe "normal d:\<CR>"', 'E21:')
|
||
set modifiable
|
||
call feedkeys("dv:\<Esc>dV:\<Esc>", 'xt')
|
||
call assert_equal(['zzz'], getline(1, 2))
|
||
set nomodifiable
|
||
let v:errmsg = ''
|
||
call feedkeys("d:\<Esc>", 'xt')
|
||
call assert_true(v:errmsg !~# '^E21:')
|
||
set modifiable
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_characterwise_visual_mode()
|
||
new
|
||
|
||
" characterwise visual mode: replace last line
|
||
$put ='a'
|
||
let @" = 'x'
|
||
normal v$p
|
||
call assert_equal('x', getline('$'))
|
||
|
||
" characterwise visual mode: delete middle line
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['a', 'b', 'c'])
|
||
normal G
|
||
normal kkv$d
|
||
call assert_equal(['', 'b', 'c'], getline(1, '$'))
|
||
|
||
" characterwise visual mode: delete middle two lines
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['a', 'b', 'c'])
|
||
normal Gkkvj$d
|
||
call assert_equal(['', 'c'], getline(1, '$'))
|
||
|
||
" characterwise visual mode: delete last line
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['a', 'b', 'c'])
|
||
normal Gv$d
|
||
call assert_equal(['', 'a', 'b', ''], getline(1, '$'))
|
||
|
||
" characterwise visual mode: delete last two lines
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['a', 'b', 'c'])
|
||
normal Gkvj$d
|
||
call assert_equal(['', 'a', ''], getline(1, '$'))
|
||
|
||
" characterwise visual mode: use a count with the visual mode from the last
|
||
" line in the buffer
|
||
%d _
|
||
call setline(1, ['one', 'two', 'three', 'four'])
|
||
norm! vj$y
|
||
norm! G1vy
|
||
call assert_equal('four', @")
|
||
|
||
" characterwise visual mode: replace a single character line and the eol
|
||
%d _
|
||
call setline(1, "a")
|
||
normal v$rx
|
||
call assert_equal(['x'], getline(1, '$'))
|
||
|
||
" replace a character with composing characters
|
||
call setline(1, "xã̳x")
|
||
normal gg0lvrb
|
||
call assert_equal("xbx", getline(1))
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_mode_put()
|
||
new
|
||
|
||
" v_p: replace last character with line register at middle line
|
||
call append('$', ['aaa', 'bbb', 'ccc'])
|
||
normal G
|
||
-2yank
|
||
normal k$vp
|
||
call assert_equal(['', 'aaa', 'bb', 'aaa', '', 'ccc'], getline(1, '$'))
|
||
|
||
" v_p: replace last character with line register at middle line selecting
|
||
" newline
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['aaa', 'bbb', 'ccc'])
|
||
normal G
|
||
-2yank
|
||
normal k$v$p
|
||
call assert_equal(['', 'aaa', 'bb', 'aaa', 'ccc'], getline(1, '$'))
|
||
|
||
" v_p: replace last character with line register at last line
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['aaa', 'bbb', 'ccc'])
|
||
normal G
|
||
-2yank
|
||
normal $vp
|
||
call assert_equal(['', 'aaa', 'bbb', 'cc', 'aaa', ''], getline(1, '$'))
|
||
|
||
" v_p: replace last character with line register at last line selecting
|
||
" newline
|
||
call deletebufline('', 1, '$')
|
||
call append('$', ['aaa', 'bbb', 'ccc'])
|
||
normal G
|
||
-2yank
|
||
normal $v$p
|
||
call assert_equal(['', 'aaa', 'bbb', 'cc', 'aaa', ''], getline(1, '$'))
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_gv_with_exclusive_selection()
|
||
new
|
||
|
||
" gv with exclusive selection after an operation
|
||
call append('$', ['zzz ', 'äà '])
|
||
set selection=exclusive
|
||
normal Gkv3lyjv3lpgvcxxx
|
||
call assert_equal(['', 'zzz ', 'xxx '], getline(1, '$'))
|
||
|
||
" gv with exclusive selection without an operation
|
||
call deletebufline('', 1, '$')
|
||
call append('$', 'zzz ')
|
||
set selection=exclusive
|
||
exe "normal G0v3l\<Esc>gvcxxx"
|
||
call assert_equal(['', 'xxx '], getline(1, '$'))
|
||
|
||
set selection&vim
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Tests for the visual block mode commands
|
||
func Test_visual_block_mode()
|
||
new
|
||
call append(0, '')
|
||
call setline(1, repeat(['abcdefghijklm'], 5))
|
||
call cursor(1, 1)
|
||
|
||
" Test shift-right of a block
|
||
exe "normal jllll\<C-V>jj>wll\<C-V>jlll>"
|
||
" Test shift-left of a block
|
||
exe "normal G$hhhh\<C-V>kk<"
|
||
" Test block-insert
|
||
exe "normal Gkl\<C-V>kkkIxyz"
|
||
" Test block-replace
|
||
exe "normal Gllll\<C-V>kkklllrq"
|
||
" Test block-change
|
||
exe "normal G$khhh\<C-V>hhkkcmno"
|
||
call assert_equal(['axyzbcdefghijklm',
|
||
\ 'axyzqqqq mno ghijklm',
|
||
\ 'axyzqqqqef mno ghijklm',
|
||
\ 'axyzqqqqefgmnoklm',
|
||
\ 'abcdqqqqijklm'], getline(1, 5))
|
||
|
||
" Test 'C' to change till the end of the line
|
||
call cursor(3, 4)
|
||
exe "normal! \<C-V>j3lCooo"
|
||
call assert_equal(['axyooo', 'axyooo'], getline(3, 4))
|
||
|
||
" Test 'D' to delete till the end of the line
|
||
call cursor(3, 3)
|
||
exe "normal! \<C-V>j2lD"
|
||
call assert_equal(['ax', 'ax'], getline(3, 4))
|
||
|
||
" Test block insert with a short line that ends before the block
|
||
%d _
|
||
call setline(1, [" one", "a", " two"])
|
||
exe "normal gg\<C-V>2jIx"
|
||
call assert_equal([" xone", "a", " xtwo"], getline(1, '$'))
|
||
|
||
" Test block append at EOL with '$' and without '$'
|
||
%d _
|
||
call setline(1, ["one", "a", "two"])
|
||
exe "normal gg$\<C-V>2jAx"
|
||
call assert_equal(["onex", "ax", "twox"], getline(1, '$'))
|
||
%d _
|
||
call setline(1, ["one", "a", "two"])
|
||
exe "normal gg3l\<C-V>2jAx"
|
||
call assert_equal(["onex", "a x", "twox"], getline(1, '$'))
|
||
|
||
" Test block replace with an empty line in the middle and use $ to jump to
|
||
" the end of the line.
|
||
%d _
|
||
call setline(1, ['one', '', 'two'])
|
||
exe "normal gg$\<C-V>2jrx"
|
||
call assert_equal(["onx", "", "twx"], getline(1, '$'))
|
||
|
||
" Test block replace with an empty line in the middle and move cursor to the
|
||
" end of the line
|
||
%d _
|
||
call setline(1, ['one', '', 'two'])
|
||
exe "normal gg2l\<C-V>2jrx"
|
||
call assert_equal(["onx", "", "twx"], getline(1, '$'))
|
||
|
||
" Replace odd number of characters with a multibyte character
|
||
%d _
|
||
call setline(1, ['abcd', 'efgh'])
|
||
exe "normal ggl\<C-V>2ljr\u1100"
|
||
call assert_equal(["a\u1100 ", "e\u1100 "], getline(1, '$'))
|
||
|
||
" During visual block append, if the cursor moved outside of the selected
|
||
" range, then the edit should not be applied to the block.
|
||
%d _
|
||
call setline(1, ['aaa', 'bbb', 'ccc'])
|
||
exe "normal 2G\<C-V>jAx\<Up>"
|
||
call assert_equal(['aaa', 'bxbb', 'ccc'], getline(1, '$'))
|
||
|
||
" During visual block append, if the cursor is moved before the start of the
|
||
" block, then the new text should be appended there.
|
||
%d _
|
||
call setline(1, ['aaa', 'bbb', 'ccc'])
|
||
exe "normal $\<C-V>2jA\<Left>x"
|
||
call assert_equal(['aaxa', 'bbxb', 'ccxc'], getline(1, '$'))
|
||
" Repeat the previous test but use 'l' to move the cursor instead of '$'
|
||
call setline(1, ['aaa', 'bbb', 'ccc'])
|
||
exe "normal! gg2l\<C-V>2jA\<Left>x"
|
||
call assert_equal(['aaxa', 'bbxb', 'ccxc'], getline(1, '$'))
|
||
|
||
" Change a characterwise motion to a blockwise motion using CTRL-V
|
||
%d _
|
||
call setline(1, ['123', '456', '789'])
|
||
exe "normal ld\<C-V>j"
|
||
call assert_equal(['13', '46', '789'], getline(1, '$'))
|
||
|
||
" Test from ':help v_b_I_example'
|
||
%d _
|
||
setlocal tabstop=8 shiftwidth=4
|
||
let lines =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call setline(1, lines)
|
||
exe "normal ggfo\<C-V>3jISTRING"
|
||
let expected =<< trim END
|
||
abcdefghijklmnSTRINGopqrstuvwxyz
|
||
abc STRING defghijklmnopqrstuvwxyz
|
||
abcdef ghi STRING jklmnopqrstuvwxyz
|
||
abcdefghijklmnSTRINGopqrstuvwxyz
|
||
END
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
" Test from ':help v_b_A_example'
|
||
%d _
|
||
let lines =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call setline(1, lines)
|
||
exe "normal ggfo\<C-V>3j$ASTRING"
|
||
let expected =<< trim END
|
||
abcdefghijklmnopqrstuvwxyzSTRING
|
||
abc defghijklmnopqrstuvwxyzSTRING
|
||
abcdef ghi jklmnopqrstuvwxyzSTRING
|
||
abcdefghijklmnopqrstuvwxyzSTRING
|
||
END
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
" Test from ':help v_b_<_example'
|
||
%d _
|
||
let lines =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call setline(1, lines)
|
||
exe "normal ggfo\<C-V>3j3l<.."
|
||
let expected =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
" Test from ':help v_b_>_example'
|
||
%d _
|
||
let lines =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call setline(1, lines)
|
||
exe "normal ggfo\<C-V>3j>.."
|
||
let expected =<< trim END
|
||
abcdefghijklmn opqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmn opqrstuvwxyz
|
||
END
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
" Test from ':help v_b_r_example'
|
||
%d _
|
||
let lines =<< trim END
|
||
abcdefghijklmnopqrstuvwxyz
|
||
abc defghijklmnopqrstuvwxyz
|
||
abcdef ghi jklmnopqrstuvwxyz
|
||
abcdefghijklmnopqrstuvwxyz
|
||
END
|
||
call setline(1, lines)
|
||
exe "normal ggfo\<C-V>5l3jrX"
|
||
let expected =<< trim END
|
||
abcdefghijklmnXXXXXXuvwxyz
|
||
abc XXXXXXhijklmnopqrstuvwxyz
|
||
abcdef ghi XXXXXX jklmnopqrstuvwxyz
|
||
abcdefghijklmnXXXXXXuvwxyz
|
||
END
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
bwipe!
|
||
set tabstop& shiftwidth&
|
||
endfunc
|
||
|
||
func Test_visual_force_motion_feedkeys()
|
||
onoremap <expr> i- execute('let g:mode = mode(1)')->slice(0, 0)
|
||
call feedkeys('dvi-', 'x')
|
||
call assert_equal('nov', g:mode)
|
||
call feedkeys('di-', 'x')
|
||
call assert_equal('no', g:mode)
|
||
ounmap i-
|
||
endfunc
|
||
|
||
" Test block-insert using cursor keys for movement
|
||
func Test_visual_block_insert_cursor_keys()
|
||
new
|
||
call append(0, ['aaaaaa', 'bbbbbb', 'cccccc', 'dddddd'])
|
||
call cursor(1, 1)
|
||
|
||
exe "norm! l\<C-V>jjjlllI\<Right>\<Right> \<Esc>"
|
||
call assert_equal(['aaa aaa', 'bbb bbb', 'ccc ccc', 'ddd ddd'],
|
||
\ getline(1, 4))
|
||
|
||
call deletebufline('', 1, '$')
|
||
call setline(1, ['xaaa', 'bbbb', 'cccc', 'dddd'])
|
||
call cursor(1, 1)
|
||
exe "norm! \<C-V>jjjI<>\<Left>p\<Esc>"
|
||
call assert_equal(['<p>xaaa', '<p>bbbb', '<p>cccc', '<p>dddd'],
|
||
\ getline(1, 4))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_block_create()
|
||
new
|
||
call append(0, '')
|
||
" Test for Visual block was created with the last <C-v>$
|
||
call setline(1, ['A23', '4567'])
|
||
call cursor(1, 1)
|
||
exe "norm! l\<C-V>j$Aab\<Esc>"
|
||
call assert_equal(['A23ab', '4567ab'], getline(1, 2))
|
||
|
||
" Test for Visual block was created with the middle <C-v>$ (1)
|
||
call deletebufline('', 1, '$')
|
||
call setline(1, ['B23', '4567'])
|
||
call cursor(1, 1)
|
||
exe "norm! l\<C-V>j$hAab\<Esc>"
|
||
call assert_equal(['B23 ab', '4567ab'], getline(1, 2))
|
||
|
||
" Test for Visual block was created with the middle <C-v>$ (2)
|
||
call deletebufline('', 1, '$')
|
||
call setline(1, ['C23', '4567'])
|
||
call cursor(1, 1)
|
||
exe "norm! l\<C-V>j$hhAab\<Esc>"
|
||
call assert_equal(['C23ab', '456ab7'], getline(1, 2))
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for Visual block insert when virtualedit=all
|
||
func Test_virtualedit_visual_block()
|
||
set ve=all
|
||
new
|
||
call append(0, ["\t\tline1", "\t\tline2", "\t\tline3"])
|
||
call cursor(1, 1)
|
||
exe "norm! 07l\<C-V>jjIx\<Esc>"
|
||
call assert_equal([" x \tline1",
|
||
\ " x \tline2",
|
||
\ " x \tline3"], getline(1, 3))
|
||
|
||
" Test for Visual block append when virtualedit=all
|
||
exe "norm! 012l\<C-v>jjAx\<Esc>"
|
||
call assert_equal([' x x line1',
|
||
\ ' x x line2',
|
||
\ ' x x line3'], getline(1, 3))
|
||
set ve=
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for changing case
|
||
func Test_visual_change_case()
|
||
new
|
||
" gUe must uppercase a whole word, also when ß changes to ẞ
|
||
exe "normal Gothe youtußeuu end\<Esc>Ypk0wgUe\r"
|
||
" gUfx must uppercase until x, inclusive.
|
||
exe "normal O- youßtußexu -\<Esc>0fogUfx\r"
|
||
" VU must uppercase a whole line
|
||
exe "normal YpkVU\r"
|
||
" same, when it's the last line in the buffer
|
||
exe "normal YPGi111\<Esc>VUddP\r"
|
||
" Uppercase two lines
|
||
exe "normal Oblah di\rdoh dut\<Esc>VkUj\r"
|
||
" Uppercase part of two lines
|
||
exe "normal ddppi333\<Esc>k0i222\<Esc>fyllvjfuUk"
|
||
call assert_equal(['the YOUTUẞEUU end', '- yOUẞTUẞEXu -',
|
||
\ 'THE YOUTUẞEUU END', '111THE YOUTUẞEUU END', 'BLAH DI', 'DOH DUT',
|
||
\ '222the yoUTUẞEUU END', '333THE YOUTUßeuu end'], getline(2, '$'))
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for Visual replace using Enter or NL
|
||
func Test_visual_replace_crnl()
|
||
new
|
||
exe "normal G3o123456789\e2k05l\<C-V>2jr\r"
|
||
exe "normal G3o98765\e2k02l\<C-V>2jr\<C-V>\r\n"
|
||
exe "normal G3o123456789\e2k05l\<C-V>2jr\n"
|
||
exe "normal G3o98765\e2k02l\<C-V>2jr\<C-V>\n"
|
||
call assert_equal(['12345', '789', '12345', '789', '12345', '789', "98\r65",
|
||
\ "98\r65", "98\r65", '12345', '789', '12345', '789', '12345', '789',
|
||
\ "98\n65", "98\n65", "98\n65"], getline(2, '$'))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_ve_block_curpos()
|
||
new
|
||
" Test cursor position. When ve=block and Visual block mode and $gj
|
||
call append(0, ['12345', '789'])
|
||
call cursor(1, 3)
|
||
set virtualedit=block
|
||
exe "norm! \<C-V>$gj\<Esc>"
|
||
call assert_equal([0, 2, 4, 0], getpos("'>"))
|
||
set virtualedit=
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for block_insert when replacing spaces in front of the a with tabs
|
||
func Test_block_insert_replace_tabs()
|
||
new
|
||
set ts=8 sts=4 sw=4
|
||
call append(0, ["#define BO_ALL\t 0x0001",
|
||
\ "#define BO_BS\t 0x0002",
|
||
\ "#define BO_CRSR\t 0x0004"])
|
||
call cursor(1, 1)
|
||
exe "norm! f0\<C-V>2jI\<tab>\<esc>"
|
||
call assert_equal([
|
||
\ "#define BO_ALL\t\t0x0001",
|
||
\ "#define BO_BS\t \t0x0002",
|
||
\ "#define BO_CRSR\t \t0x0004", ''], getline(1, '$'))
|
||
set ts& sts& sw&
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for * register in :
|
||
func Test_star_register()
|
||
call assert_fails('*bfirst', 'E16:')
|
||
new
|
||
call setline(1, ['foo', 'bar', 'baz', 'qux'])
|
||
exe "normal jVj\<ESC>"
|
||
*yank r
|
||
call assert_equal("bar\nbaz\n", @r)
|
||
|
||
delmarks < >
|
||
call assert_fails('*yank', 'E20:')
|
||
close!
|
||
endfunc
|
||
|
||
" Test for changing text in visual mode with 'exclusive' selection
|
||
func Test_exclusive_selection()
|
||
new
|
||
call setline(1, ['one', 'two'])
|
||
set selection=exclusive
|
||
call feedkeys("vwcabc", 'xt')
|
||
call assert_equal('abctwo', getline(1))
|
||
call setline(1, ["\tone"])
|
||
set virtualedit=all
|
||
call feedkeys('0v2lcl', 'xt')
|
||
call assert_equal('l one', getline(1))
|
||
set virtualedit&
|
||
set selection&
|
||
close!
|
||
endfunc
|
||
|
||
" Test for starting linewise visual with a count.
|
||
" This test needs to be run without any previous visual mode. Otherwise the
|
||
" count will use the count from the previous visual mode.
|
||
func Test_linewise_visual_with_count()
|
||
let after =<< trim [CODE]
|
||
call setline(1, ['one', 'two', 'three', 'four'])
|
||
norm! 3Vy
|
||
call assert_equal("one\ntwo\nthree\n", @")
|
||
call writefile(v:errors, 'Xtestout')
|
||
qall!
|
||
[CODE]
|
||
if RunVim([], after, '')
|
||
call assert_equal([], readfile('Xtestout'))
|
||
call delete('Xtestout')
|
||
endif
|
||
endfunc
|
||
|
||
" Test for starting characterwise visual with a count.
|
||
" This test needs to be run without any previous visual mode. Otherwise the
|
||
" count will use the count from the previous visual mode.
|
||
func Test_characterwise_visual_with_count()
|
||
let after =<< trim [CODE]
|
||
call setline(1, ['one two', 'three'])
|
||
norm! l5vy
|
||
call assert_equal("ne tw", @")
|
||
call writefile(v:errors, 'Xtestout')
|
||
qall!
|
||
[CODE]
|
||
if RunVim([], after, '')
|
||
call assert_equal([], readfile('Xtestout'))
|
||
call delete('Xtestout')
|
||
endif
|
||
endfunc
|
||
|
||
" Test for visually selecting an inner block (iB)
|
||
func Test_visual_inner_block()
|
||
new
|
||
call setline(1, ['one', '{', 'two', '{', 'three', '}', 'four', '}', 'five'])
|
||
call cursor(5, 1)
|
||
" visually select all the lines in the block and then execute iB
|
||
call feedkeys("ViB\<C-C>", 'xt')
|
||
call assert_equal([0, 5, 1, 0], getpos("'<"))
|
||
call assert_equal([0, 5, 6, 0], getpos("'>"))
|
||
" visually select two inner blocks
|
||
call feedkeys("ViBiB\<C-C>", 'xt')
|
||
call assert_equal([0, 3, 1, 0], getpos("'<"))
|
||
call assert_equal([0, 7, 5, 0], getpos("'>"))
|
||
" try to select non-existing inner block
|
||
call cursor(5, 1)
|
||
call assert_beeps('normal ViBiBiB')
|
||
" try to select an unclosed inner block
|
||
8,9d
|
||
call cursor(5, 1)
|
||
call assert_beeps('normal ViBiB')
|
||
close!
|
||
endfunc
|
||
|
||
func Test_visual_put_in_block()
|
||
new
|
||
call setline(1, ['xxxx', 'y∞yy', 'zzzz'])
|
||
normal 1G2yl
|
||
exe "normal 1G2l\<C-V>jjlp"
|
||
call assert_equal(['xxxx', 'y∞xx', 'zzxx'], getline(1, 3))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_put_in_block_using_zp()
|
||
new
|
||
" paste using zP
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ '/subdir',
|
||
\ '/longsubdir',
|
||
\ '/longlongsubdir'])
|
||
exe "normal! 5G\<c-v>2j$y"
|
||
norm! 1Gf;zP
|
||
call assert_equal(['/path/subdir;text', '/path/longsubdir;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
%d
|
||
" paste using zP
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ '/subdir',
|
||
\ '/longsubdir',
|
||
\ '/longlongsubdir'])
|
||
exe "normal! 5G\<c-v>2j$y"
|
||
norm! 1Gf;hzp
|
||
call assert_equal(['/path/subdir;text', '/path/longsubdir;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_put_in_block_using_zy_and_zp()
|
||
new
|
||
|
||
" Test 1) Paste using zp - after the cursor without trailing spaces
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ 'texttext /subdir columntext',
|
||
\ 'texttext /longsubdir columntext',
|
||
\ 'texttext /longlongsubdir columntext'])
|
||
exe "normal! 5G0f/\<c-v>2jezy"
|
||
norm! 1G0f;hzp
|
||
call assert_equal(['/path/subdir;text', '/path/longsubdir;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
|
||
" Test 2) Paste using zP - in front of the cursor without trailing spaces
|
||
%d
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ 'texttext /subdir columntext',
|
||
\ 'texttext /longsubdir columntext',
|
||
\ 'texttext /longlongsubdir columntext'])
|
||
exe "normal! 5G0f/\<c-v>2jezy"
|
||
norm! 1G0f;zP
|
||
call assert_equal(['/path/subdir;text', '/path/longsubdir;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
|
||
" Test 3) Paste using p - with trailing spaces
|
||
%d
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ 'texttext /subdir columntext',
|
||
\ 'texttext /longsubdir columntext',
|
||
\ 'texttext /longlongsubdir columntext'])
|
||
exe "normal! 5G0f/\<c-v>2jezy"
|
||
norm! 1G0f;hp
|
||
call assert_equal(['/path/subdir ;text', '/path/longsubdir ;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
|
||
" Test 4) Paste using P - with trailing spaces
|
||
%d
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ 'texttext /subdir columntext',
|
||
\ 'texttext /longsubdir columntext',
|
||
\ 'texttext /longlongsubdir columntext'])
|
||
exe "normal! 5G0f/\<c-v>2jezy"
|
||
norm! 1G0f;P
|
||
call assert_equal(['/path/subdir ;text', '/path/longsubdir ;text', '/path/longlongsubdir;text'], getline(1, 3))
|
||
|
||
" Test 5) Yank with spaces inside the block
|
||
%d
|
||
call setline(1, ['/path;text', '/path;text', '/path;text', '',
|
||
\ 'texttext /sub dir/ columntext',
|
||
\ 'texttext /lon gsubdir/ columntext',
|
||
\ 'texttext /lon glongsubdir/ columntext'])
|
||
exe "normal! 5G0f/\<c-v>2jf/zy"
|
||
norm! 1G0f;zP
|
||
call assert_equal(['/path/sub dir/;text', '/path/lon gsubdir/;text', '/path/lon glongsubdir/;text'], getline(1, 3))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_put_blockedit_zy_and_zp()
|
||
new
|
||
|
||
call setline(1, ['aa', 'bbbbb', 'ccc', '', 'XX', 'GGHHJ', 'RTZU'])
|
||
exe "normal! gg0\<c-v>2j$zy"
|
||
norm! 5gg0zP
|
||
call assert_equal(['aa', 'bbbbb', 'ccc', '', 'aaXX', 'bbbbbGGHHJ', 'cccRTZU'], getline(1, 7))
|
||
"
|
||
" now with blockmode editing
|
||
sil %d
|
||
:set ve=block
|
||
call setline(1, ['aa', 'bbbbb', 'ccc', '', 'XX', 'GGHHJ', 'RTZU'])
|
||
exe "normal! gg0\<c-v>2j$zy"
|
||
norm! 5gg0zP
|
||
call assert_equal(['aa', 'bbbbb', 'ccc', '', 'aaXX', 'bbbbbGGHHJ', 'cccRTZU'], getline(1, 7))
|
||
set ve&vim
|
||
bw!
|
||
endfunc
|
||
|
||
func Test_visual_block_yank_zy()
|
||
new
|
||
" this was reading before the start of the line
|
||
exe "norm o\<C-T>\<Esc>\<C-V>zy"
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_block_with_virtualedit()
|
||
CheckScreendump
|
||
|
||
let lines =<< trim END
|
||
call setline(1, ['aaaaaa', 'bbbb', 'cc'])
|
||
set virtualedit=block
|
||
normal G
|
||
END
|
||
call writefile(lines, 'XTest_block')
|
||
|
||
let buf = RunVimInTerminal('-S XTest_block', {'rows': 8, 'cols': 50})
|
||
call term_sendkeys(buf, "\<C-V>gg$")
|
||
call VerifyScreenDump(buf, 'Test_visual_block_with_virtualedit', {})
|
||
|
||
call term_sendkeys(buf, "\<Esc>gg\<C-V>G$")
|
||
call VerifyScreenDump(buf, 'Test_visual_block_with_virtualedit2', {})
|
||
|
||
" clean up
|
||
call term_sendkeys(buf, "\<Esc>")
|
||
call StopVimInTerminal(buf)
|
||
call delete('XTest_block')
|
||
endfunc
|
||
|
||
func Test_visual_block_ctrl_w_f()
|
||
" Empty block selected in new buffer should not result in an error.
|
||
au! BufNew foo sil norm f
|
||
edit foo
|
||
|
||
au! BufNew
|
||
endfunc
|
||
|
||
func Test_visual_block_append_invalid_char()
|
||
" this was going over the end of the line
|
||
set isprint=@,161-255
|
||
new
|
||
call setline(1, [' let xxx', 'xxxxx', 'xxxxxxxxxxx'])
|
||
exe "normal 0\<C-V>jjA-\<Esc>"
|
||
call assert_equal([' - let xxx', 'xxxxx -', 'xxxxxxxx-xxx'], getline(1, 3))
|
||
bwipe!
|
||
set isprint&
|
||
endfunc
|
||
|
||
func Test_visual_block_with_substitute()
|
||
" this was reading beyond the end of the line
|
||
new
|
||
norm a0)
|
||
sil! norm O
|
||
s/)
|
||
sil! norm
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_reselect_with_count()
|
||
enew
|
||
call setline(1, ['aaaaaa', '✗ bbbb', '✗ bbbb'])
|
||
exe "normal! 2Gw\<C-V>jed"
|
||
exe "normal! gg0lP"
|
||
call assert_equal(['abbbbaaaaa', '✗bbbb ', '✗ '], getline(1, '$'))
|
||
|
||
exe "normal! 1vr."
|
||
call assert_equal(['a....aaaaa', '✗.... ', '✗ '], getline(1, '$'))
|
||
|
||
bwipe!
|
||
|
||
" this was causing an illegal memory access
|
||
let lines =<< trim END
|
||
|
||
|
||
|
||
:
|
||
r<sfile>
|
||
exe "%norm e3\<c-v>kr\t"
|
||
:
|
||
|
||
:
|
||
END
|
||
call writefile(lines, 'XvisualReselect')
|
||
source XvisualReselect
|
||
|
||
bwipe!
|
||
call delete('XvisualReselect')
|
||
endfunc
|
||
|
||
func Test_visual_reselect_exclusive()
|
||
new
|
||
call setline(1, ['abcde', 'abcde'])
|
||
set selection=exclusive
|
||
normal 1G0viwd
|
||
normal 2G01vd
|
||
call assert_equal(['', ''], getline(1, 2))
|
||
|
||
set selection&
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_block_insert_round_off()
|
||
new
|
||
" The number of characters are tuned to fill a 4096 byte allocated block,
|
||
" so that valgrind reports going over the end.
|
||
call setline(1, ['xxxxx', repeat('0', 1350), "\t", repeat('x', 60)])
|
||
exe "normal gg0\<C-V>GI" .. repeat('0', 1320) .. "\<Esc>"
|
||
bwipe!
|
||
endfunc
|
||
|
||
" this was causing an ml_get error
|
||
func Test_visual_exchange_windows()
|
||
enew!
|
||
new
|
||
call setline(1, ['foo', 'bar'])
|
||
exe "normal G\<C-V>gg\<C-W>\<C-X>OO\<Esc>"
|
||
bwipe!
|
||
bwipe!
|
||
endfunc
|
||
|
||
" this was leaving the end of the Visual area beyond the end of a line
|
||
func Test_visual_ex_copy_line()
|
||
new
|
||
call setline(1, ["aaa", "bbbbbbbbbxbb"])
|
||
/x
|
||
exe "normal ggvjfxO"
|
||
t0
|
||
normal gNU
|
||
bwipe!
|
||
endfunc
|
||
|
||
" This was leaving the end of the Visual area beyond the end of a line.
|
||
" Set 'undolevels' to start a new undo block.
|
||
func Test_visual_undo_deletes_last_line()
|
||
new
|
||
call setline(1, ["aaa", "ccc", "dyd"])
|
||
set undolevels=100
|
||
exe "normal obbbbbbbbbxbb\<Esc>"
|
||
set undolevels=100
|
||
/y
|
||
exe "normal ggvjfxO"
|
||
undo
|
||
normal gNU
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_paste()
|
||
new
|
||
|
||
" v_p overwrites unnamed register.
|
||
call setline(1, ['xxxx'])
|
||
call setreg('"', 'foo')
|
||
call setreg('-', 'bar')
|
||
normal gg0vp
|
||
call assert_equal('x', @")
|
||
call assert_equal('x', @-)
|
||
call assert_equal('fooxxx', getline(1))
|
||
normal $vp
|
||
call assert_equal('x', @")
|
||
call assert_equal('x', @-)
|
||
call assert_equal('fooxxx', getline(1))
|
||
" Test with a different register as unnamed register.
|
||
call setline(2, ['baz'])
|
||
normal 2gg0"rD
|
||
call assert_equal('baz', @")
|
||
normal gg0vp
|
||
call assert_equal('f', @")
|
||
call assert_equal('f', @-)
|
||
call assert_equal('bazooxxx', getline(1))
|
||
normal $vp
|
||
call assert_equal('x', @")
|
||
call assert_equal('x', @-)
|
||
call assert_equal('bazooxxf', getline(1))
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_paste_clipboard()
|
||
CheckFeature clipboard_working
|
||
|
||
if has('gui')
|
||
" auto select feature breaks tests
|
||
set guioptions-=a
|
||
endif
|
||
|
||
" v_P does not overwrite unnamed register.
|
||
call setline(1, ['xxxx'])
|
||
call setreg('"', 'foo')
|
||
call setreg('-', 'bar')
|
||
normal gg0vP
|
||
call assert_equal('foo', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('fooxxx', getline(1))
|
||
normal $vP
|
||
call assert_equal('foo', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('fooxxfoo', getline(1))
|
||
" Test with a different register as unnamed register.
|
||
call setline(2, ['baz'])
|
||
normal 2gg0"rD
|
||
call assert_equal('baz', @")
|
||
normal gg0vP
|
||
call assert_equal('baz', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('bazooxxfoo', getline(1))
|
||
normal $vP
|
||
call assert_equal('baz', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('bazooxxfobaz', getline(1))
|
||
|
||
" Test for unnamed clipboard
|
||
set clipboard=unnamed
|
||
call setline(1, ['xxxx'])
|
||
call setreg('"', 'foo')
|
||
call setreg('-', 'bar')
|
||
call setreg('*', 'baz')
|
||
normal gg0vP
|
||
call assert_equal('foo', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('baz', @*)
|
||
call assert_equal('bazxxx', getline(1))
|
||
|
||
" Test for unnamedplus clipboard
|
||
if has('unnamedplus')
|
||
set clipboard=unnamedplus
|
||
call setline(1, ['xxxx'])
|
||
call setreg('"', 'foo')
|
||
call setreg('-', 'bar')
|
||
call setreg('+', 'baz')
|
||
normal gg0vP
|
||
call assert_equal('foo', @")
|
||
call assert_equal('bar', @-)
|
||
call assert_equal('baz', @+)
|
||
call assert_equal('bazxxx', getline(1))
|
||
endif
|
||
|
||
set clipboard&
|
||
if has('gui')
|
||
set guioptions&
|
||
endif
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_area_adjusted_when_hiding()
|
||
" The Visual area ended after the end of the line after :hide
|
||
call setline(1, 'xxx')
|
||
vsplit Xfile
|
||
call setline(1, 'xxxxxxxx')
|
||
norm! $o
|
||
hid
|
||
norm! zW
|
||
bwipe!
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_switch_buffer_ends_visual_mode()
|
||
enew
|
||
call setline(1, 'foo')
|
||
set hidden
|
||
set virtualedit=all
|
||
let buf1 = bufnr()
|
||
enew
|
||
let buf2 = bufnr()
|
||
call setline(1, ['', '', '', ''])
|
||
call cursor(4, 5)
|
||
call feedkeys("\<C-V>3k4h", 'xt')
|
||
exe 'buffer' buf1
|
||
call assert_equal('n', mode())
|
||
|
||
set nohidden
|
||
set virtualedit=
|
||
bwipe!
|
||
exe 'bwipe!' buf2
|
||
endfunc
|
||
|
||
" Check fix for the heap-based buffer overflow bug found in the function
|
||
" utfc_ptr2len and reported at
|
||
" https://huntr.dev/bounties/ae933869-a1ec-402a-bbea-d51764c6618e
|
||
func Test_heap_buffer_overflow()
|
||
enew
|
||
set updatecount=0
|
||
|
||
norm R0
|
||
split other
|
||
norm R000
|
||
exe "norm \<C-V>l"
|
||
ball
|
||
call assert_equal(getpos("."), getpos("v"))
|
||
call assert_equal('n', mode())
|
||
norm zW
|
||
|
||
%bwipe!
|
||
set updatecount&
|
||
endfunc
|
||
|
||
" Test Visual highlight with cursor at end of screen line and 'showbreak'
|
||
func Test_visual_hl_with_showbreak()
|
||
CheckScreendump
|
||
|
||
let lines =<< trim END
|
||
setlocal showbreak=+
|
||
call setline(1, repeat('a', &columns + 10))
|
||
normal g$v4lo
|
||
END
|
||
call writefile(lines, 'XTest_visual_sbr', 'D')
|
||
|
||
let buf = RunVimInTerminal('-S XTest_visual_sbr', {'rows': 6, 'cols': 50})
|
||
call VerifyScreenDump(buf, 'Test_visual_hl_with_showbreak', {})
|
||
|
||
" clean up
|
||
call term_sendkeys(buf, "\<Esc>")
|
||
call StopVimInTerminal(buf)
|
||
endfunc
|
||
|
||
func Test_Visual_r_CTRL_C()
|
||
new
|
||
" visual r_cmd
|
||
call setline(1, [' '])
|
||
call feedkeys("\<c-v>$r\<c-c>", 'tx')
|
||
call assert_equal([''], getline(1, 1))
|
||
|
||
" visual gr_cmd
|
||
call setline(1, [' '])
|
||
call feedkeys("\<c-v>$gr\<c-c>", 'tx')
|
||
call assert_equal([''], getline(1, 1))
|
||
bw!
|
||
endfunc
|
||
|
||
func Test_visual_drag_out_of_window()
|
||
rightbelow vnew
|
||
call setline(1, '123456789')
|
||
set mouse=a
|
||
func ClickExpr(off)
|
||
call Ntest_setmouse(1, getwininfo(win_getid())[0].wincol + a:off)
|
||
return "\<LeftMouse>"
|
||
endfunc
|
||
func DragExpr(off)
|
||
call Ntest_setmouse(1, getwininfo(win_getid())[0].wincol + a:off)
|
||
return "\<LeftDrag>"
|
||
endfunc
|
||
|
||
nnoremap <expr> <F2> ClickExpr(5)
|
||
nnoremap <expr> <F3> DragExpr(-1)
|
||
redraw
|
||
call feedkeys("\<F2>\<F3>\<LeftRelease>", 'tx')
|
||
call assert_equal([1, 6], [col('.'), col('v')])
|
||
call feedkeys("\<Esc>", 'tx')
|
||
|
||
nnoremap <expr> <F2> ClickExpr(6)
|
||
nnoremap <expr> <F3> DragExpr(-2)
|
||
redraw
|
||
call feedkeys("\<F2>\<F3>\<LeftRelease>", 'tx')
|
||
call assert_equal([1, 7], [col('.'), col('v')])
|
||
call feedkeys("\<Esc>", 'tx')
|
||
|
||
nunmap <F2>
|
||
nunmap <F3>
|
||
delfunc ClickExpr
|
||
delfunc DragExpr
|
||
set mouse&
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_substitute_visual()
|
||
new
|
||
call setline(1, ['one', 'two', 'three'])
|
||
call feedkeys("Gk\<C-V>j$:s/\\%V\\_.*\\%V/foobar\<CR>", 'tx')
|
||
call assert_equal(['one', 'foobar'], getline(1, '$'))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_virtualedit_exclusive_selection()
|
||
new
|
||
set virtualedit=all selection=exclusive
|
||
|
||
call setline(1, "a\tb")
|
||
normal! 0v8ly
|
||
call assert_equal("a\t", getreg('"'))
|
||
normal! 0v6ly
|
||
call assert_equal('a ', getreg('"'))
|
||
normal! 06lv2ly
|
||
call assert_equal(' ', getreg('"'))
|
||
|
||
set virtualedit& selection&
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_getregion()
|
||
let lines =<< trim END
|
||
new
|
||
|
||
call setline(1, ['one', 'two', 'three'])
|
||
|
||
#" Visual mode
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>vjl", 'tx')
|
||
|
||
call assert_equal(['one', 'tw'],
|
||
\ 'v'->getpos()->getregion(getpos('.')))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 2, 0]]
|
||
\ ],
|
||
\ 'v'->getpos()->getregionpos(getpos('.')))
|
||
|
||
call assert_equal(['one', 'tw'],
|
||
\ '.'->getpos()->getregion(getpos('v')))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 2, 0]]
|
||
\ ],
|
||
\ '.'->getpos()->getregionpos(getpos('v')))
|
||
|
||
call assert_equal(['o'],
|
||
\ 'v'->getpos()->getregion(getpos('v')))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 1, 0]],
|
||
\ ],
|
||
\ 'v'->getpos()->getregionpos(getpos('v')))
|
||
|
||
call assert_equal(['w'],
|
||
\ '.'->getpos()->getregion(getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 2, 0]],
|
||
\ ],
|
||
\ '.'->getpos()->getregionpos(getpos('.'), {'type': 'v' }))
|
||
|
||
call assert_equal(['one', 'two'],
|
||
\ getpos('.')->getregion(getpos('v'), {'type': 'V' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ ],
|
||
\ getpos('.')->getregionpos(getpos('v'), {'type': 'V' }))
|
||
|
||
call assert_equal(['on', 'tw'],
|
||
\ getpos('.')->getregion(getpos('v'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 2, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 2, 0]],
|
||
\ ],
|
||
\ getpos('.')->getregionpos(getpos('v'), {'type': "\<C-v>" }))
|
||
|
||
#" Line visual mode
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>Vl", 'tx')
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'V' }))
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('.'), getpos('v'), {'type': 'V' }))
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('v'), getpos('v'), {'type': 'V' }))
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('.'), getpos('.'), {'type': 'V' }))
|
||
call assert_equal(['on'],
|
||
\ getpos('.')->getregion(getpos('v'), {'type': 'v' }))
|
||
call assert_equal(['on'],
|
||
\ getpos('.')->getregion(getpos('v'), {'type': "\<C-v>" }))
|
||
|
||
#" Block visual mode
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>\<C-v>ll", 'tx')
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal(['one'],
|
||
\ getregion(getpos('.'), getpos('v'), {'type': "\<C-v>" }))
|
||
call assert_equal(['o'],
|
||
\ getregion(getpos('v'), getpos('v'), {'type': "\<C-v>" }))
|
||
call assert_equal(['e'],
|
||
\ getregion(getpos('.'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal(['one'],
|
||
\ '.'->getpos()->getregion(getpos('v'), {'type': 'V' }))
|
||
call assert_equal(['one'],
|
||
\ '.'->getpos()->getregion(getpos('v'), {'type': 'v' }))
|
||
|
||
#" Using Marks
|
||
call setpos("'a", [0, 2, 3, 0])
|
||
call cursor(1, 1)
|
||
call assert_equal(['one', 'two'],
|
||
\ "'a"->getpos()->getregion(getpos('.'), {'type': 'v' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ "."->getpos()->getregion(getpos("'a"), {'type': 'v' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ "."->getpos()->getregion(getpos("'a"), {'type': 'V' }))
|
||
call assert_equal(['two'],
|
||
\ "'a"->getpos()->getregion(getpos("'a"), {'type': 'V' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ "."->getpos()->getregion(getpos("'a"), {'type': "\<c-v>" }))
|
||
call feedkeys("\<ESC>jVj\<ESC>", 'tx')
|
||
call assert_equal(['two', 'three'], getregion(getpos("'<"), getpos("'>")))
|
||
call assert_equal(['two', 'three'], getregion(getpos("'>"), getpos("'<")))
|
||
|
||
#" Using List
|
||
call cursor(1, 1)
|
||
call assert_equal(['one', 'two'],
|
||
\ [0, 2, 3, 0]->getregion(getpos('.'), {'type': 'v' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ '.'->getpos()->getregion([0, 2, 3, 0], {'type': 'v' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ '.'->getpos()->getregion([0, 2, 3, 0], {'type': 'V' }))
|
||
call assert_equal(['two'],
|
||
\ [0, 2, 3, 0]->getregion([0, 2, 3, 0], {'type': 'V' }))
|
||
call assert_equal(['one', 'two'],
|
||
\ '.'->getpos()->getregion([0, 2, 3, 0], {'type': "\<c-v>" }))
|
||
|
||
#" Multiline with line visual mode
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>Vjj", 'tx')
|
||
call assert_equal(['one', 'two', 'three'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'V' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'V' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 6, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'V', 'eol': v:true }))
|
||
|
||
#" Multiline with block visual mode
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>\<C-v>jj", 'tx')
|
||
call assert_equal(['o', 't', 't'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 1, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 1, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 1, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>\<C-v>jj$", 'tx')
|
||
call assert_equal(['one', 'two', 'three'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", 'eol': v:true }))
|
||
|
||
#" 'virtualedit'
|
||
set virtualedit=all
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>\<C-v>10ljj$", 'tx')
|
||
call assert_equal(['one ', 'two ', 'three '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 4, 3]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 3]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 6, 1]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", 'eol': v:true }))
|
||
|
||
call cursor(3, 5)
|
||
call feedkeys("\<ESC>\<C-v>hkk", 'tx')
|
||
call assert_equal([' ', ' ', 'ee'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 0, 0], [bufnr('%'), 1, 0, 0]],
|
||
\ [[bufnr('%'), 2, 0, 0], [bufnr('%'), 2, 0, 0]],
|
||
\ [[bufnr('%'), 3, 4, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 4, 0], [bufnr('%'), 1, 4, 2]],
|
||
\ [[bufnr('%'), 2, 4, 0], [bufnr('%'), 2, 4, 2]],
|
||
\ [[bufnr('%'), 3, 4, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", 'eol': v:true }))
|
||
|
||
call cursor(3, 5)
|
||
call feedkeys("\<ESC>\<C-v>kk", 'tx')
|
||
call assert_equal([' ', ' ', 'e'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 0, 0], [bufnr('%'), 1, 0, 0]],
|
||
\ [[bufnr('%'), 2, 0, 0], [bufnr('%'), 2, 0, 0]],
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 4, 1], [bufnr('%'), 1, 4, 2]],
|
||
\ [[bufnr('%'), 2, 4, 1], [bufnr('%'), 2, 4, 2]],
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", 'eol': v:true }))
|
||
|
||
call cursor(1, 3)
|
||
call feedkeys("\<ESC>vjj4l", 'tx')
|
||
call assert_equal(['e', 'two', 'three '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 3, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 3, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 6, 2]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', 'eol': v:true }))
|
||
|
||
call cursor(1, 3)
|
||
call feedkeys("\<ESC>lvjj3l", 'tx')
|
||
call assert_equal(['', 'two', 'three '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 0, 0], [bufnr('%'), 1, 0, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 4, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 6, 2]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', 'eol': v:true }))
|
||
|
||
call cursor(3, 5)
|
||
call feedkeys("\<ESC>v3l", 'tx')
|
||
call assert_equal(['e '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 6, 3]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', 'eol': v:true }))
|
||
|
||
call cursor(3, 5)
|
||
call feedkeys("\<ESC>lv3l", 'tx')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 6, 0], [bufnr('%'), 3, 6, 4]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', 'eol': v:true }))
|
||
|
||
call cursor(3, 5)
|
||
call feedkeys("\<ESC>3lv3l", 'tx')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 3, 6, 2], [bufnr('%'), 3, 6, 6]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', 'eol': v:true }))
|
||
|
||
set virtualedit&
|
||
|
||
#" using wrong types for positions
|
||
call cursor(1, 1)
|
||
call feedkeys("\<ESC>vjj$", 'tx')
|
||
call assert_fails("call getregion(1, 2)", 'E1211:')
|
||
call assert_fails("call getregion(getpos('.'), {})", 'E1211:')
|
||
call assert_fails(':echo "."->getpos()->getregion("$", [])', 'E1211:')
|
||
call assert_fails("call getregionpos(1, 2)", 'E1211:')
|
||
call assert_fails("call getregionpos(getpos('.'), {})", 'E1211:')
|
||
call assert_fails(':echo "."->getpos()->getregionpos("$", [])', 'E1211:')
|
||
|
||
#" using invalid value for "type"
|
||
call assert_fails("call getregion(getpos('.'), getpos('.'), {'type': '' })", 'E475:')
|
||
call assert_fails("call getregionpos(getpos('.'), getpos('.'), {'type': '' })", 'E475:')
|
||
call assert_fails("call getregion(getpos('.'), getpos('.'), {'type': 'v0' })", 'E475:')
|
||
call assert_fails("call getregionpos(getpos('.'), getpos('.'), {'type': 'v0' })", 'E475:')
|
||
call assert_fails("call getregion(getpos('.'), getpos('.'), {'type': 'V0' })", 'E475:')
|
||
call assert_fails("call getregionpos(getpos('.'), getpos('.'), {'type': 'V0' })", 'E475:')
|
||
call assert_fails("call getregion(getpos('.'), getpos('.'), {'type': '\<C-v>0' })", 'E475:')
|
||
call assert_fails("call getregionpos(getpos('.'), getpos('.'), {'type': '\<C-v>0' })", 'E475:')
|
||
call assert_fails("call getregion(getpos('.'), getpos('.'), {'type': '\<C-v>1:' })", 'E475:')
|
||
call assert_fails("call getregionpos(getpos('.'), getpos('.'), {'type': '\<C-v>1:' })", 'E475:')
|
||
|
||
#" using a mark from another buffer to current buffer
|
||
new
|
||
LET g:buf = bufnr()
|
||
call setline(1, range(10))
|
||
normal! GmA
|
||
wincmd p
|
||
call assert_equal([g:buf, 10, 1, 0], getpos("'A"))
|
||
call assert_equal([], getregion(getpos('.'), getpos("'A"), {'type': 'v' }))
|
||
call assert_equal([], getregion(getpos("'A"), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([], getregionpos(getpos('.'), getpos("'A"), {'type': 'v' }))
|
||
call assert_equal([], getregionpos(getpos("'A"), getpos('.'), {'type': 'v' }))
|
||
|
||
#" using two marks from another buffer
|
||
wincmd p
|
||
normal! GmB
|
||
wincmd p
|
||
call assert_equal([g:buf, 10, 1, 0], getpos("'B"))
|
||
call assert_equal(['9'],
|
||
\ getregion(getpos("'B"), getpos("'A"), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[g:buf, 10, 1, 0], [g:buf, 10, 1, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos("'B"), getpos("'A"), {'type': 'v' }))
|
||
|
||
#" using two positions from another buffer
|
||
for type in ['v', 'V', "\<C-V>"]
|
||
for exclusive in [v:false, v:true]
|
||
call assert_equal(range(10)->mapnew('string(v:val)'),
|
||
\ getregion([g:buf, 1, 1, 0], [g:buf, 10, 2, 0],
|
||
\ {'type': type, 'exclusive': exclusive }))
|
||
call assert_equal(range(10)->mapnew('string(v:val)'),
|
||
\ getregion([g:buf, 10, 2, 0], [g:buf, 1, 1, 0],
|
||
\ {'type': type, 'exclusive': exclusive }))
|
||
call assert_equal(range(1, 10)->mapnew('repeat([[g:buf, v:val, 1, 0]], 2)'),
|
||
\ getregionpos([g:buf, 1, 1, 0], [g:buf, 10, 2, 0],
|
||
\ {'type': type, 'exclusive': exclusive }))
|
||
call assert_equal(range(1, 10)->mapnew('repeat([[g:buf, v:val, 1, 0]], 2)'),
|
||
\ getregionpos([g:buf, 10, 2, 0], [g:buf, 1, 1, 0],
|
||
\ {'type': type, 'exclusive': exclusive }))
|
||
endfor
|
||
endfor
|
||
|
||
#" using invalid positions in buffer
|
||
call assert_fails('call getregion([g:buf, 0, 1, 0], [g:buf, 10, 2, 0])', 'E966:')
|
||
call assert_fails('call getregion([g:buf, 10, 2, 0], [g:buf, 0, 1, 0])', 'E966:')
|
||
call assert_fails('call getregion([g:buf, 1, 1, 0], [g:buf, 11, 2, 0])', 'E966:')
|
||
call assert_fails('call getregion([g:buf, 11, 2, 0], [g:buf, 1, 1, 0])', 'E966:')
|
||
call assert_fails('call getregion([g:buf, 1, 1, 0], [g:buf, 10, 0, 0])', 'E964:')
|
||
call assert_fails('call getregion([g:buf, 10, 0, 0], [g:buf, 1, 1, 0])', 'E964:')
|
||
call assert_fails('call getregion([g:buf, 1, 1, 0], [g:buf, 10, 3, 0])', 'E964:')
|
||
call assert_fails('call getregion([g:buf, 10, 3, 0], [g:buf, 1, 1, 0])', 'E964:')
|
||
call assert_fails('call getregion([g:buf, 1, 0, 0], [g:buf, 1, 1, 0])', 'E964:')
|
||
call assert_fails('call getregion([g:buf, 1, 1, 0], [g:buf, 1, 0, 0])', 'E964:')
|
||
|
||
#" using invalid buffer
|
||
call assert_fails('call getregion([10000, 10, 1, 0], [10000, 10, 1, 0])', 'E681:')
|
||
|
||
exe $':{g:buf}bwipe!'
|
||
unlet g:buf
|
||
bwipe!
|
||
END
|
||
call CheckLegacyAndVim9Success(lines)
|
||
|
||
let lines =<< trim END
|
||
#" Selection in starts or ends in the middle of a multibyte character
|
||
new
|
||
call setline(1, [
|
||
\ "abcdefghijk\u00ab",
|
||
\ "\U0001f1e6\u00ab\U0001f1e7\u00ab\U0001f1e8\u00ab\U0001f1e9",
|
||
\ "1234567890"
|
||
\ ])
|
||
|
||
call cursor(1, 3)
|
||
call feedkeys("\<Esc>\<C-v>ljj", 'xt')
|
||
call assert_equal(['cd', "\u00ab ", '34'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 3, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 5, 0], [bufnr('%'), 2, 7, 1]],
|
||
\ [[bufnr('%'), 3, 3, 0], [bufnr('%'), 3, 4, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 4)
|
||
call feedkeys("\<Esc>\<C-v>ljj", 'xt')
|
||
call assert_equal(['de', "\U0001f1e7", '45'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 4, 0], [bufnr('%'), 1, 5, 0]],
|
||
\ [[bufnr('%'), 2, 7, 0], [bufnr('%'), 2, 10, 0]],
|
||
\ [[bufnr('%'), 3, 4, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 5)
|
||
call feedkeys("\<Esc>\<C-v>jj", 'xt')
|
||
call assert_equal(['e', ' ', '5'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 5, 0], [bufnr('%'), 1, 5, 0]],
|
||
\ [[bufnr('%'), 2, 7, 1], [bufnr('%'), 2, 7, 2]],
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal(['efghijk«', '🇦«🇧«🇨«🇩', '12345'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 5, 0], [bufnr('%'), 1, 13, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 22, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 5, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 5)
|
||
call feedkeys("\<Esc>\<C-v>5l2j", 'xt')
|
||
call assert_equal(['efghij', ' «🇨« ', '567890'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 5, 0], [bufnr('%'), 1, 10, 0]],
|
||
\ [[bufnr('%'), 2, 7, 1], [bufnr('%'), 2, 19, 1]],
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 10, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 4)
|
||
call feedkeys("\<Esc>\<C-v>02j", 'xt')
|
||
call assert_equal(['abcd', '🇦« ', '1234'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 7, 1]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 4, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
#" characterwise selection with multibyte chars
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>vj", 'xt')
|
||
call assert_equal(['abcdefghijk«', "\U0001f1e6"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 13, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
set selection=exclusive
|
||
call feedkeys('l', 'xt')
|
||
call assert_equal(['abcdefghijk«', "\U0001f1e6"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 13, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 4, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
#" marks on multibyte chars
|
||
call setpos("'a", [0, 1, 11, 0])
|
||
call setpos("'b", [0, 2, 16, 0])
|
||
call setpos("'c", [0, 2, 0, 0])
|
||
call cursor(1, 1)
|
||
|
||
call assert_equal(['ghijk', '🇨«🇩'],
|
||
\ getregion(getpos("'a"), getpos("'b"), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 7, 0], [bufnr('%'), 1, 11, 0]],
|
||
\ [[bufnr('%'), 2, 13, 0], [bufnr('%'), 2, 22, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos("'a"), getpos("'b"), {'type': "\<C-v>" }))
|
||
|
||
call assert_equal(['k«', '🇦«🇧«🇨'],
|
||
\ getregion(getpos("'a"), getpos("'b"), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 11, 0], [bufnr('%'), 1, 13, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 16, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos("'a"), getpos("'b"), {'type': 'v' }))
|
||
|
||
call assert_equal(['k«'],
|
||
\ getregion(getpos("'a"), getpos("'c"), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 11, 0], [bufnr('%'), 1, 13, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos("'a"), getpos("'c"), {'type': 'v' }))
|
||
|
||
#" use inclusive selection, although 'selection' is exclusive
|
||
call setpos("'a", [0, 1, 11, 0])
|
||
call setpos("'b", [0, 1, 1, 0])
|
||
call assert_equal(['abcdefghijk'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': "\<c-v>", 'exclusive': v:false }))
|
||
call assert_equal(['abcdefghij'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': "\<c-v>", 'exclusive': v:true }))
|
||
call assert_equal(['abcdefghijk'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': 'v', 'exclusive': 0 }))
|
||
call assert_equal(['abcdefghij'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': 'v', 'exclusive': 1 }))
|
||
call assert_equal(['abcdefghijk«'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': 'V', 'exclusive': 0 }))
|
||
call assert_equal(['abcdefghijk«'],
|
||
\ getregion(getpos("'a"), getpos("'b"),
|
||
\ {'type': 'V', 'exclusive': 1 }))
|
||
|
||
set selection&
|
||
bwipe!
|
||
END
|
||
call CheckLegacyAndVim9Success(lines)
|
||
|
||
let lines =<< trim END
|
||
#" Exclusive selection
|
||
new
|
||
set selection=exclusive
|
||
call setline(1, ["a\tc", "x\tz", '', ''])
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v2l", 'xt')
|
||
call assert_equal(["a\t"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v$G", 'xt')
|
||
call assert_equal(["a\tc", "x\tz", ''],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v$j", 'xt')
|
||
call assert_equal(["a\tc", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>\<C-v>$j", 'xt')
|
||
call assert_equal(["a\tc", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>\<C-v>$G", 'xt')
|
||
call assert_equal(["a", "x", '', ''],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>wv2j", 'xt')
|
||
call assert_equal(["c", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
set selection&
|
||
bwipe!
|
||
|
||
#" Exclusive selection 2
|
||
new
|
||
call setline(1, ["a\tc", "x\tz", '', ''])
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v2l", 'xt')
|
||
call assert_equal(["a\t"],
|
||
\ getregion(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 2, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v$G", 'xt')
|
||
call assert_equal(["a\tc", "x\tz", ''],
|
||
\ getregion(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v$j", 'xt')
|
||
call assert_equal(["a\tc", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>\<C-v>$j", 'xt')
|
||
call assert_equal(["a\tc", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'),
|
||
\ {'exclusive': v:true, 'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'exclusive': v:true, 'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>\<C-v>$G", 'xt')
|
||
call assert_equal(["a", "x", '', ''],
|
||
\ getregion(getpos('v'), getpos('.'),
|
||
\ {'exclusive': v:true, 'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 1, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 1, 0]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ [[bufnr('%'), 4, 0, 0], [bufnr('%'), 4, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'exclusive': v:true, 'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>wv2j", 'xt')
|
||
call assert_equal(["c", "x\tz"],
|
||
\ getregion(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 3, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'exclusive': v:true }))
|
||
|
||
#" 'virtualedit' with exclusive selection
|
||
set selection=exclusive
|
||
set virtualedit=all
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>vj", 'xt')
|
||
call assert_equal(["a\tc"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v8l", 'xt')
|
||
call assert_equal(["a\t"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 2, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v6l", 'xt')
|
||
call assert_equal(['a '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 2, 5]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>6lv2l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 5], [bufnr('%'), 1, 2, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>lv2l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 2]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>2lv2l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 3]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call feedkeys('j', 'xt')
|
||
call assert_equal([' c', 'x '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 2, 3]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>6l\<C-v>2lj", 'xt')
|
||
call assert_equal([' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 5], [bufnr('%'), 1, 2, 7]],
|
||
\ [[bufnr('%'), 2, 2, 5], [bufnr('%'), 2, 2, 7]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>l\<C-v>2l2j", 'xt')
|
||
call assert_equal([' ', ' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 2]],
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 2, 2]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 2]],
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 2, 2]],
|
||
\ [[bufnr('%'), 3, 1, 1], [bufnr('%'), 3, 1, 3]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", "eol": v:true }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>2l\<C-v>2l2j", 'xt')
|
||
call assert_equal([' ', ' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 3]],
|
||
\ [[bufnr('%'), 2, 2, 1], [bufnr('%'), 2, 2, 3]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 3]],
|
||
\ [[bufnr('%'), 2, 2, 1], [bufnr('%'), 2, 2, 3]],
|
||
\ [[bufnr('%'), 3, 1, 2], [bufnr('%'), 3, 1, 4]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", "eol": v:true }))
|
||
|
||
#" 'virtualedit' with inclusive selection
|
||
set selection&
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>vj", 'xt')
|
||
call assert_equal(["a\tc", 'x'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 1, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v8l", 'xt')
|
||
call assert_equal(["a\tc"],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>v6l", 'xt')
|
||
call assert_equal(['a '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 2, 6]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>6lv2l", 'xt')
|
||
call assert_equal([' c'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 5], [bufnr('%'), 1, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>lv2l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 3]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>2lv2l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 4]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call feedkeys('j', 'xt')
|
||
call assert_equal([' c', 'x '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 2, 4]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>6l\<C-v>2lj", 'xt')
|
||
call assert_equal([' c', ' z'],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 5], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 2, 5], [bufnr('%'), 2, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>l\<C-v>2l2j", 'xt')
|
||
call assert_equal([' ', ' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 3]],
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 2, 3]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 2, 3]],
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 2, 3]],
|
||
\ [[bufnr('%'), 3, 1, 1], [bufnr('%'), 3, 1, 4]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", "eol": v:true }))
|
||
|
||
call cursor(1, 1)
|
||
call feedkeys("\<Esc>2l\<C-v>2l2j", 'xt')
|
||
call assert_equal([' ', ' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 4]],
|
||
\ [[bufnr('%'), 2, 2, 1], [bufnr('%'), 2, 2, 4]],
|
||
\ [[bufnr('%'), 3, 0, 0], [bufnr('%'), 3, 0, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 2, 1], [bufnr('%'), 1, 2, 4]],
|
||
\ [[bufnr('%'), 2, 2, 1], [bufnr('%'), 2, 2, 4]],
|
||
\ [[bufnr('%'), 3, 1, 2], [bufnr('%'), 3, 1, 5]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", "eol": v:true }))
|
||
|
||
set virtualedit&
|
||
bwipe!
|
||
END
|
||
call CheckLegacyAndVim9Success(lines)
|
||
|
||
let lines =<< trim END
|
||
#" 'virtualedit' with TABs at end of line
|
||
new
|
||
set virtualedit=all
|
||
call setline(1, ["\t", "a\t", "aa\t"])
|
||
|
||
call feedkeys("gg06l\<C-v>3l2j", 'xt')
|
||
call assert_equal([' ', ' ', ' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 6], [bufnr('%'), 1, 1, 0]],
|
||
\ [[bufnr('%'), 2, 2, 5], [bufnr('%'), 2, 2, 0]],
|
||
\ [[bufnr('%'), 3, 3, 4], [bufnr('%'), 3, 3, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': "\<C-v>" }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 6], [bufnr('%'), 1, 2, 2]],
|
||
\ [[bufnr('%'), 2, 2, 5], [bufnr('%'), 2, 3, 2]],
|
||
\ [[bufnr('%'), 3, 3, 4], [bufnr('%'), 3, 4, 2]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': "\<C-v>", "eol": v:true }))
|
||
|
||
call feedkeys("gg06lv3l", 'xt')
|
||
call assert_equal([' '],
|
||
\ getregion(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 6], [bufnr('%'), 1, 1, 0]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'), {'type': 'v' }))
|
||
call assert_equal([
|
||
\ [[bufnr('%'), 1, 1, 6], [bufnr('%'), 1, 2, 2]],
|
||
\ ],
|
||
\ getregionpos(getpos('v'), getpos('.'),
|
||
\ {'type': 'v', "eol": v:true }))
|
||
|
||
set virtualedit&
|
||
bwipe!
|
||
END
|
||
call CheckLegacyAndVim9Success(lines)
|
||
endfunc
|
||
|
||
func Test_getregion_invalid_buf()
|
||
new
|
||
help
|
||
call cursor(5, 7)
|
||
norm! mA
|
||
call cursor(5, 18)
|
||
norm! mB
|
||
call assert_equal(['Move around:'], getregion(getpos("'A"), getpos("'B")))
|
||
" close the help window
|
||
q
|
||
call assert_fails("call getregion(getpos(\"'A\"), getpos(\"'B\"))", 'E681:')
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_getregion_after_yank()
|
||
func! Check_Results(type)
|
||
call assert_equal(g:expected_region,
|
||
\ getregion(getpos("'["), getpos("']"), #{ type: a:type }))
|
||
call assert_equal(g:expected_regionpos,
|
||
\ getregionpos(getpos("'["), getpos("']"), #{ type: a:type }))
|
||
call assert_equal(g:expected_region,
|
||
\ getregion(getpos("']"), getpos("'["), #{ type: a:type }))
|
||
call assert_equal(g:expected_regionpos,
|
||
\ getregionpos(getpos("']"), getpos("'["), #{ type: a:type }))
|
||
let g:checked = 1
|
||
endfunc
|
||
|
||
autocmd TextYankPost *
|
||
\ : if v:event.operator ==? 'y'
|
||
\ | call Check_Results(v:event.regtype)
|
||
\ | endif
|
||
|
||
new
|
||
call setline(1, ['abcd', 'efghijk', 'lmn'])
|
||
|
||
let g:expected_region = ['abcd']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
normal yy
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
|
||
let g:expected_region = ['cd', 'ghijk', 'n']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 3, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 3, 0], [bufnr('%'), 2, 7, 0]],
|
||
\ [[bufnr('%'), 3, 3, 0], [bufnr('%'), 3, 3, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys("gg0ll\<C-V>jj$y", 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
let g:expected_region = ['bc', 'fg', 'mn']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 2, 0], [bufnr('%'), 1, 3, 0]],
|
||
\ [[bufnr('%'), 2, 2, 0], [bufnr('%'), 2, 3, 0]],
|
||
\ [[bufnr('%'), 3, 2, 0], [bufnr('%'), 3, 3, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys("gg0l\<C-V>jjly", 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
bwipe!
|
||
|
||
new
|
||
let lines = ['asdfghjkl', '«口=口»', 'qwertyuiop', '口口=口口', 'zxcvbnm']
|
||
call setline(1, lines)
|
||
|
||
let g:expected_region = lines
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 9, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 11, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 10, 0]],
|
||
\ [[bufnr('%'), 4, 1, 0], [bufnr('%'), 4, 13, 0]],
|
||
\ [[bufnr('%'), 5, 1, 0], [bufnr('%'), 5, 7, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys('ggyG', 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
let g:expected_region = ['=口»', 'qwertyuiop', '口口=口']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 2, 6, 0], [bufnr('%'), 2, 11, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 10, 0]],
|
||
\ [[bufnr('%'), 4, 1, 0], [bufnr('%'), 4, 10, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys('2gg02lv2j2ly', 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
let g:expected_region = ['asdf', '«口=', 'qwer', '口口', 'zxcv']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 1, 0], [bufnr('%'), 1, 4, 0]],
|
||
\ [[bufnr('%'), 2, 1, 0], [bufnr('%'), 2, 6, 0]],
|
||
\ [[bufnr('%'), 3, 1, 0], [bufnr('%'), 3, 4, 0]],
|
||
\ [[bufnr('%'), 4, 1, 0], [bufnr('%'), 4, 6, 0]],
|
||
\ [[bufnr('%'), 5, 1, 0], [bufnr('%'), 5, 4, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys("G0\<C-V>3l4ky", 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
let g:expected_region = ['ghjkl', '口»', 'tyuiop', '=口口', 'bnm']
|
||
let g:expected_regionpos = [
|
||
\ [[bufnr('%'), 1, 5, 0], [bufnr('%'), 1, 9, 0]],
|
||
\ [[bufnr('%'), 2, 7, 0], [bufnr('%'), 2, 11, 0]],
|
||
\ [[bufnr('%'), 3, 5, 0], [bufnr('%'), 3, 10, 0]],
|
||
\ [[bufnr('%'), 4, 7, 0], [bufnr('%'), 4, 13, 0]],
|
||
\ [[bufnr('%'), 5, 5, 0], [bufnr('%'), 5, 7, 0]],
|
||
\ ]
|
||
let g:checked = 0
|
||
call feedkeys("G04l\<C-V>$4ky", 'tx')
|
||
call assert_equal(1, g:checked)
|
||
call Check_Results(getregtype('"'))
|
||
call assert_equal(g:expected_region, getreg('"', v:true, v:true))
|
||
|
||
bwipe!
|
||
|
||
unlet g:expected_region
|
||
unlet g:expected_regionpos
|
||
unlet g:checked
|
||
autocmd! TextYankPost
|
||
delfunc Check_Results
|
||
endfunc
|
||
|
||
func Test_visual_block_cursor_delete()
|
||
new
|
||
call setline(1, 'ab')
|
||
exe ":norm! $\<c-v>hI\<Del>\<ESC>"
|
||
call assert_equal(['b'], getline(1, 1))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_visual_block_cursor_insert_enter()
|
||
new
|
||
call setline(1, ['asdf asdf', 'asdf asdf', 'asdf asdf', 'asdf asdf'])
|
||
call cursor(1, 5)
|
||
exe ":norm! \<c-v>3jcw\<cr>"
|
||
call assert_equal(['asdfw', 'asdf', 'asdfasdf', 'asdfasdf', 'asdfasdf'], getline(1, '$'))
|
||
bwipe!
|
||
endfunc
|
||
|
||
" vim: shiftwidth=2 sts=2 expandtab
|