2016-10-22 14:22:50 -07:00
|
|
|
" Tests for tabpage
|
|
|
|
|
2020-04-28 20:13:23 -07:00
|
|
|
source screendump.vim
|
2020-12-23 00:23:35 -07:00
|
|
|
source check.vim
|
2018-08-08 16:34:54 -07:00
|
|
|
|
2016-10-22 14:22:50 -07:00
|
|
|
function Test_tabpage()
|
2023-11-12 22:31:30 -07:00
|
|
|
CheckFeature quickfix
|
|
|
|
|
2016-10-22 14:22:50 -07:00
|
|
|
bw!
|
|
|
|
" Simple test for opening and closing a tab page
|
|
|
|
tabnew
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
quit
|
|
|
|
|
|
|
|
" Open three tab pages and use ":tabdo"
|
|
|
|
0tabnew
|
|
|
|
1tabnew
|
|
|
|
$tabnew
|
2017-03-21 05:56:10 -07:00
|
|
|
%del
|
2016-10-22 14:22:50 -07:00
|
|
|
tabdo call append(line('$'), tabpagenr())
|
|
|
|
tabclose! 2
|
|
|
|
tabrewind
|
|
|
|
let line1 = getline('$')
|
|
|
|
undo
|
|
|
|
q
|
|
|
|
tablast
|
|
|
|
let line2 = getline('$')
|
|
|
|
q!
|
|
|
|
call append(line('$'), line1)
|
|
|
|
call append(line('$'), line2)
|
|
|
|
unlet line1 line2
|
|
|
|
call assert_equal(['', '3', '1', '4'], getline(1, '$'))
|
|
|
|
"
|
|
|
|
" Test for settabvar() and gettabvar() functions. Open a new tab page and
|
|
|
|
" set 3 variables to a number, string and a list. Verify that the variables
|
|
|
|
" are correctly set.
|
|
|
|
tabnew
|
|
|
|
tabfirst
|
|
|
|
call settabvar(2, 'val_num', 100)
|
2021-10-31 11:10:46 -07:00
|
|
|
eval 'SetTabVar test'->settabvar(2, 'val_str')
|
2016-10-22 14:22:50 -07:00
|
|
|
call settabvar(2, 'val_list', ['red', 'blue', 'green'])
|
|
|
|
"
|
|
|
|
call assert_true(gettabvar(2, 'val_num') == 100 && gettabvar(2, 'val_str') == 'SetTabVar test' && gettabvar(2, 'val_list') == ['red', 'blue', 'green'])
|
|
|
|
|
|
|
|
tabnext 2
|
|
|
|
call assert_true(t:val_num == 100 && t:val_str == 'SetTabVar test' && t:val_list == ['red', 'blue', 'green'])
|
|
|
|
tabclose
|
|
|
|
|
2018-08-16 00:05:35 -07:00
|
|
|
" Test for ":tab drop exist-file" to keep current window.
|
|
|
|
sp test1
|
|
|
|
tab drop test1
|
|
|
|
call assert_true(tabpagenr('$') == 1 && winnr('$') == 2 && winnr() == 1)
|
|
|
|
close
|
|
|
|
"
|
|
|
|
"
|
|
|
|
" Test for ":tab drop new-file" to keep current window of tabpage 1.
|
|
|
|
split
|
|
|
|
tab drop newfile
|
|
|
|
call assert_true(tabpagenr('$') == 2 && tabpagewinnr(1, '$') == 2 && tabpagewinnr(1) == 1)
|
|
|
|
tabclose
|
|
|
|
q
|
|
|
|
"
|
|
|
|
"
|
2020-10-20 21:03:36 -07:00
|
|
|
" Test for ":tab drop multi-opened-file" to keep current tabpage and window.
|
2018-08-16 00:05:35 -07:00
|
|
|
new test1
|
|
|
|
tabnew
|
|
|
|
new test1
|
|
|
|
tab drop test1
|
|
|
|
call assert_true(tabpagenr() == 2 && tabpagewinnr(2, '$') == 2 && tabpagewinnr(2) == 1)
|
|
|
|
tabclose
|
|
|
|
q
|
|
|
|
"
|
|
|
|
"
|
|
|
|
" Test for ":tab drop vertical-split-window" to jump test1 buffer
|
|
|
|
tabedit test1
|
|
|
|
vnew
|
|
|
|
tabfirst
|
|
|
|
tab drop test1
|
|
|
|
call assert_equal([2, 2, 2, 2], [tabpagenr('$'), tabpagenr(), tabpagewinnr(2, '$'), tabpagewinnr(2)])
|
|
|
|
1tabonly
|
2016-10-22 14:22:50 -07:00
|
|
|
"
|
|
|
|
"
|
|
|
|
for i in range(9) | tabnew | endfor
|
|
|
|
normal! 1gt
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
tabmove 5
|
|
|
|
call assert_equal(5, tabpagenr())
|
|
|
|
.tabmove
|
|
|
|
call assert_equal(5, tabpagenr())
|
|
|
|
tabmove -
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
tabmove +
|
|
|
|
call assert_equal(5, tabpagenr())
|
|
|
|
tabmove -2
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
tabmove +4
|
|
|
|
call assert_equal(7, tabpagenr())
|
|
|
|
tabmove
|
|
|
|
call assert_equal(10, tabpagenr())
|
|
|
|
0tabmove
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
$tabmove
|
|
|
|
call assert_equal(10, tabpagenr())
|
|
|
|
tabmove 0
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
tabmove $
|
|
|
|
call assert_equal(10, tabpagenr())
|
|
|
|
3tabmove
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
7tabmove 5
|
|
|
|
call assert_equal(5, tabpagenr())
|
2019-05-02 19:37:24 -07:00
|
|
|
-tabmove
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
+tabmove
|
|
|
|
call assert_equal(5, tabpagenr())
|
|
|
|
-2tabmove
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
+3tabmove
|
|
|
|
call assert_equal(6, tabpagenr())
|
2018-08-08 16:35:48 -07:00
|
|
|
|
|
|
|
" The following are a no-op
|
|
|
|
norm! 2gt
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
tabmove 2
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
2tabmove
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
tabmove 1
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
1tabmove
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
|
2022-03-14 04:37:44 -07:00
|
|
|
call assert_fails('let t = tabpagenr("@")', 'E15:')
|
|
|
|
call assert_equal(0, tabpagewinnr(-1))
|
2017-03-21 08:22:04 -07:00
|
|
|
call assert_fails("99tabmove", 'E16:')
|
|
|
|
call assert_fails("+99tabmove", 'E16:')
|
|
|
|
call assert_fails("-99tabmove", 'E16:')
|
2022-08-06 22:47:46 -07:00
|
|
|
call assert_fails("tabmove foo", 'E475:')
|
|
|
|
call assert_fails("tabmove 99", 'E475:')
|
|
|
|
call assert_fails("tabmove +99", 'E475:')
|
|
|
|
call assert_fails("tabmove -99", 'E475:')
|
|
|
|
call assert_fails("tabmove -3+", 'E475:')
|
|
|
|
call assert_fails("tabmove $3", 'E475:')
|
2022-07-11 17:28:56 -07:00
|
|
|
call assert_fails("%tabonly", 'E16:')
|
2017-03-21 08:22:04 -07:00
|
|
|
1tabonly!
|
2022-07-15 20:34:19 -07:00
|
|
|
tabmove 1
|
|
|
|
call assert_equal(1, tabpagenr())
|
2022-07-11 17:28:56 -07:00
|
|
|
tabnew
|
2022-08-06 22:47:46 -07:00
|
|
|
call assert_fails("-2tabmove", 'E16:')
|
2022-07-11 17:28:56 -07:00
|
|
|
tabonly!
|
2016-10-22 14:22:50 -07:00
|
|
|
endfunc
|
|
|
|
|
2023-04-20 18:02:30 -07:00
|
|
|
func Test_tabpage_drop()
|
|
|
|
edit f1
|
|
|
|
tab split f2
|
|
|
|
tab split f3
|
|
|
|
normal! gt
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
|
|
|
|
tab drop f3
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
call assert_equal(1, tabpagenr('#'))
|
|
|
|
bwipe!
|
|
|
|
bwipe!
|
|
|
|
bwipe!
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
2024-01-23 16:29:33 -07:00
|
|
|
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
call assert_equal('', bufname(''))
|
|
|
|
call writefile(['L1', 'L2'], 'Xdropfile', 'D')
|
|
|
|
|
|
|
|
" Test for ':tab drop single-file': reuse current buffer
|
|
|
|
let expected_nr = bufnr()
|
|
|
|
tab drop Xdropfile
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
bwipe!
|
|
|
|
|
|
|
|
" Test for ':tab drop single-file': not reuse modified buffer
|
|
|
|
set modified
|
|
|
|
let expected_nr = bufnr() + 1
|
|
|
|
tab drop Xdropfile
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
bwipe!
|
|
|
|
|
|
|
|
" Test for ':tab drop single-file': multiple tabs already exist
|
|
|
|
tab split f2
|
|
|
|
tab split f3
|
|
|
|
let expected_nr = bufnr() + 1
|
|
|
|
tab drop Xdropfile
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
call assert_equal(4, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
%bwipe!
|
|
|
|
|
|
|
|
" Test for ':tab drop multi-files': reuse current buffer
|
|
|
|
let expected_nr = bufnr()
|
|
|
|
tab drop Xdropfile f1 f2 f3
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
call assert_equal(4, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
%bwipe!
|
|
|
|
|
|
|
|
" Test for ':tab drop multi-files': not reuse modified buffer
|
|
|
|
set modified
|
|
|
|
let expected_nr = bufnr() + 1
|
|
|
|
tab drop Xdropfile f1 f2 f3
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal(5, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
%bwipe!
|
|
|
|
|
|
|
|
" Test for ':tab drop multi-files': multiple tabs already exist
|
|
|
|
tab split f2
|
|
|
|
tab split f3
|
|
|
|
let expected_nr = bufnr() + 1
|
|
|
|
tab drop a b c
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
let expected_nr = bufnr() + 3
|
|
|
|
tab drop Xdropfile f1 f2 f3
|
|
|
|
call assert_equal(5, tabpagenr())
|
|
|
|
call assert_equal(8, tabpagenr('$'))
|
|
|
|
call assert_equal(expected_nr, bufnr())
|
|
|
|
call assert_equal('L2', getline(2))
|
|
|
|
%bwipe!
|
2023-04-20 18:02:30 -07:00
|
|
|
endfunc
|
|
|
|
|
2016-10-22 14:22:50 -07:00
|
|
|
" Test autocommands
|
|
|
|
function Test_tabpage_with_autocmd()
|
|
|
|
command -nargs=1 -bar C :call add(s:li, '=== ' . <q-args> . ' ===')|<args>
|
|
|
|
augroup TestTabpageGroup
|
|
|
|
au!
|
|
|
|
autocmd TabEnter * call add(s:li, 'TabEnter')
|
|
|
|
autocmd WinEnter * call add(s:li, 'WinEnter')
|
|
|
|
autocmd BufEnter * call add(s:li, 'BufEnter')
|
|
|
|
autocmd TabLeave * call add(s:li, 'TabLeave')
|
|
|
|
autocmd WinLeave * call add(s:li, 'WinLeave')
|
|
|
|
autocmd BufLeave * call add(s:li, 'BufLeave')
|
|
|
|
augroup END
|
|
|
|
|
|
|
|
let s:li = []
|
|
|
|
let t:a='a'
|
|
|
|
C tab split
|
|
|
|
call assert_equal(['=== tab split ===', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter'], s:li)
|
|
|
|
let s:li = []
|
|
|
|
let t:a='b'
|
|
|
|
C tabnew
|
|
|
|
call assert_equal(['=== tabnew ===', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', 'BufLeave', 'BufEnter'], s:li)
|
|
|
|
let t:a='c'
|
|
|
|
let s:li = split(join(map(range(1, tabpagenr('$')), 'gettabvar(v:val, "a")')) , '\s\+')
|
|
|
|
call assert_equal(['a', 'b', 'c'], s:li)
|
|
|
|
|
|
|
|
let s:li = []
|
|
|
|
C call map(range(1, tabpagenr('$')), 'settabvar(v:val, ''a'', v:val*2)')
|
|
|
|
call assert_equal(["=== call map(range(1, tabpagenr('$')), 'settabvar(v:val, ''a'', v:val*2)') ==="], s:li)
|
|
|
|
let s:li = split(join(map(range(1, tabpagenr('$')), 'gettabvar(v:val, "a")')) , '\s\+')
|
|
|
|
call assert_equal(['2', '4', '6'], s:li)
|
|
|
|
|
|
|
|
let s:li = []
|
|
|
|
let w:a='a'
|
|
|
|
C vsplit
|
|
|
|
call assert_equal(['=== vsplit ===', 'WinLeave', 'WinEnter'], s:li)
|
|
|
|
let s:li = []
|
|
|
|
let w:a='a'
|
|
|
|
let tabn=tabpagenr()
|
|
|
|
let winr=range(1, winnr('$'))
|
|
|
|
C tabnext 1
|
|
|
|
call assert_equal(['=== tabnext 1 ===', 'BufLeave', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', 'BufEnter'], s:li)
|
|
|
|
let s:li = split(join(map(copy(winr), 'gettabwinvar('.tabn.', v:val, "a")')), '\s\+')
|
|
|
|
call assert_equal(['a', 'a'], s:li)
|
|
|
|
let s:li = []
|
2021-10-31 11:10:46 -07:00
|
|
|
C call map(copy(winr), '(v:val*2)->settabwinvar(' .. tabn .. ', v:val, ''a'')')
|
2016-10-22 14:22:50 -07:00
|
|
|
let s:li = split(join(map(copy(winr), 'gettabwinvar('.tabn.', v:val, "a")')), '\s\+')
|
|
|
|
call assert_equal(['2', '4'], s:li)
|
|
|
|
|
|
|
|
augroup TabDestructive
|
|
|
|
autocmd TabEnter * :C tabnext 2 | C tabclose 3
|
|
|
|
augroup END
|
|
|
|
let s:li = []
|
|
|
|
C tabnext 3
|
|
|
|
call assert_equal(['=== tabnext 3 ===', 'BufLeave', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', '=== tabnext 2 ===', '=== tabclose 3 ==='], s:li)
|
|
|
|
call assert_equal(['2/2'], [tabpagenr().'/'.tabpagenr('$')])
|
|
|
|
|
|
|
|
autocmd! TabDestructive TabEnter
|
|
|
|
let s:li = []
|
|
|
|
C tabnew
|
|
|
|
call assert_equal(['=== tabnew ===', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', 'BufLeave', 'BufEnter'], s:li)
|
|
|
|
let s:li = []
|
|
|
|
C tabnext 1
|
|
|
|
call assert_equal(['=== tabnext 1 ===', 'BufLeave', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', 'BufEnter'], s:li)
|
|
|
|
|
|
|
|
autocmd TabDestructive TabEnter * nested :C tabnext 2 | C tabclose 3
|
|
|
|
let s:li = []
|
2017-03-21 08:22:04 -07:00
|
|
|
call assert_equal(3, tabpagenr('$'))
|
|
|
|
C tabnext 2
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
call assert_equal(['=== tabnext 2 ===', 'WinLeave', 'TabLeave', 'WinEnter', 'TabEnter', '=== tabnext 2 ===', '=== tabclose 3 ==='], s:li)
|
2016-10-22 14:22:50 -07:00
|
|
|
call assert_equal(['2/2'], [tabpagenr().'/'.tabpagenr('$')])
|
|
|
|
|
|
|
|
delcommand C
|
|
|
|
autocmd! TabDestructive
|
|
|
|
augroup! TabDestructive
|
|
|
|
autocmd! TestTabpageGroup
|
|
|
|
augroup! TestTabpageGroup
|
2017-03-21 08:22:04 -07:00
|
|
|
1tabonly!
|
2016-10-22 14:22:50 -07:00
|
|
|
endfunction
|
|
|
|
|
2020-12-23 00:08:12 -07:00
|
|
|
" Test autocommands on tab drop
|
|
|
|
function Test_tabpage_with_autocmd_tab_drop()
|
|
|
|
augroup TestTabpageGroup
|
|
|
|
au!
|
|
|
|
autocmd TabEnter * call add(s:li, 'TabEnter')
|
|
|
|
autocmd WinEnter * call add(s:li, 'WinEnter')
|
|
|
|
autocmd BufEnter * call add(s:li, 'BufEnter')
|
|
|
|
autocmd TabLeave * call add(s:li, 'TabLeave')
|
|
|
|
autocmd WinLeave * call add(s:li, 'WinLeave')
|
|
|
|
autocmd BufLeave * call add(s:li, 'BufLeave')
|
|
|
|
augroup END
|
|
|
|
|
|
|
|
let s:li = []
|
|
|
|
tab drop test1
|
2024-01-23 16:29:33 -07:00
|
|
|
call assert_equal(['BufEnter'], s:li)
|
2020-12-23 00:08:12 -07:00
|
|
|
|
|
|
|
let s:li = []
|
|
|
|
tab drop test2 test3
|
|
|
|
call assert_equal([
|
|
|
|
\ 'TabLeave', 'TabEnter', 'TabLeave', 'TabEnter',
|
|
|
|
\ 'TabLeave', 'WinEnter', 'TabEnter', 'BufEnter',
|
2024-01-23 16:29:33 -07:00
|
|
|
\ 'TabLeave', 'WinEnter', 'TabEnter', 'BufEnter', 'BufEnter'], s:li)
|
2020-12-23 00:08:12 -07:00
|
|
|
|
|
|
|
autocmd! TestTabpageGroup
|
|
|
|
augroup! TestTabpageGroup
|
|
|
|
1tabonly!
|
|
|
|
endfunction
|
|
|
|
|
2016-10-22 15:00:47 -07:00
|
|
|
function Test_tabpage_with_tab_modifier()
|
2023-11-12 22:31:30 -07:00
|
|
|
CheckFeature quickfix
|
|
|
|
|
2016-10-22 15:00:47 -07:00
|
|
|
for n in range(4)
|
|
|
|
tabedit
|
|
|
|
endfor
|
|
|
|
|
|
|
|
function s:check_tab(pre_nr, cmd, post_nr)
|
|
|
|
exec 'tabnext ' . a:pre_nr
|
|
|
|
exec a:cmd
|
|
|
|
call assert_equal(a:post_nr, tabpagenr())
|
2017-03-21 06:11:27 -07:00
|
|
|
call assert_equal('help', &buftype)
|
2016-10-22 15:00:47 -07:00
|
|
|
helpclose
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
call s:check_tab(1, 'tab help', 2)
|
|
|
|
call s:check_tab(1, '3tab help', 4)
|
|
|
|
call s:check_tab(1, '.tab help', 2)
|
|
|
|
call s:check_tab(1, '.+1tab help', 3)
|
|
|
|
call s:check_tab(1, '0tab help', 1)
|
|
|
|
call s:check_tab(2, '+tab help', 4)
|
|
|
|
call s:check_tab(2, '+2tab help', 5)
|
|
|
|
call s:check_tab(4, '-tab help', 4)
|
|
|
|
call s:check_tab(4, '-2tab help', 3)
|
|
|
|
call s:check_tab(3, '$tab help', 6)
|
|
|
|
call assert_fails('99tab help', 'E16:')
|
|
|
|
call assert_fails('+99tab help', 'E16:')
|
|
|
|
call assert_fails('-99tab help', 'E16:')
|
|
|
|
|
|
|
|
delfunction s:check_tab
|
2017-03-21 08:22:04 -07:00
|
|
|
1tabonly!
|
|
|
|
endfunction
|
|
|
|
|
|
|
|
function Check_tab_count(pre_nr, cmd, post_nr)
|
|
|
|
exec 'tabnext' a:pre_nr
|
|
|
|
normal! G
|
|
|
|
exec a:cmd
|
|
|
|
call assert_equal(a:post_nr, tabpagenr(), a:cmd)
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
" Test for [count] of tabnext
|
|
|
|
function Test_tabpage_with_tabnext()
|
|
|
|
for n in range(4)
|
|
|
|
tabedit
|
|
|
|
call setline(1, ['', '', '3'])
|
|
|
|
endfor
|
|
|
|
|
|
|
|
call Check_tab_count(1, 'tabnext', 2)
|
|
|
|
call Check_tab_count(1, '3tabnext', 3)
|
|
|
|
call Check_tab_count(1, '.tabnext', 1)
|
|
|
|
call Check_tab_count(1, '.+1tabnext', 2)
|
|
|
|
call Check_tab_count(2, '+tabnext', 3)
|
|
|
|
call Check_tab_count(2, '+2tabnext', 4)
|
|
|
|
call Check_tab_count(4, '-tabnext', 3)
|
|
|
|
call Check_tab_count(4, '-2tabnext', 2)
|
|
|
|
call Check_tab_count(3, '$tabnext', 5)
|
|
|
|
call assert_fails('0tabnext', 'E16:')
|
|
|
|
call assert_fails('99tabnext', 'E16:')
|
|
|
|
call assert_fails('+99tabnext', 'E16:')
|
|
|
|
call assert_fails('-99tabnext', 'E16:')
|
|
|
|
call Check_tab_count(1, 'tabnext 3', 3)
|
|
|
|
call Check_tab_count(2, 'tabnext +', 3)
|
|
|
|
call Check_tab_count(2, 'tabnext +2', 4)
|
|
|
|
call Check_tab_count(4, 'tabnext -', 3)
|
|
|
|
call Check_tab_count(4, 'tabnext -2', 2)
|
|
|
|
call Check_tab_count(3, 'tabnext $', 5)
|
2022-08-06 22:47:46 -07:00
|
|
|
call assert_fails('tabnext 0', 'E475:')
|
|
|
|
call assert_fails('tabnext .', 'E475:')
|
|
|
|
call assert_fails('tabnext -+', 'E475:')
|
|
|
|
call assert_fails('tabnext +2-', 'E475:')
|
|
|
|
call assert_fails('tabnext $3', 'E475:')
|
|
|
|
call assert_fails('tabnext 99', 'E475:')
|
|
|
|
call assert_fails('tabnext +99', 'E475:')
|
|
|
|
call assert_fails('tabnext -99', 'E475:')
|
2017-03-21 08:22:04 -07:00
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
endfunction
|
|
|
|
|
|
|
|
" Test for [count] of tabprevious
|
|
|
|
function Test_tabpage_with_tabprevious()
|
|
|
|
for n in range(5)
|
|
|
|
tabedit
|
|
|
|
call setline(1, ['', '', '3'])
|
|
|
|
endfor
|
|
|
|
|
|
|
|
for cmd in ['tabNext', 'tabprevious']
|
|
|
|
call Check_tab_count(6, cmd, 5)
|
|
|
|
call Check_tab_count(6, '3' . cmd, 3)
|
|
|
|
call Check_tab_count(6, '8' . cmd, 4)
|
|
|
|
call Check_tab_count(6, cmd . ' 3', 3)
|
|
|
|
call Check_tab_count(6, cmd . ' 8', 4)
|
|
|
|
for n in range(2)
|
|
|
|
for c in ['0', '.+3', '+', '+2' , '-', '-2' , '$', '+99', '-99']
|
|
|
|
if n == 0 " pre count
|
|
|
|
let entire_cmd = c . cmd
|
|
|
|
let err_code = 'E16:'
|
|
|
|
else
|
|
|
|
let entire_cmd = cmd . ' ' . c
|
2022-08-06 22:47:46 -07:00
|
|
|
let err_code = 'E475:'
|
2017-03-21 08:22:04 -07:00
|
|
|
endif
|
|
|
|
call assert_fails(entire_cmd, err_code)
|
|
|
|
endfor
|
|
|
|
endfor
|
|
|
|
endfor
|
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
endfunction
|
|
|
|
|
|
|
|
function s:reconstruct_tabpage_for_test(nr)
|
|
|
|
let n = (a:nr > 2) ? a:nr - 2 : 1
|
|
|
|
1tabonly!
|
|
|
|
0tabedit n0
|
|
|
|
for n in range(1, n)
|
|
|
|
exec '$tabedit n' . n
|
|
|
|
if n == 1
|
|
|
|
call setline(1, ['', '', '3'])
|
|
|
|
endif
|
|
|
|
endfor
|
|
|
|
endfunc
|
|
|
|
|
2018-08-08 16:34:54 -07:00
|
|
|
func Test_tabpage_ctrl_pgup_pgdown()
|
|
|
|
enew!
|
|
|
|
tabnew tab1
|
|
|
|
tabnew tab2
|
|
|
|
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
exe "norm! \<C-PageUp>"
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
exe "norm! \<C-PageDown>"
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
|
|
|
|
" Check wrapping at last or first page.
|
|
|
|
exe "norm! \<C-PageDown>"
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
exe "norm! \<C-PageUp>"
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
|
|
|
|
" With a count, <C-PageUp> and <C-PageDown> are not symmetrical somehow:
|
|
|
|
" - {count}<C-PageUp> goes {count} pages downward (relative count)
|
|
|
|
" - {count}<C-PageDown> goes to page number {count} (absolute count)
|
|
|
|
exe "norm! 2\<C-PageUp>"
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
exe "norm! 2\<C-PageDown>"
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
endfunc
|
|
|
|
|
2017-03-21 08:22:04 -07:00
|
|
|
" Test for [count] of tabclose
|
|
|
|
function Test_tabpage_with_tabclose()
|
|
|
|
|
|
|
|
" pre count
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
call Check_tab_count(3, 'tabclose!', 3)
|
|
|
|
call Check_tab_count(1, '3tabclose', 1)
|
|
|
|
call Check_tab_count(4, '4tabclose', 3)
|
|
|
|
call Check_tab_count(3, '1tabclose', 2)
|
|
|
|
call Check_tab_count(2, 'tabclose', 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal('', bufname(''))
|
|
|
|
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
call Check_tab_count(2, '$tabclose', 2)
|
|
|
|
call Check_tab_count(4, '.tabclose', 4)
|
|
|
|
call Check_tab_count(3, '.+tabclose', 3)
|
|
|
|
call Check_tab_count(3, '.-2tabclose', 2)
|
|
|
|
call Check_tab_count(1, '.+1tabclose!', 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal('', bufname(''))
|
|
|
|
|
|
|
|
" post count
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
call Check_tab_count(3, 'tabclose!', 3)
|
|
|
|
call Check_tab_count(1, 'tabclose 3', 1)
|
|
|
|
call Check_tab_count(4, 'tabclose 4', 3)
|
|
|
|
call Check_tab_count(3, 'tabclose 1', 2)
|
|
|
|
call Check_tab_count(2, 'tabclose', 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal('', bufname(''))
|
|
|
|
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
call Check_tab_count(2, 'tabclose $', 2)
|
|
|
|
call Check_tab_count(4, 'tabclose', 4)
|
|
|
|
call Check_tab_count(3, 'tabclose +', 3)
|
|
|
|
call Check_tab_count(3, 'tabclose -2', 2)
|
|
|
|
call Check_tab_count(1, 'tabclose! +1', 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal('', bufname(''))
|
|
|
|
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
for n in range(2)
|
|
|
|
for c in ['0', '$3', '99', '+99', '-99']
|
|
|
|
if n == 0 " pre count
|
|
|
|
let entire_cmd = c . 'tabclose'
|
|
|
|
let err_code = 'E16:'
|
|
|
|
else
|
|
|
|
let entire_cmd = 'tabclose ' . c
|
2022-08-06 22:47:46 -07:00
|
|
|
let err_code = 'E475:'
|
2017-03-21 08:22:04 -07:00
|
|
|
endif
|
|
|
|
call assert_fails(entire_cmd, err_code)
|
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
endfor
|
|
|
|
endfor
|
|
|
|
|
|
|
|
call assert_fails('3tabclose', 'E37:')
|
|
|
|
call assert_fails('tabclose 3', 'E37:')
|
2022-08-06 22:47:46 -07:00
|
|
|
call assert_fails('tabclose -+', 'E475:')
|
|
|
|
call assert_fails('tabclose +2-', 'E475:')
|
2017-03-21 08:22:04 -07:00
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
endfunction
|
|
|
|
|
|
|
|
" Test for [count] of tabonly
|
|
|
|
function Test_tabpage_with_tabonly()
|
|
|
|
|
|
|
|
" Test for the normal behavior (pre count only)
|
|
|
|
let tc = [ [4, '.', '!'], [2, '.+', ''], [3, '.-2', '!'], [1, '.+1', '!'] ]
|
|
|
|
for c in tc
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
let entire_cmd = c[1] . 'tabonly' . c[2]
|
|
|
|
call Check_tab_count(c[0], entire_cmd, 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
endfor
|
|
|
|
|
|
|
|
" Test for the normal behavior
|
|
|
|
let tc2 = [ [3, '', ''], [1, '3', ''], [4, '4', '!'], [3, '1', '!'],
|
|
|
|
\ [2, '', '!'],
|
|
|
|
\ [2, '$', '!'], [3, '+', '!'], [3, '-2', '!'], [3, '+1', '!']
|
|
|
|
\ ]
|
|
|
|
for n in range(2)
|
|
|
|
for c in tc2
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
if n == 0 " pre count
|
|
|
|
let entire_cmd = c[1] . 'tabonly' . c[2]
|
|
|
|
else
|
|
|
|
let entire_cmd = 'tabonly' . c[2] . ' ' . c[1]
|
|
|
|
endif
|
|
|
|
call Check_tab_count(c[0], entire_cmd, 1)
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
endfor
|
|
|
|
endfor
|
|
|
|
|
|
|
|
" Test for the error behavior
|
|
|
|
for n in range(2)
|
|
|
|
for c in ['0', '$3', '99', '+99', '-99']
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
if n == 0 " pre count
|
|
|
|
let entire_cmd = c . 'tabonly'
|
|
|
|
let err_code = 'E16:'
|
|
|
|
else
|
|
|
|
let entire_cmd = 'tabonly ' . c
|
2022-08-06 22:47:46 -07:00
|
|
|
let err_code = 'E475:'
|
2017-03-21 08:22:04 -07:00
|
|
|
endif
|
|
|
|
call assert_fails(entire_cmd, err_code)
|
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
endfor
|
|
|
|
endfor
|
|
|
|
|
|
|
|
" Test for the error behavior (post count only)
|
|
|
|
for c in tc
|
|
|
|
call s:reconstruct_tabpage_for_test(6)
|
|
|
|
let entire_cmd = 'tabonly' . c[2] . ' ' . c[1]
|
2022-08-06 22:47:46 -07:00
|
|
|
let err_code = 'E475:'
|
2017-03-21 08:22:04 -07:00
|
|
|
call assert_fails(entire_cmd, err_code)
|
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
endfor
|
|
|
|
|
2022-08-06 22:47:46 -07:00
|
|
|
call assert_fails('tabonly -+', 'E475:')
|
|
|
|
call assert_fails('tabonly +2-', 'E475:')
|
2017-03-21 08:22:04 -07:00
|
|
|
call assert_equal(6, tabpagenr('$'))
|
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
new
|
|
|
|
only!
|
2016-10-22 15:00:47 -07:00
|
|
|
endfunction
|
|
|
|
|
2016-10-26 04:53:14 -07:00
|
|
|
func Test_tabnext_on_buf_unload1()
|
2016-10-22 15:25:16 -07:00
|
|
|
" This once caused a crash
|
|
|
|
new
|
|
|
|
tabedit
|
|
|
|
tabfirst
|
|
|
|
au BufUnload <buffer> tabnext
|
|
|
|
q
|
|
|
|
|
|
|
|
while tabpagenr('$') > 1
|
2016-10-26 04:53:14 -07:00
|
|
|
bwipe!
|
|
|
|
endwhile
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
func Test_tabnext_on_buf_unload2()
|
|
|
|
" This once caused a crash
|
|
|
|
tabedit
|
|
|
|
autocmd BufUnload <buffer> tabnext
|
|
|
|
file x
|
|
|
|
edit y
|
|
|
|
|
|
|
|
while tabpagenr('$') > 1
|
|
|
|
bwipe!
|
2016-10-22 15:25:16 -07:00
|
|
|
endwhile
|
|
|
|
endfunc
|
|
|
|
|
2018-02-02 12:44:46 -07:00
|
|
|
func Test_close_on_quitpre()
|
|
|
|
" This once caused a crash
|
2018-02-03 04:09:37 -07:00
|
|
|
edit Xtest
|
2018-02-02 12:44:46 -07:00
|
|
|
new
|
|
|
|
only
|
|
|
|
set bufhidden=delete
|
|
|
|
au QuitPre <buffer> close
|
|
|
|
tabnew tab1
|
|
|
|
tabnew tab2
|
|
|
|
1tabn
|
|
|
|
q!
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
" clean up
|
|
|
|
while tabpagenr('$') > 1
|
|
|
|
bwipe!
|
|
|
|
endwhile
|
2018-02-03 04:09:37 -07:00
|
|
|
buf Xtest
|
2018-02-02 12:44:46 -07:00
|
|
|
endfunc
|
2016-10-22 15:25:16 -07:00
|
|
|
|
2018-08-08 16:34:54 -07:00
|
|
|
func Test_tabs()
|
|
|
|
enew!
|
|
|
|
tabnew tab1
|
|
|
|
norm ixxx
|
|
|
|
let a=split(execute(':tabs'), "\n")
|
|
|
|
call assert_equal(['Tab page 1',
|
2020-01-18 14:19:56 -07:00
|
|
|
\ '# [No Name]',
|
2018-08-08 16:34:54 -07:00
|
|
|
\ 'Tab page 2',
|
|
|
|
\ '> + tab1'], a)
|
|
|
|
|
|
|
|
1tabonly!
|
|
|
|
bw!
|
|
|
|
endfunc
|
|
|
|
|
2019-05-02 19:40:31 -07:00
|
|
|
func Test_tabpage_cmdheight()
|
2022-11-04 17:07:06 -07:00
|
|
|
CheckRunVimInTerminal
|
2019-05-02 19:40:31 -07:00
|
|
|
call writefile([
|
|
|
|
\ 'set laststatus=2',
|
|
|
|
\ 'set cmdheight=2',
|
|
|
|
\ 'tabnew',
|
|
|
|
\ 'set cmdheight=3',
|
|
|
|
\ 'tabnext',
|
|
|
|
\ 'redraw!',
|
|
|
|
\ 'echo "hello\nthere"',
|
|
|
|
\ 'tabnext',
|
|
|
|
\ 'redraw',
|
|
|
|
\ ], 'XTest_tabpage_cmdheight')
|
|
|
|
" Check that cursor line is concealed
|
|
|
|
let buf = RunVimInTerminal('-S XTest_tabpage_cmdheight', {'statusoff': 3})
|
|
|
|
call VerifyScreenDump(buf, 'Test_tabpage_cmdheight', {})
|
|
|
|
|
|
|
|
call StopVimInTerminal(buf)
|
2019-05-06 18:28:29 -07:00
|
|
|
call delete('XTest_tabpage_cmdheight')
|
2019-05-02 19:40:31 -07:00
|
|
|
endfunc
|
|
|
|
|
2022-07-11 17:28:56 -07:00
|
|
|
" Test for closing the tab page from a command window
|
|
|
|
func Test_tabpage_close_cmdwin()
|
|
|
|
tabnew
|
|
|
|
call feedkeys("q/:tabclose\<CR>\<Esc>", 'xt')
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
call feedkeys("q/:tabonly\<CR>\<Esc>", 'xt')
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
tabonly
|
|
|
|
endfunc
|
|
|
|
|
2022-11-04 04:49:23 -07:00
|
|
|
" Pressing <C-PageUp> in insert mode should go to the previous tab page
|
|
|
|
" and <C-PageDown> should go to the next tab page
|
|
|
|
func Test_tabpage_Ctrl_Pageup()
|
|
|
|
tabnew
|
|
|
|
call feedkeys("i\<C-PageUp>", 'xt')
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
call feedkeys("i\<C-PageDown>", 'xt')
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
%bw!
|
|
|
|
endfunc
|
|
|
|
|
2020-12-23 00:23:35 -07:00
|
|
|
" Return the terminal key code for selecting a tab page from the tabline. This
|
|
|
|
" sequence contains the following codes: a CSI (0x9b), KS_TABLINE (0xf0),
|
|
|
|
" KS_FILLER (0x58) and then the tab page number.
|
|
|
|
func TabLineSelectPageCode(tabnr)
|
|
|
|
return "\x9b\xf0\x58" .. nr2char(a:tabnr)
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
" Return the terminal key code for opening a new tabpage from the tabpage
|
|
|
|
" menu. This sequence consists of the following codes: a CSI (0x9b),
|
|
|
|
" KS_TABMENU (0xef), KS_FILLER (0x58), the tab page number and
|
|
|
|
" TABLINE_MENU_NEW (2).
|
|
|
|
func TabMenuNewItemCode(tabnr)
|
|
|
|
return "\x9b\xef\x58" .. nr2char(a:tabnr) .. nr2char(2)
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
" Return the terminal key code for closing a tabpage from the tabpage menu.
|
|
|
|
" This sequence consists of the following codes: a CSI (0x9b), KS_TABMENU
|
|
|
|
" (0xef), KS_FILLER (0x58), the tab page number and TABLINE_MENU_CLOSE (1).
|
|
|
|
func TabMenuCloseItemCode(tabnr)
|
|
|
|
return "\x9b\xef\x58" .. nr2char(a:tabnr) .. nr2char(1)
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
" Test for using the tabpage menu from the insert and normal modes
|
|
|
|
func Test_tabline_tabmenu()
|
|
|
|
" only works in GUI
|
|
|
|
CheckGui
|
|
|
|
|
|
|
|
%bw!
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
call assert_equal(3, tabpagenr())
|
|
|
|
|
|
|
|
" go to tab page 2 in normal mode
|
|
|
|
call feedkeys(TabLineSelectPageCode(2), "Lx!")
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
|
|
|
|
" close tab page 3 in normal mode
|
|
|
|
call feedkeys(TabMenuCloseItemCode(3), "Lx!")
|
|
|
|
call assert_equal(2, tabpagenr('$'))
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
|
|
|
|
" open new tab page before tab page 1 in normal mode
|
|
|
|
call feedkeys(TabMenuNewItemCode(1), "Lx!")
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
call assert_equal(3, tabpagenr('$'))
|
|
|
|
|
|
|
|
" go to tab page 2 in operator-pending mode (should beep)
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_beeps('call feedkeys("c" .. TabLineSelectPageCode(2), "Lx!")')
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal(3, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
" open new tab page before tab page 1 in operator-pending mode (should beep)
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_beeps('call feedkeys("c" .. TabMenuNewItemCode(1), "Lx!")')
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
call assert_equal(4, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
" open new tab page after tab page 3 in normal mode
|
|
|
|
call feedkeys(TabMenuNewItemCode(4), "Lx!")
|
|
|
|
call assert_equal(4, tabpagenr())
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_equal(5, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
" go to tab page 2 in insert mode
|
|
|
|
call feedkeys("i" .. TabLineSelectPageCode(2) .. "\<C-C>", "Lx!")
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
|
|
|
|
" close tab page 2 in insert mode
|
|
|
|
call feedkeys("i" .. TabMenuCloseItemCode(2) .. "\<C-C>", "Lx!")
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_equal(4, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
" open new tab page before tab page 3 in insert mode
|
|
|
|
call feedkeys("i" .. TabMenuNewItemCode(3) .. "\<C-C>", "Lx!")
|
|
|
|
call assert_equal(3, tabpagenr())
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_equal(5, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
" open new tab page after tab page 4 in insert mode
|
|
|
|
call feedkeys("i" .. TabMenuNewItemCode(5) .. "\<C-C>", "Lx!")
|
|
|
|
call assert_equal(5, tabpagenr())
|
2022-07-19 17:16:02 -07:00
|
|
|
call assert_equal(6, tabpagenr('$'))
|
2020-12-23 00:23:35 -07:00
|
|
|
|
|
|
|
%bw!
|
|
|
|
endfunc
|
|
|
|
|
2022-07-15 20:34:19 -07:00
|
|
|
" Test for changing the current tab page from an autocmd when closing a tab
|
|
|
|
" page.
|
|
|
|
func Test_tabpage_switchtab_on_close()
|
|
|
|
only
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
" Test for BufLeave
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
au BufLeave * tabfirst
|
|
|
|
augroup END
|
|
|
|
tabclose
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
augroup END
|
|
|
|
|
|
|
|
" Test for WinLeave
|
|
|
|
$tabnew
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
au WinLeave * tabfirst
|
|
|
|
augroup END
|
|
|
|
tabclose
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
augroup END
|
|
|
|
|
|
|
|
" Test for TabLeave
|
|
|
|
$tabnew
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
au TabLeave * tabfirst
|
|
|
|
augroup END
|
|
|
|
tabclose
|
|
|
|
call assert_equal(1, tabpagenr())
|
|
|
|
augroup T1
|
|
|
|
au!
|
|
|
|
augroup END
|
|
|
|
augroup! T1
|
|
|
|
tabonly
|
|
|
|
endfunc
|
|
|
|
|
|
|
|
" Test for closing the destination tabpage when jumping from one to another.
|
|
|
|
func Test_tabpage_close_on_switch()
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
edit Xfile
|
|
|
|
augroup T2
|
|
|
|
au!
|
|
|
|
au BufLeave Xfile 1tabclose
|
|
|
|
augroup END
|
|
|
|
tabfirst
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal('Xfile', @%)
|
|
|
|
augroup T2
|
|
|
|
au!
|
|
|
|
augroup END
|
|
|
|
augroup! T2
|
|
|
|
%bw!
|
|
|
|
endfunc
|
|
|
|
|
2022-03-14 04:37:44 -07:00
|
|
|
" Test for jumping to last accessed tabpage
|
|
|
|
func Test_lastused_tabpage()
|
|
|
|
tabonly!
|
|
|
|
call assert_equal(0, tabpagenr('#'))
|
|
|
|
call assert_beeps('call feedkeys("g\<Tab>", "xt")')
|
|
|
|
call assert_beeps('call feedkeys("\<C-Tab>", "xt")')
|
|
|
|
call assert_beeps('call feedkeys("\<C-W>g\<Tab>", "xt")')
|
2022-03-14 05:16:12 -07:00
|
|
|
call assert_fails('tabnext #', 'E475:')
|
2022-03-14 04:37:44 -07:00
|
|
|
|
|
|
|
" open four tab pages
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
|
|
|
|
2tabnext
|
|
|
|
|
|
|
|
" Test for g<Tab>
|
|
|
|
call assert_equal(4, tabpagenr('#'))
|
|
|
|
call feedkeys("g\<Tab>", "xt")
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
call assert_equal(2, tabpagenr('#'))
|
|
|
|
|
|
|
|
" Test for <C-Tab>
|
|
|
|
call feedkeys("\<C-Tab>", "xt")
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal(4, tabpagenr('#'))
|
|
|
|
|
|
|
|
" Test for <C-W>g<Tab>
|
|
|
|
call feedkeys("\<C-W>g\<Tab>", "xt")
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
call assert_equal(2, tabpagenr('#'))
|
|
|
|
|
2022-03-14 05:16:12 -07:00
|
|
|
" Test for :tabnext #
|
|
|
|
tabnext #
|
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_equal(4, tabpagenr('#'))
|
|
|
|
|
2022-03-14 04:37:44 -07:00
|
|
|
" Try to jump to a closed tab page
|
2022-03-14 05:16:12 -07:00
|
|
|
tabclose #
|
2022-03-14 04:37:44 -07:00
|
|
|
call assert_equal(0, tabpagenr('#'))
|
|
|
|
call feedkeys("g\<Tab>", "xt")
|
2022-03-14 05:16:12 -07:00
|
|
|
call assert_equal(2, tabpagenr())
|
2022-03-14 04:37:44 -07:00
|
|
|
call feedkeys("\<C-Tab>", "xt")
|
2022-03-14 05:16:12 -07:00
|
|
|
call assert_equal(2, tabpagenr())
|
2022-03-14 04:37:44 -07:00
|
|
|
call feedkeys("\<C-W>g\<Tab>", "xt")
|
2022-03-14 05:16:12 -07:00
|
|
|
call assert_equal(2, tabpagenr())
|
|
|
|
call assert_fails('tabnext #', 'E475:')
|
|
|
|
call assert_equal(2, tabpagenr())
|
2022-03-14 04:37:44 -07:00
|
|
|
|
2022-03-14 05:16:12 -07:00
|
|
|
" Test for :tabonly #
|
|
|
|
let wnum = win_getid()
|
|
|
|
$tabnew
|
|
|
|
tabonly #
|
|
|
|
call assert_equal(wnum, win_getid())
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
|
|
|
|
" Test for :tabmove #
|
|
|
|
tabnew
|
|
|
|
let wnum = win_getid()
|
|
|
|
tabnew
|
|
|
|
tabnew
|
|
|
|
tabnext 2
|
|
|
|
tabmove #
|
|
|
|
call assert_equal(4, tabpagenr())
|
|
|
|
call assert_equal(wnum, win_getid())
|
|
|
|
|
|
|
|
tabonly!
|
2022-03-14 04:37:44 -07:00
|
|
|
endfunc
|
|
|
|
|
2023-02-28 06:01:36 -07:00
|
|
|
" Test for tabpage allocation failure
|
|
|
|
func Test_tabpage_alloc_failure()
|
|
|
|
CheckFunction test_alloc_fail
|
|
|
|
call test_alloc_fail(GetAllocId('newtabpage_tvars'), 0, 0)
|
|
|
|
call assert_fails('tabnew', 'E342:')
|
|
|
|
|
|
|
|
call test_alloc_fail(GetAllocId('newtabpage_tvars'), 0, 0)
|
|
|
|
edit Xfile1
|
|
|
|
call assert_fails('tabedit Xfile2', 'E342:')
|
|
|
|
call assert_equal(1, winnr('$'))
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
call assert_equal('Xfile1', @%)
|
|
|
|
|
|
|
|
new
|
|
|
|
call test_alloc_fail(GetAllocId('newtabpage_tvars'), 0, 0)
|
|
|
|
call assert_fails('wincmd T', 'E342:')
|
|
|
|
bw!
|
|
|
|
|
|
|
|
call test_alloc_fail(GetAllocId('newtabpage_tvars'), 0, 0)
|
|
|
|
call assert_fails('tab split', 'E342:')
|
|
|
|
call assert_equal(2, winnr('$'))
|
|
|
|
call assert_equal(1, tabpagenr('$'))
|
|
|
|
endfunc
|
|
|
|
|
2023-02-27 17:26:00 -07:00
|
|
|
" this was giving ml_get errors
|
|
|
|
func Test_tabpage_last_line()
|
|
|
|
enew
|
|
|
|
call setline(1, repeat(['a'], &lines + 5))
|
|
|
|
$
|
|
|
|
tabnew
|
|
|
|
call setline(1, repeat(['b'], &lines + 20))
|
|
|
|
$
|
|
|
|
tabNext
|
|
|
|
call assert_equal('a', getline('.'))
|
|
|
|
|
|
|
|
bwipe!
|
|
|
|
bwipe!
|
|
|
|
endfunc
|
|
|
|
|
vim-patch:9.0.2168: Moving tabpages on :drop may cause an endless loop (#26605)
Problem: Moving tabpages on :drop may cause an endless loop
Solution: Disallow moving tabpages on :drop when cleaning up the arglist
first
Moving tabpages during drop command may cause an endless loop
When executing a :tab drop command, Vim will close all windows not in
the argument list. This triggers various autocommands. If a user has
created an 'au Tabenter * :tabmove -' autocommand, this can cause Vim to
end up in an endless loop, when trying to iterate over all tabs (which
would trigger the tabmove autocommand, which will change the tpnext
pointer, etc).
So instead of blocking all autocommands before we actually try to edit
the given file, lets simply disallow to move tabpages around. Otherwise,
we may change the expected number of events triggered during a :drop
command, which users may rely on (there is actually a test, that expects
various TabLeave/TabEnter autocommands) and would therefore be a
backwards incompatible change.
Don't make this an error, as this could trigger several times during the
drop command, but silently ignore the :tabmove command in this case (and
it should in fact finally trigger successfully when loading the given
file in a new tab). So let's just be quiet here instead.
fixes: vim/vim#13676
closes: vim/vim#13686
https://github.com/vim/vim/commit/df12e39b8b9dd39056e22b452276622cb7b617fd
Co-authored-by: Christian Brabandt <cb@256bit.org>
2023-12-16 06:30:08 -07:00
|
|
|
" this was causing an endless loop
|
|
|
|
func Test_tabpage_drop_tabmove()
|
|
|
|
augroup TestTabpageTabmove
|
|
|
|
au!
|
|
|
|
autocmd! TabEnter * :if tabpagenr() > 1 | tabmove - | endif
|
|
|
|
augroup end
|
|
|
|
$tab drop XTab_99.log
|
|
|
|
$tab drop XTab_98.log
|
|
|
|
$tab drop XTab_97.log
|
|
|
|
|
|
|
|
autocmd! TestTabpageTabmove
|
|
|
|
augroup! TestTabpageTabmove
|
|
|
|
|
|
|
|
" clean up
|
|
|
|
bwipe!
|
|
|
|
bwipe!
|
|
|
|
bwipe!
|
|
|
|
endfunc
|
|
|
|
|
2016-10-22 14:22:50 -07:00
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|