mirror of
https://github.com/vim/vim.git
synced 2025-10-27 09:24:23 -04:00
b0905e269d
Problem: tests: too many imports in the test suite Solution: Clean up the imported scripts Most tests make use of check.vim, so let's just source it once in runtest.vim instead of having each test manually source it. runtest.vim already sources shared.vim, which again sources view_util.vim, so we don't need to source those two common dependencies in all the other tests And then check.vim sources term_util.vim already, so we can in addition drop sourcing it explicitly in each single test script. Note: test_expand_func.vim had to be updated to account for the changed number of sourced files. And finally check.vim uses line-continuation so let's also explicitly enable line continuation via the 'cpo' option value. related: #17677 Signed-off-by: Christian Brabandt <cb@256bit.org>
1355 lines
35 KiB
VimL
1355 lines
35 KiB
VimL
" Test for reading and writing .viminfo
|
|
|
|
func Test_viminfo_read_and_write()
|
|
" First clear 'history', so that "hislen" is zero. Then set it again,
|
|
" simulating Vim starting up.
|
|
set history=0
|
|
wviminfo Xviminfo
|
|
set history=1000
|
|
|
|
call histdel(':')
|
|
let @/=''
|
|
let lines = [
|
|
\ '# comment line',
|
|
\ '*encoding=utf-8',
|
|
\ '~MSle0~/asdf',
|
|
\ '|copied as-is',
|
|
\ '|and one more',
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
rviminfo Xviminfo
|
|
call assert_equal('asdf', @/)
|
|
|
|
wviminfo Xviminfo
|
|
let lines = readfile('Xviminfo')
|
|
let done = 0
|
|
for line in lines
|
|
if line[0] == '|' && line !~ '^|[234],' && line !~ '^|<'
|
|
if done == 0
|
|
call assert_equal('|1,4', line)
|
|
elseif done == 1
|
|
call assert_equal('|copied as-is', line)
|
|
elseif done == 2
|
|
call assert_equal('|and one more', line)
|
|
endif
|
|
let done += 1
|
|
endif
|
|
endfor
|
|
call assert_equal(3, done)
|
|
endfunc
|
|
|
|
func Test_global_vars()
|
|
let g:MY_GLOBAL_STRING = "Vim Editor"
|
|
let g:MY_GLOBAL_NUM = 345
|
|
let g:MY_GLOBAL_FLOAT = 3.14
|
|
let test_dict = {'foo': 1, 'bar': 0, 'longvarible': 1000}
|
|
let g:MY_GLOBAL_DICT = test_dict
|
|
" store a really long list, so line wrapping will occur in viminfo file
|
|
let test_list = range(1,100)
|
|
let g:MY_GLOBAL_LIST = test_list
|
|
let test_blob = 0z00112233445566778899aabbccddeeff
|
|
let g:MY_GLOBAL_BLOB = test_blob
|
|
let test_false = v:false
|
|
let g:MY_GLOBAL_FALSE = test_false
|
|
let test_true = v:true
|
|
let g:MY_GLOBAL_TRUE = test_true
|
|
let test_null = v:null
|
|
let g:MY_GLOBAL_NULL = test_null
|
|
let test_none = v:none
|
|
let g:MY_GLOBAL_NONE = test_none
|
|
let g:MY_GLOBAL_FUNCREF = function('min')
|
|
|
|
set viminfo='100,<50,s10,h,!,nviminfo
|
|
wv! Xviminfo
|
|
|
|
unlet g:MY_GLOBAL_STRING
|
|
unlet g:MY_GLOBAL_NUM
|
|
unlet g:MY_GLOBAL_FLOAT
|
|
unlet g:MY_GLOBAL_DICT
|
|
unlet g:MY_GLOBAL_LIST
|
|
unlet g:MY_GLOBAL_BLOB
|
|
unlet g:MY_GLOBAL_FALSE
|
|
unlet g:MY_GLOBAL_TRUE
|
|
unlet g:MY_GLOBAL_NULL
|
|
unlet g:MY_GLOBAL_NONE
|
|
unlet g:MY_GLOBAL_FUNCREF
|
|
|
|
rv! Xviminfo
|
|
call assert_equal("Vim Editor", g:MY_GLOBAL_STRING)
|
|
call assert_equal(345, g:MY_GLOBAL_NUM)
|
|
call assert_equal(3.14, g:MY_GLOBAL_FLOAT)
|
|
call assert_equal(test_dict, g:MY_GLOBAL_DICT)
|
|
call assert_equal(test_list, g:MY_GLOBAL_LIST)
|
|
call assert_equal(test_blob, g:MY_GLOBAL_BLOB)
|
|
call assert_equal(test_false, g:MY_GLOBAL_FALSE)
|
|
call assert_equal(test_true, g:MY_GLOBAL_TRUE)
|
|
call assert_equal(test_null, g:MY_GLOBAL_NULL)
|
|
call assert_equal(test_none, g:MY_GLOBAL_NONE)
|
|
call assert_false(exists("g:MY_GLOBAL_FUNCREF"))
|
|
|
|
" When reading global variables from viminfo, if a variable cannot be
|
|
" modified, then the value should not be changed.
|
|
unlet g:MY_GLOBAL_STRING
|
|
unlet g:MY_GLOBAL_NUM
|
|
unlet g:MY_GLOBAL_FLOAT
|
|
unlet g:MY_GLOBAL_DICT
|
|
unlet g:MY_GLOBAL_LIST
|
|
unlet g:MY_GLOBAL_BLOB
|
|
|
|
const g:MY_GLOBAL_STRING = 'New Value'
|
|
const g:MY_GLOBAL_NUM = 987
|
|
const g:MY_GLOBAL_FLOAT = 1.16
|
|
const g:MY_GLOBAL_DICT = {'editor': 'vim'}
|
|
const g:MY_GLOBAL_LIST = [5, 7, 13]
|
|
const g:MY_GLOBAL_BLOB = 0zDEADBEEF
|
|
call assert_fails('rv! Xviminfo', 'E741:')
|
|
call assert_equal('New Value', g:MY_GLOBAL_STRING)
|
|
call assert_equal(987, g:MY_GLOBAL_NUM)
|
|
call assert_equal(1.16, g:MY_GLOBAL_FLOAT)
|
|
call assert_equal({'editor': 'vim'}, g:MY_GLOBAL_DICT)
|
|
call assert_equal([5, 7 , 13], g:MY_GLOBAL_LIST)
|
|
call assert_equal(0zDEADBEEF, g:MY_GLOBAL_BLOB)
|
|
|
|
unlet g:MY_GLOBAL_STRING
|
|
unlet g:MY_GLOBAL_NUM
|
|
unlet g:MY_GLOBAL_FLOAT
|
|
unlet g:MY_GLOBAL_DICT
|
|
unlet g:MY_GLOBAL_LIST
|
|
unlet g:MY_GLOBAL_BLOB
|
|
|
|
" Test for invalid values for a blob, list, dict in a viminfo file
|
|
call writefile([
|
|
\ "!GLOB_BLOB_1\tBLO\t123",
|
|
\ "!GLOB_BLOB_2\tBLO\t012",
|
|
\ "!GLOB_BLOB_3\tBLO\t0z1x",
|
|
\ "!GLOB_BLOB_4\tBLO\t0z12 ab",
|
|
\ "!GLOB_LIST_1\tLIS\t1 2",
|
|
\ "!GLOB_DICT_1\tDIC\t1 2"], 'Xviminfo', 'D')
|
|
call assert_fails('rv! Xviminfo', 'E488:')
|
|
call assert_equal('123', g:GLOB_BLOB_1)
|
|
call assert_equal(1, type(g:GLOB_BLOB_1))
|
|
call assert_equal('012', g:GLOB_BLOB_2)
|
|
call assert_equal(1, type(g:GLOB_BLOB_2))
|
|
call assert_equal('0z1x', g:GLOB_BLOB_3)
|
|
call assert_equal(1, type(g:GLOB_BLOB_3))
|
|
call assert_equal('0z12 ab', g:GLOB_BLOB_4)
|
|
call assert_equal(1, type(g:GLOB_BLOB_4))
|
|
call assert_equal('1 2', g:GLOB_LIST_1)
|
|
call assert_equal(1, type(g:GLOB_LIST_1))
|
|
call assert_equal('1 2', g:GLOB_DICT_1)
|
|
call assert_equal(1, type(g:GLOB_DICT_1))
|
|
|
|
set viminfo-=!
|
|
endfunc
|
|
|
|
func Test_global_vars_with_circular_reference()
|
|
let g:MY_GLOBAL_LIST = []
|
|
call add(g:MY_GLOBAL_LIST, g:MY_GLOBAL_LIST)
|
|
let g:MY_GLOBAL_DICT = {}
|
|
let g:MY_GLOBAL_DICT['self'] = g:MY_GLOBAL_DICT
|
|
|
|
set viminfo='100,<50,s10,h,!,nviminfo
|
|
wv! Xviminfo
|
|
call assert_equal(v:errmsg, '')
|
|
|
|
unlet g:MY_GLOBAL_LIST
|
|
unlet g:MY_GLOBAL_DICT
|
|
|
|
rv! Xviminfo
|
|
call assert_equal(v:errmsg, '')
|
|
call assert_true(!exists('g:MY_GLOBAL_LIST'))
|
|
call assert_true(!exists('g:MY_GLOBAL_DICT'))
|
|
|
|
call delete('Xviminfo')
|
|
set viminfo-=!
|
|
endfunc
|
|
|
|
func Test_cmdline_history()
|
|
call histdel(':')
|
|
call test_settime(11)
|
|
call histadd(':', "echo 'one'")
|
|
call test_settime(12)
|
|
" split into two lines
|
|
let long800 = repeat(" 'eight'", 100)
|
|
call histadd(':', "echo " . long800)
|
|
call test_settime(13)
|
|
" split into three lines
|
|
let long1400 = repeat(" 'fourteeeeen'", 100)
|
|
call histadd(':', "echo " . long1400)
|
|
wviminfo Xviminfo
|
|
let lines = readfile('Xviminfo')
|
|
let done_colon = 0
|
|
let done_bar = 0
|
|
let lnum = 0
|
|
while lnum < len(lines)
|
|
let line = lines[lnum] | let lnum += 1
|
|
if line[0] == ':'
|
|
if done_colon == 0
|
|
call assert_equal(":\x161408", line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('<echo ' . long1400, line)
|
|
elseif done_colon == 1
|
|
call assert_equal(":\x16808", line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal("<echo " . long800, line)
|
|
elseif done_colon == 2
|
|
call assert_equal(":echo 'one'", line)
|
|
endif
|
|
let done_colon += 1
|
|
elseif line[0:4] == '|2,0,'
|
|
if done_bar == 0
|
|
call assert_equal("|2,0,13,,>1407", line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('|<"echo ' . long1400[0:484], line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('|<' . long1400[485:974], line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('|<' . long1400[975:] . '"', line)
|
|
elseif done_bar == 1
|
|
call assert_equal('|2,0,12,,>807', line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('|<"echo ' . long800[0:484], line)
|
|
let line = lines[lnum] | let lnum += 1
|
|
call assert_equal('|<' . long800[485:] . '"', line)
|
|
elseif done_bar == 2
|
|
call assert_equal("|2,0,11,,\"echo 'one'\"", line)
|
|
endif
|
|
let done_bar += 1
|
|
endif
|
|
endwhile
|
|
call assert_equal(3, done_colon)
|
|
call assert_equal(3, done_bar)
|
|
|
|
call histdel(':')
|
|
rviminfo Xviminfo
|
|
call assert_equal("echo " . long1400, histget(':', -1))
|
|
call assert_equal("echo " . long800, histget(':', -2))
|
|
call assert_equal("echo 'one'", histget(':', -3))
|
|
|
|
" If the value for the '/' or ':' or '@' field in 'viminfo' is zero, then
|
|
" the corresponding history entries are not saved.
|
|
set viminfo='100,/0,:0,@0,<50,s10,h,!,nviminfo
|
|
call histdel('/')
|
|
call histdel(':')
|
|
call histdel('@')
|
|
call histadd('/', 'foo')
|
|
call histadd(':', 'bar')
|
|
call histadd('@', 'baz')
|
|
wviminfo! Xviminfo
|
|
call histdel('/')
|
|
call histdel(':')
|
|
call histdel('@')
|
|
rviminfo! Xviminfo
|
|
call assert_equal('', histget('/'))
|
|
call assert_equal('', histget(':'))
|
|
call assert_equal('', histget('@'))
|
|
|
|
call delete('Xviminfo')
|
|
set viminfo&vim
|
|
endfunc
|
|
|
|
func Test_cmdline_history_order()
|
|
call histdel(':')
|
|
call test_settime(11)
|
|
call histadd(':', "echo '11'")
|
|
call test_settime(22)
|
|
call histadd(':', "echo '22'")
|
|
call test_settime(33)
|
|
call histadd(':', "echo '33'")
|
|
wviminfo Xviminfo
|
|
|
|
call histdel(':')
|
|
" items go in between
|
|
call test_settime(15)
|
|
call histadd(':', "echo '15'")
|
|
call test_settime(27)
|
|
call histadd(':', "echo '27'")
|
|
|
|
rviminfo Xviminfo
|
|
call assert_equal("echo '33'", histget(':', -1))
|
|
call assert_equal("echo '27'", histget(':', -2))
|
|
call assert_equal("echo '22'", histget(':', -3))
|
|
call assert_equal("echo '15'", histget(':', -4))
|
|
call assert_equal("echo '11'", histget(':', -5))
|
|
|
|
call histdel(':')
|
|
" items go before and after
|
|
eval 8->test_settime()
|
|
call histadd(':', "echo '8'")
|
|
call test_settime(39)
|
|
call histadd(':', "echo '39'")
|
|
|
|
rviminfo Xviminfo
|
|
call assert_equal("echo '39'", histget(':', -1))
|
|
call assert_equal("echo '33'", histget(':', -2))
|
|
call assert_equal("echo '22'", histget(':', -3))
|
|
call assert_equal("echo '11'", histget(':', -4))
|
|
call assert_equal("echo '8'", histget(':', -5))
|
|
|
|
" Check sorting works when writing with merge.
|
|
call histdel(':')
|
|
call test_settime(8)
|
|
call histadd(':', "echo '8'")
|
|
call test_settime(15)
|
|
call histadd(':', "echo '15'")
|
|
call test_settime(27)
|
|
call histadd(':', "echo '27'")
|
|
call test_settime(39)
|
|
call histadd(':', "echo '39'")
|
|
wviminfo Xviminfo
|
|
|
|
call histdel(':')
|
|
rviminfo Xviminfo
|
|
call assert_equal("echo '39'", histget(':', -1))
|
|
call assert_equal("echo '33'", histget(':', -2))
|
|
call assert_equal("echo '27'", histget(':', -3))
|
|
call assert_equal("echo '22'", histget(':', -4))
|
|
call assert_equal("echo '15'", histget(':', -5))
|
|
call assert_equal("echo '11'", histget(':', -6))
|
|
call assert_equal("echo '8'", histget(':', -7))
|
|
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
func Test_viminfo_registers()
|
|
call test_settime(8)
|
|
call setreg('a', "eight", 'c')
|
|
call test_settime(20)
|
|
call setreg('b', ["twenty", "again"], 'l')
|
|
call test_settime(40)
|
|
call setreg('c', ["four", "agai"], 'b4')
|
|
let l = []
|
|
set viminfo='100,<600,s10,h,!,nviminfo
|
|
for i in range(500)
|
|
call add(l, 'something')
|
|
endfor
|
|
call setreg('d', l, 'l')
|
|
call setreg('e', "abc\<C-V>xyz")
|
|
wviminfo Xviminfo
|
|
|
|
call test_settime(10)
|
|
call setreg('a', '', 'b10')
|
|
call test_settime(15)
|
|
call setreg('b', 'drop')
|
|
call test_settime(50)
|
|
call setreg('c', 'keep', 'l')
|
|
call test_settime(30)
|
|
call setreg('d', 'drop', 'l')
|
|
call setreg('e', 'drop')
|
|
rviminfo Xviminfo
|
|
|
|
call assert_equal("", getreg('a'))
|
|
call assert_equal("\<C-V>10", getregtype('a'))
|
|
call assert_equal("twenty\nagain\n", getreg('b'))
|
|
call assert_equal("V", getregtype('b'))
|
|
call assert_equal("keep\n", getreg('c'))
|
|
call assert_equal("V", getregtype('c'))
|
|
call assert_equal(l, getreg('d', 1, 1))
|
|
call assert_equal("V", getregtype('d'))
|
|
call assert_equal("abc\<C-V>xyz", getreg('e'))
|
|
|
|
" Length around 440 switches to line continuation.
|
|
let len = 434
|
|
while len < 445
|
|
let s = repeat('a', len)
|
|
call setreg('"', s)
|
|
wviminfo Xviminfo
|
|
call setreg('"', '')
|
|
rviminfo Xviminfo
|
|
call assert_equal(s, getreg('"'), 'wrong register at length: ' . len)
|
|
|
|
let len += 1
|
|
endwhile
|
|
|
|
" If the maximum number of lines saved for a register ('<' in 'viminfo') is
|
|
" zero, then register values should not be saved.
|
|
let @a = 'abc'
|
|
set viminfo='100,<0,s10,h,!,nviminfo
|
|
wviminfo Xviminfo
|
|
let @a = 'xyz'
|
|
rviminfo! Xviminfo
|
|
call assert_equal('xyz', @a)
|
|
" repeat the test with '"' instead of '<'
|
|
let @b = 'def'
|
|
set viminfo='100,\"0,s10,h,!,nviminfo
|
|
wviminfo Xviminfo
|
|
let @b = 'rst'
|
|
rviminfo! Xviminfo
|
|
call assert_equal('rst', @b)
|
|
|
|
" If the maximum size of an item ('s' in 'viminfo') is zero, then register
|
|
" values should not be saved.
|
|
let @c = '123'
|
|
set viminfo='100,<20,s0,h,!,nviminfo
|
|
wviminfo Xviminfo
|
|
let @c = '456'
|
|
rviminfo! Xviminfo
|
|
call assert_equal('456', @c)
|
|
|
|
call delete('Xviminfo')
|
|
set viminfo&vim
|
|
endfunc
|
|
|
|
func Test_viminfo_marks()
|
|
sp bufa
|
|
let bufa = bufnr('%')
|
|
sp bufb
|
|
let bufb = bufnr('%')
|
|
|
|
call test_settime(8)
|
|
call setpos("'A", [bufa, 1, 1, 0])
|
|
call test_settime(20)
|
|
call setpos("'B", [bufb, 9, 1, 0])
|
|
call setpos("'C", [bufa, 7, 1, 0])
|
|
|
|
delmark 0-9
|
|
call test_settime(25)
|
|
call setpos("'1", [bufb, 12, 1, 0])
|
|
call test_settime(35)
|
|
call setpos("'0", [bufa, 11, 1, 0])
|
|
|
|
call test_settime(45)
|
|
wviminfo Xviminfo
|
|
|
|
" Writing viminfo inserts the '0 mark.
|
|
call assert_equal([bufb, 1, 1, 0], getpos("'0"))
|
|
call assert_equal([bufa, 11, 1, 0], getpos("'1"))
|
|
call assert_equal([bufb, 12, 1, 0], getpos("'2"))
|
|
|
|
call test_settime(4)
|
|
call setpos("'A", [bufa, 9, 1, 0])
|
|
call test_settime(30)
|
|
call setpos("'B", [bufb, 2, 3, 0])
|
|
delmark C
|
|
|
|
delmark 0-9
|
|
call test_settime(30)
|
|
call setpos("'1", [bufb, 22, 1, 0])
|
|
call test_settime(55)
|
|
call setpos("'0", [bufa, 21, 1, 0])
|
|
|
|
rviminfo Xviminfo
|
|
|
|
call assert_equal([bufa, 1, 1, 0], getpos("'A"))
|
|
call assert_equal([bufb, 2, 3, 0], getpos("'B"))
|
|
call assert_equal([bufa, 7, 1, 0], getpos("'C"))
|
|
|
|
" numbered marks are merged
|
|
call assert_equal([bufa, 21, 1, 0], getpos("'0")) " time 55
|
|
call assert_equal([bufb, 1, 1, 0], getpos("'1")) " time 45
|
|
call assert_equal([bufa, 11, 1, 0], getpos("'2")) " time 35
|
|
call assert_equal([bufb, 22, 1, 0], getpos("'3")) " time 30
|
|
call assert_equal([bufb, 12, 1, 0], getpos("'4")) " time 25
|
|
|
|
" deleted file marks are removed from viminfo
|
|
delmark C
|
|
wviminfo Xviminfo
|
|
rviminfo Xviminfo
|
|
call assert_equal([0, 0, 0, 0], getpos("'C"))
|
|
|
|
" deleted file marks stay in viminfo if defined in another vim later
|
|
call test_settime(70)
|
|
call setpos("'D", [bufb, 8, 1, 0])
|
|
wviminfo Xviminfo
|
|
call test_settime(65)
|
|
delmark D
|
|
call assert_equal([0, 0, 0, 0], getpos("'D"))
|
|
call test_settime(75)
|
|
rviminfo Xviminfo
|
|
call assert_equal([bufb, 8, 1, 0], getpos("'D"))
|
|
|
|
call delete('Xviminfo')
|
|
exe 'bwipe ' . bufa
|
|
exe 'bwipe ' . bufb
|
|
endfunc
|
|
|
|
func Test_viminfo_jumplist()
|
|
split testbuf
|
|
clearjumps
|
|
call setline(1, ['time 05', 'time 10', 'time 15', 'time 20', 'time 30', 'last pos'])
|
|
call cursor(2, 1)
|
|
call test_settime(10)
|
|
exe "normal /20\r"
|
|
call test_settime(20)
|
|
exe "normal /30\r"
|
|
call test_settime(30)
|
|
exe "normal /last pos\r"
|
|
wviminfo Xviminfo
|
|
|
|
clearjumps
|
|
call cursor(1, 1)
|
|
call test_settime(5)
|
|
exe "normal /15\r"
|
|
call test_settime(15)
|
|
exe "normal /last pos\r"
|
|
call test_settime(40)
|
|
exe "normal ?30\r"
|
|
rviminfo Xviminfo
|
|
|
|
call assert_equal('time 30', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('last pos', getline('.'))
|
|
exe "normal \<C-O>"
|
|
" duplicate for 'time 30' was removed
|
|
call assert_equal('time 20', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 15', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 10', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 05', getline('.'))
|
|
|
|
clearjumps
|
|
call cursor(1, 1)
|
|
call test_settime(5)
|
|
exe "normal /15\r"
|
|
call test_settime(15)
|
|
exe "normal /last pos\r"
|
|
call test_settime(40)
|
|
exe "normal ?30\r"
|
|
" Test merge when writing
|
|
wviminfo Xviminfo
|
|
clearjumps
|
|
rviminfo Xviminfo
|
|
|
|
let last_line = line('.')
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 30', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('last pos', getline('.'))
|
|
exe "normal \<C-O>"
|
|
" duplicate for 'time 30' was removed
|
|
call assert_equal('time 20', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 15', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 10', getline('.'))
|
|
exe "normal \<C-O>"
|
|
call assert_equal('time 05', getline('.'))
|
|
|
|
" Test with jumplist full.
|
|
clearjumps
|
|
call setline(1, repeat(['match here'], 101))
|
|
call cursor(1, 1)
|
|
call test_settime(10)
|
|
for i in range(100)
|
|
exe "normal /here\r"
|
|
endfor
|
|
rviminfo Xviminfo
|
|
|
|
" must be newest mark that comes from viminfo.
|
|
exe "normal \<C-O>"
|
|
call assert_equal(last_line, line('.'))
|
|
|
|
bwipe!
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
func Test_viminfo_encoding()
|
|
set enc=latin1
|
|
call histdel(':')
|
|
call histadd(':', "echo '\xe9'")
|
|
wviminfo Xviminfo
|
|
|
|
set fencs=utf-8,latin1
|
|
set enc=utf-8
|
|
sp Xviminfo
|
|
call assert_equal('latin1', &fenc)
|
|
close
|
|
|
|
call histdel(':')
|
|
rviminfo Xviminfo
|
|
call assert_equal("echo 'é'", histget(':', -1))
|
|
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
func Test_viminfo_bad_syntax()
|
|
let lines = []
|
|
call add(lines, '|<') " empty continuation line
|
|
call add(lines, '|234234234234234324,nothing')
|
|
call add(lines, '|1+"no comma"')
|
|
call add(lines, '|1,2,3,4,5,6,7') " too many items
|
|
call add(lines, '|1,"string version"')
|
|
call add(lines, '|1,>x') " bad continuation line
|
|
call add(lines, '|1,"x') " missing quote
|
|
call add(lines, '|1,"x\') " trailing backslash
|
|
call add(lines, '|1,,,,') "trailing comma
|
|
call add(lines, '|1,>234') " trailing continuation line
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
rviminfo Xviminfo
|
|
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
func Test_viminfo_bad_syntax2()
|
|
let lines = []
|
|
call add(lines, '|1,4')
|
|
|
|
" bad viminfo syntax for history barline
|
|
call add(lines, '|2') " invalid number of fields in a history barline
|
|
call add(lines, '|2,9,1,1,"x"') " invalid value for the history type
|
|
call add(lines, '|2,0,,1,"x"') " no timestamp
|
|
call add(lines, '|2,0,1,1,10') " non-string text
|
|
|
|
" bad viminfo syntax for register barline
|
|
call add(lines, '|3') " invalid number of fields in a register barline
|
|
call add(lines, '|3,1,1,1,1,,1,"x"') " missing width field
|
|
call add(lines, '|3,0,80,1,1,1,1,"x"') " invalid register number
|
|
call add(lines, '|3,0,10,5,1,1,1,"x"') " invalid register type
|
|
call add(lines, '|3,0,10,1,20,1,1,"x"') " invalid line count
|
|
call add(lines, '|3,0,10,1,0,1,1') " zero line count
|
|
|
|
" bad viminfo syntax for mark barline
|
|
call add(lines, '|4') " invalid number of fields in a mark barline
|
|
call add(lines, '|4,1,1,1,1,1') " invalid value for file name
|
|
call add(lines, '|4,20,1,1,1,"x"') " invalid value for file name
|
|
call add(lines, '|4,49,0,1,1,"x"') " invalid value for line number
|
|
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
rviminfo Xviminfo
|
|
endfunc
|
|
|
|
" This used to crash Vim (GitHub issue #12652)
|
|
func Test_viminfo_bad_syntax3()
|
|
let lines =<< trim END
|
|
call writefile([], 'Xvbs3.result')
|
|
qall!
|
|
END
|
|
call writefile(lines, 'Xvbs3script', 'D')
|
|
|
|
let lines = []
|
|
call add(lines, '|1,4')
|
|
" bad viminfo syntax for register barline
|
|
call add(lines, '|3,1,1,1,1,0,71489,,125') " empty line1
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
|
|
call RunVim([], [], '--clean -i Xviminfo -S Xvbs3script')
|
|
call assert_true(filereadable('Xvbs3.result'))
|
|
|
|
call delete('Xvbs3.result')
|
|
endfunc
|
|
|
|
func Test_viminfo_file_marks()
|
|
silent! bwipe test_viminfo.vim
|
|
silent! bwipe Xviminfo
|
|
|
|
call test_settime(10)
|
|
edit ten
|
|
call test_settime(25)
|
|
edit again
|
|
call test_settime(30)
|
|
edit thirty
|
|
wviminfo Xviminfo
|
|
|
|
call test_settime(20)
|
|
edit twenty
|
|
call test_settime(35)
|
|
edit again
|
|
call test_settime(40)
|
|
edit forty
|
|
wviminfo Xviminfo
|
|
|
|
sp Xviminfo
|
|
1
|
|
for name in ['forty', 'again', 'thirty', 'twenty', 'ten']
|
|
/^>
|
|
call assert_equal(name, substitute(getline('.'), '.*/', '', ''))
|
|
endfor
|
|
close
|
|
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
func Test_viminfo_file_mark_tabclose()
|
|
tabnew Xtestfileintab
|
|
call setline(1, ['a','b','c','d','e'])
|
|
4
|
|
q!
|
|
wviminfo Xviminfo
|
|
sp Xviminfo
|
|
/^> .*Xtestfileintab
|
|
let lnum = line('.')
|
|
while 1
|
|
if lnum == line('$')
|
|
call assert_report('mark not found in Xtestfileintab')
|
|
break
|
|
endif
|
|
let lnum += 1
|
|
let line = getline(lnum)
|
|
if line == ''
|
|
call assert_report('mark not found in Xtestfileintab')
|
|
break
|
|
endif
|
|
if line =~ "^\t\""
|
|
call assert_equal('4', substitute(line, ".*\"\t\\(\\d\\).*", '\1', ''))
|
|
break
|
|
endif
|
|
endwhile
|
|
|
|
call delete('Xviminfo')
|
|
silent! bwipe Xtestfileintab
|
|
endfunc
|
|
|
|
func Test_viminfo_file_mark_zero_time()
|
|
let lines = [
|
|
\ '# Viminfo version',
|
|
\ '|1,4',
|
|
\ '',
|
|
\ '*encoding=utf-8',
|
|
\ '',
|
|
\ '# File marks:',
|
|
\ "'B 1 0 /tmp/nothing",
|
|
\ '|4,66,1,0,0,"/tmp/nothing"',
|
|
\ "",
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
delmark B
|
|
rviminfo Xviminfo
|
|
call assert_equal(1, line("'B"))
|
|
delmark B
|
|
endfunc
|
|
|
|
" Test for saving and restoring file marks in unloaded buffers
|
|
func Test_viminfo_file_mark_unloaded_buf()
|
|
let save_viminfo = &viminfo
|
|
set viminfo&vim
|
|
call writefile(repeat(['vim'], 10), 'Xfile1', 'D')
|
|
%bwipe
|
|
edit! Xfile1
|
|
call setpos("'u", [0, 3, 1, 0])
|
|
call setpos("'v", [0, 5, 1, 0])
|
|
enew
|
|
wviminfo Xviminfo
|
|
%bwipe
|
|
edit Xfile1
|
|
rviminfo! Xviminfo
|
|
call assert_equal([0, 3, 1, 0], getpos("'u"))
|
|
call assert_equal([0, 5, 1, 0], getpos("'v"))
|
|
%bwipe
|
|
call delete('Xviminfo')
|
|
let &viminfo = save_viminfo
|
|
endfunc
|
|
|
|
func Test_viminfo_oldfiles()
|
|
set noswapfile
|
|
let v:oldfiles = []
|
|
let lines = [
|
|
\ '# comment line',
|
|
\ '*encoding=utf-8',
|
|
\ '',
|
|
\ ':h viminfo',
|
|
\ '?/session',
|
|
\ '=myvar',
|
|
\ '@123',
|
|
\ '',
|
|
\ "'E 2 0 /tmp/nothing",
|
|
\ '',
|
|
\ "> /tmp/file_one.txt",
|
|
\ "\t\"\t11\t0",
|
|
\ "",
|
|
\ "> /tmp/file_two.txt",
|
|
\ "\t\"\t11\t0",
|
|
\ "",
|
|
\ "> /tmp/another.txt",
|
|
\ "\t\"\t11\t0",
|
|
\ "",
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
delmark E
|
|
edit /tmp/file_two.txt
|
|
rviminfo! Xviminfo
|
|
|
|
call assert_equal('h viminfo', histget(':'))
|
|
call assert_equal('session', histget('/'))
|
|
call assert_equal('myvar', histget('='))
|
|
call assert_equal('123', histget('@'))
|
|
call assert_equal(2, line("'E"))
|
|
call assert_equal(['1: /tmp/file_one.txt', '2: /tmp/file_two.txt', '3: /tmp/another.txt'], filter(split(execute('oldfiles'), "\n"), {i, v -> v =~ '/tmp/'}))
|
|
call assert_equal(['1: /tmp/file_one.txt', '2: /tmp/file_two.txt'], filter(split(execute('filter file_ oldfiles'), "\n"), {i, v -> v =~ '/tmp/'}))
|
|
call assert_equal(['3: /tmp/another.txt'], filter(split(execute('filter /another/ oldfiles'), "\n"), {i, v -> v =~ '/tmp/'}))
|
|
|
|
new
|
|
call feedkeys("3\<CR>", 't')
|
|
browse oldfiles
|
|
call assert_equal("/tmp/another.txt", expand("%"))
|
|
bwipe
|
|
delmark E
|
|
set swapfile&
|
|
endfunc
|
|
|
|
" Test for storing and restoring buffer list in 'viminfo'
|
|
func Test_viminfo_bufferlist()
|
|
" If there are arguments, then :rviminfo doesn't read the buffer list.
|
|
" Need to delete all the arguments for :rviminfo to work.
|
|
%argdelete
|
|
set viminfo&vim
|
|
|
|
edit Xfile1
|
|
edit Xfile2
|
|
set viminfo-=%
|
|
wviminfo Xviminfo
|
|
%bwipe
|
|
rviminfo Xviminfo
|
|
call assert_equal(1, len(getbufinfo()))
|
|
|
|
edit Xfile1
|
|
edit Xfile2
|
|
set viminfo^=%
|
|
wviminfo Xviminfo
|
|
%bwipe
|
|
rviminfo Xviminfo
|
|
let l = getbufinfo()
|
|
call assert_equal(3, len(l))
|
|
call assert_equal('Xfile1', bufname(l[1].bufnr))
|
|
call assert_equal('Xfile2', bufname(l[2].bufnr))
|
|
|
|
" The quickfix, terminal, unlisted, unnamed buffers are not stored in the
|
|
" viminfo file
|
|
%bw!
|
|
edit Xfile1
|
|
new
|
|
setlocal nobuflisted
|
|
new
|
|
copen
|
|
if has('terminal')
|
|
terminal
|
|
endif
|
|
wviminfo! Xviminfo
|
|
%bwipe!
|
|
rviminfo Xviminfo
|
|
let l = getbufinfo()
|
|
call assert_equal(2, len(l))
|
|
call assert_true(bufexists('Xfile1'))
|
|
|
|
" If a count is specified for '%', then only that many buffers should be
|
|
" stored in the viminfo file.
|
|
%bw!
|
|
set viminfo&vim
|
|
new Xbuf1
|
|
new Xbuf2
|
|
set viminfo+=%1
|
|
wviminfo! Xviminfo
|
|
%bwipe!
|
|
rviminfo! Xviminfo
|
|
let l = getbufinfo()
|
|
call assert_equal(2, len(l))
|
|
call assert_true(bufexists('Xbuf1'))
|
|
call assert_false(bufexists('Xbuf2'))
|
|
|
|
call delete('Xviminfo')
|
|
%bwipe
|
|
set viminfo&vim
|
|
endfunc
|
|
|
|
" Test for errors in a viminfo file
|
|
func Test_viminfo_error()
|
|
" Non-existing viminfo files
|
|
call assert_fails('rviminfo xyz', 'E195:')
|
|
|
|
" Illegal starting character
|
|
call writefile(["a 123"], 'Xviminfo', 'D')
|
|
call assert_fails('rv Xviminfo', 'E575:')
|
|
|
|
" Illegal register name in the viminfo file
|
|
call writefile(['"@ LINE 0'], 'Xviminfo')
|
|
call assert_fails('rv Xviminfo', 'E577:')
|
|
|
|
" Invalid file mark line
|
|
call writefile(['>', '@'], 'Xviminfo')
|
|
call assert_fails('rv Xviminfo', 'E576:')
|
|
|
|
" Too many errors in viminfo file
|
|
call writefile(repeat(["a 123"], 15), 'Xviminfo')
|
|
call assert_fails('rv Xviminfo', 'E575:')
|
|
|
|
call writefile(['>'] + repeat(['@'], 10), 'Xviminfo')
|
|
call assert_fails('rv Xviminfo', 'E576:')
|
|
|
|
call writefile(repeat(['"@'], 15), 'Xviminfo')
|
|
call assert_fails('rv Xviminfo', 'E577:')
|
|
endfunc
|
|
|
|
" Test for saving and restoring last substitute string in viminfo
|
|
func Test_viminfo_lastsub()
|
|
enew
|
|
call append(0, "blue blue blue")
|
|
call cursor(1, 1)
|
|
s/blue/green/
|
|
wviminfo Xviminfo
|
|
s/blue/yellow/
|
|
rviminfo! Xviminfo
|
|
&
|
|
call assert_equal("green yellow green", getline(1))
|
|
enew!
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
" Test saving and restoring the register values using the older method
|
|
func Test_viminfo_registers_old()
|
|
let lines = [
|
|
\ '# Viminfo version',
|
|
\ '|1,1',
|
|
\ '',
|
|
\ '*encoding=utf-8',
|
|
\ '',
|
|
\ '# Registers:',
|
|
\ '""0 CHAR 0',
|
|
\ ' Vim',
|
|
\ '"a CHAR 0',
|
|
\ ' red',
|
|
\ '"c BLOCK 0',
|
|
\ ' a',
|
|
\ ' d',
|
|
\ '"d LINE 0',
|
|
\ ' abc',
|
|
\ ' def',
|
|
\ '"m@ CHAR 0',
|
|
\ " :echo 'Hello'\<CR>",
|
|
\ "",
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
let @a = 'one'
|
|
let @b = 'two'
|
|
let @m = 'three'
|
|
let @" = 'four'
|
|
let @t = ":echo 'Unix'\<CR>"
|
|
silent! normal @t
|
|
rviminfo! Xviminfo
|
|
call assert_equal('red', getreg('a'))
|
|
call assert_equal("v", getregtype('a'))
|
|
call assert_equal('two', getreg('b'))
|
|
call assert_equal("a\nd", getreg('c'))
|
|
call assert_equal("\<C-V>1", getregtype('c'))
|
|
call assert_equal("abc\ndef\n", getreg('d'))
|
|
call assert_equal("V", getregtype('d'))
|
|
call assert_equal(":echo 'Hello'\<CR>", getreg('m'))
|
|
call assert_equal('Vim', getreg('"'))
|
|
call assert_equal("\nHello", execute('normal @@'))
|
|
|
|
let @" = ''
|
|
endfunc
|
|
|
|
" Test for saving and restoring large number of lines in a register
|
|
func Test_viminfo_large_register()
|
|
let save_viminfo = &viminfo
|
|
set viminfo&vim
|
|
set viminfo-=<50
|
|
set viminfo+=<200
|
|
let lines = ['"r CHAR 0']
|
|
call extend(lines, repeat(["\tsun is rising"], 200))
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
let @r = ''
|
|
rviminfo! Xviminfo
|
|
call assert_equal(join(repeat(["sun is rising"], 200), "\n"), @r)
|
|
|
|
let @r = ''
|
|
let &viminfo = save_viminfo
|
|
endfunc
|
|
|
|
" Test for setting 'viminfofile' to NONE
|
|
func Test_viminfofile_none()
|
|
let save_vif = &viminfofile
|
|
set viminfofile=NONE
|
|
wviminfo Xviminfo
|
|
call assert_false(filereadable('Xviminfo'))
|
|
call writefile([''], 'Xviminfo', 'D')
|
|
call assert_fails('rviminfo Xviminfo', 'E195:')
|
|
|
|
let &viminfofile = save_vif
|
|
endfunc
|
|
|
|
" Test for an unwritable and unreadable 'viminfo' file
|
|
func Test_viminfo_perm()
|
|
CheckUnix
|
|
CheckNotRoot
|
|
call writefile([''], 'Xviminfo', 'D')
|
|
call setfperm('Xviminfo', 'r-x------')
|
|
call assert_fails('wviminfo Xviminfo', 'E137:')
|
|
call setfperm('Xviminfo', '--x------')
|
|
call assert_fails('rviminfo Xviminfo', 'E195:')
|
|
|
|
" Try to write the viminfo to a directory
|
|
call mkdir('Xvifdir', 'R')
|
|
call assert_fails('wviminfo Xvifdir', 'E137:')
|
|
call assert_fails('rviminfo Xvifdir', 'E195:')
|
|
endfunc
|
|
|
|
" Test for writing to an existing viminfo file merges the file marks
|
|
func XTest_viminfo_marks_merge()
|
|
let save_viminfo = &viminfo
|
|
set viminfo&vim
|
|
set viminfo^=%
|
|
enew
|
|
%argdelete
|
|
%bwipe
|
|
|
|
call writefile(repeat(['editor'], 10), 'Xbufa', 'D')
|
|
call writefile(repeat(['Vim'], 10), 'Xbufb', 'D')
|
|
|
|
" set marks in buffers
|
|
call test_settime(10)
|
|
edit Xbufa
|
|
4mark a
|
|
wviminfo Xviminfo
|
|
edit Xbufb
|
|
4mark b
|
|
wviminfo Xviminfo
|
|
%bwipe
|
|
|
|
" set marks in buffers again
|
|
call test_settime(20)
|
|
edit Xbufb
|
|
6mark b
|
|
wviminfo Xviminfo
|
|
edit Xbufa
|
|
6mark a
|
|
wviminfo Xviminfo
|
|
%bwipe
|
|
|
|
" Load the buffer and check the marks
|
|
edit Xbufa
|
|
rviminfo! Xviminfo
|
|
call assert_equal(6, line("'a"))
|
|
edit Xbufb
|
|
rviminfo! Xviminfo
|
|
call assert_equal(6, line("'b"))
|
|
|
|
" cleanup
|
|
%bwipe
|
|
call delete('Xviminfo')
|
|
call test_settime(0)
|
|
let &viminfo=save_viminfo
|
|
endfunc
|
|
|
|
" Test for errors in setting 'viminfo'
|
|
func Test_viminfo_option_error()
|
|
" Missing number
|
|
call assert_fails('set viminfo=\"', 'E526:')
|
|
for c in split("'/:<@s", '\zs')
|
|
call assert_fails('set viminfo=' .. c, 'E526:')
|
|
endfor
|
|
|
|
" Missing comma
|
|
call assert_fails('set viminfo=%10!', 'E527:')
|
|
call assert_fails('set viminfo=!%10', 'E527:')
|
|
call assert_fails('set viminfo=h%10', 'E527:')
|
|
call assert_fails('set viminfo=c%10', 'E527:')
|
|
call assert_fails('set viminfo=:10%10', 'E527:')
|
|
|
|
" Missing ' setting
|
|
call assert_fails('set viminfo=%10', 'E528:')
|
|
endfunc
|
|
|
|
func Test_viminfo_oldfiles_newfile()
|
|
CheckRunVimInTerminal
|
|
|
|
let save_viminfo = &viminfo
|
|
let save_viminfofile = &viminfofile
|
|
set viminfo&vim
|
|
let v:oldfiles = []
|
|
let commands =<< trim [CODE]
|
|
set viminfofile=Xviminfofile
|
|
set viminfo&vim
|
|
w! Xnew-file.txt
|
|
qall
|
|
[CODE]
|
|
call writefile(commands, 'Xviminfotest', 'D')
|
|
let buf = RunVimInTerminal('-S Xviminfotest', #{wait_for_ruler: 0})
|
|
call WaitForAssert({-> assert_equal("finished", term_getstatus(buf))})
|
|
|
|
let &viminfofile = 'Xviminfofile'
|
|
rviminfo! Xviminfofile
|
|
call assert_match('Xnew-file.txt$', v:oldfiles[0])
|
|
call assert_equal(1, len(v:oldfiles))
|
|
|
|
call delete('Xviminfofile')
|
|
call delete('Xnew-file.txt')
|
|
|
|
let v:oldfiles = test_null_list()
|
|
call assert_equal("\nNo old files", execute('oldfiles'))
|
|
|
|
let &viminfo = save_viminfo
|
|
let &viminfofile = save_viminfofile
|
|
endfunc
|
|
|
|
" When writing CTRL-V or "\n" to a viminfo file, it is converted to CTRL-V
|
|
" CTRL-V and CTRL-V n respectively.
|
|
func Test_viminfo_with_Ctrl_V()
|
|
silent! exe "normal! /\<C-V>\<C-V>\n"
|
|
wviminfo Xviminfo
|
|
call assert_notequal(-1, readfile('Xviminfo')->index("?/\<C-V>\<C-V>"))
|
|
let @/ = 'abc'
|
|
rviminfo! Xviminfo
|
|
call assert_equal("\<C-V>", @/)
|
|
silent! exe "normal! /\<C-V>\<C-J>\n"
|
|
wviminfo Xviminfo
|
|
call assert_notequal(-1, readfile('Xviminfo')->index("?/\<C-V>n"))
|
|
let @/ = 'abc'
|
|
rviminfo! Xviminfo
|
|
call assert_equal("\n", @/)
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
" Test for the 'r' field in 'viminfo' (removal media)
|
|
func Test_viminfo_removable_media()
|
|
CheckUnix
|
|
if !isdirectory('/tmp') || getftype('/tmp') != 'dir'
|
|
return
|
|
endif
|
|
let save_viminfo = &viminfo
|
|
set viminfo+=r/tmp
|
|
edit /tmp/Xvima1b2c3
|
|
wviminfo Xviminfo
|
|
let matches = readfile('Xviminfo')->filter("v:val =~ 'Xvima1b2c3'")
|
|
call assert_equal(0, matches->len())
|
|
let &viminfo = save_viminfo
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
" Test for the 'h' flag in 'viminfo'. If 'h' is not present, then the last
|
|
" search pattern read from 'viminfo' should be highlighted with 'hlsearch'.
|
|
" If 'h' is present, then the last search pattern should not be highlighted.
|
|
func Test_viminfo_hlsearch()
|
|
set viminfo&vim
|
|
|
|
new
|
|
call setline(1, ['one two three'])
|
|
" save the screen attribute for the Search highlighted text and the normal
|
|
" text for later comparison
|
|
set hlsearch
|
|
let @/ = 'three'
|
|
redraw!
|
|
let hiSearch = screenattr(1, 9)
|
|
let hiNormal = screenattr(1, 1)
|
|
|
|
set viminfo-=h
|
|
let @/='two'
|
|
wviminfo! Xviminfo
|
|
let @/='one'
|
|
rviminfo! Xviminfo
|
|
redraw!
|
|
call assert_equal(hiSearch, screenattr(1, 5))
|
|
call assert_equal(hiSearch, screenattr(1, 6))
|
|
call assert_equal(hiSearch, screenattr(1, 7))
|
|
|
|
set viminfo+=h
|
|
let @/='two'
|
|
wviminfo! Xviminfo
|
|
let @/='one'
|
|
rviminfo! Xviminfo
|
|
redraw!
|
|
call assert_equal(hiNormal, screenattr(1, 5))
|
|
call assert_equal(hiNormal, screenattr(1, 6))
|
|
call assert_equal(hiNormal, screenattr(1, 7))
|
|
|
|
call delete('Xviminfo')
|
|
set hlsearch& viminfo&vim
|
|
bw!
|
|
endfunc
|
|
|
|
" Test for restoring the magicness of the last search pattern from the viminfo
|
|
" file.
|
|
func Test_viminfo_last_spat_magic()
|
|
set viminfo&vim
|
|
new
|
|
call setline(1, ' one abc a.c')
|
|
|
|
" restore 'nomagic'
|
|
set nomagic
|
|
exe "normal gg/a.c\<CR>"
|
|
wviminfo! Xviminfo
|
|
set magic
|
|
exe "normal gg/one\<CR>"
|
|
rviminfo! Xviminfo
|
|
exe "normal! gg/\<CR>"
|
|
call assert_equal(10, col('.'))
|
|
|
|
" restore 'magic'
|
|
set magic
|
|
exe "normal gg/a.c\<CR>"
|
|
wviminfo! Xviminfo
|
|
set nomagic
|
|
exe "normal gg/one\<CR>"
|
|
rviminfo! Xviminfo
|
|
exe "normal! gg/\<CR>"
|
|
call assert_equal(6, col('.'))
|
|
|
|
call delete('Xviminfo')
|
|
set viminfo&vim magic&
|
|
bw!
|
|
endfunc
|
|
|
|
" Test for restoring the smartcase of the last search pattern from the viminfo
|
|
" file.
|
|
func Test_viminfo_last_spat_smartcase()
|
|
new
|
|
call setline(1, ' one abc Abc')
|
|
set ignorecase smartcase
|
|
|
|
" Searching with * should disable smartcase
|
|
exe "normal! gg$b*"
|
|
wviminfo! Xviminfo
|
|
exe "normal gg/one\<CR>"
|
|
rviminfo! Xviminfo
|
|
exe "normal! gg/\<CR>"
|
|
call assert_equal(6, col('.'))
|
|
|
|
call delete('Xviminfo')
|
|
set ignorecase& smartcase& viminfo&
|
|
bw!
|
|
endfunc
|
|
|
|
" Test for restoring the last search pattern with a line or character offset
|
|
" from the viminfo file.
|
|
func Test_viminfo_last_spat_offset()
|
|
new
|
|
call setline(1, ['one', 'two', 'three', 'four', 'five'])
|
|
" line offset
|
|
exe "normal! /two/+2\<CR>"
|
|
wviminfo! Xviminfo
|
|
exe "normal gg/five\<CR>"
|
|
rviminfo! Xviminfo
|
|
exe "normal! gg/\<CR>"
|
|
call assert_equal(4, line('.'))
|
|
" character offset
|
|
exe "normal! gg/^th/e+2\<CR>"
|
|
wviminfo! Xviminfo
|
|
exe "normal gg/two\<CR>"
|
|
rviminfo! Xviminfo
|
|
exe "normal! gg/\<CR>"
|
|
call assert_equal([3, 4], [line('.'), col('.')])
|
|
call delete('Xviminfo')
|
|
bw!
|
|
endfunc
|
|
|
|
" Test for saving and restoring the last executed register (@ command)
|
|
" from the viminfo file
|
|
func Test_viminfo_last_exec_reg()
|
|
let g:val = 1
|
|
let @a = ":let g:val += 1\n"
|
|
normal! @a
|
|
wviminfo! Xviminfo
|
|
let @b = ''
|
|
normal! @b
|
|
rviminfo! Xviminfo
|
|
normal @@
|
|
call assert_equal(3, g:val)
|
|
call delete('Xviminfo')
|
|
endfunc
|
|
|
|
" Test for merging file marks in a viminfo file
|
|
func Test_viminfo_merge_file_marks()
|
|
for [f, l, t] in [['a.txt', 5, 10], ['b.txt', 10, 20]]
|
|
call test_settime(t)
|
|
exe 'edit ' .. f
|
|
call setline(1, range(1, 20))
|
|
exe l . 'mark a'
|
|
wviminfo Xviminfo
|
|
bw!
|
|
endfor
|
|
call test_settime(30)
|
|
for [f, l] in [['a.txt', 5], ['b.txt', 10]]
|
|
exe 'edit ' .. f
|
|
rviminfo! Xviminfo
|
|
call assert_equal(l, line("'a"))
|
|
bw!
|
|
endfor
|
|
call delete('Xviminfo')
|
|
call test_settime(0)
|
|
endfunc
|
|
|
|
" Test for merging file marks from a old viminfo file
|
|
func Test_viminfo_merge_old_filemarks()
|
|
let lines = []
|
|
call add(lines, '|1,4')
|
|
call add(lines, '> ' .. fnamemodify('a.txt', ':p:~'))
|
|
call add(lines, "\tb\t7\t0\n")
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
edit b.txt
|
|
call setline(1, range(1, 20))
|
|
12mark b
|
|
wviminfo Xviminfo
|
|
bw!
|
|
edit a.txt
|
|
rviminfo! Xviminfo
|
|
call assert_equal(7, line("'b"))
|
|
edit b.txt
|
|
rviminfo! Xviminfo
|
|
call assert_equal(12, line("'b"))
|
|
endfunc
|
|
|
|
" Test for merging the jump list from a old viminfo file
|
|
func Test_viminfo_merge_old_jumplist()
|
|
let lines = []
|
|
call add(lines, "-' 10 1 " .. fnamemodify('a.txt', ':p:~'))
|
|
call add(lines, "-' 20 1 " .. fnamemodify('a.txt', ':p:~'))
|
|
call add(lines, "-' 30 1 " .. fnamemodify('b.txt', ':p:~'))
|
|
call add(lines, "-' 40 1 " .. fnamemodify('b.txt', ':p:~'))
|
|
call writefile(lines, 'Xviminfo', 'D')
|
|
clearjumps
|
|
rviminfo! Xviminfo
|
|
let l = getjumplist()[0]
|
|
call assert_equal([40, 30, 20, 10], [l[0].lnum, l[1].lnum, l[2].lnum,
|
|
\ l[3].lnum])
|
|
bw!
|
|
endfunc
|
|
|
|
func Test_viminfo_oldfiles_filter()
|
|
let v:oldfiles = []
|
|
let _viminfofile = &viminfofile
|
|
let &viminfofile=''
|
|
let lines = [
|
|
\ '# comment line',
|
|
\ '*encoding=utf-8',
|
|
\ "> /tmp/vimrc_one.vim",
|
|
\ "\t\"\t11\t0",
|
|
\ "",
|
|
\ "> /tmp/foobar.txt",
|
|
\ "\t\"\t11\t0",
|
|
\ "",
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo1', 'D')
|
|
rviminfo! Xviminfo1
|
|
new
|
|
" filter returns a single item
|
|
let a = execute('filter /vim/ oldfiles')->split('\n')
|
|
call assert_equal(1, len(a))
|
|
" filter returns more than a single match
|
|
let a = execute('filter #tmp# oldfiles')->split('\n')
|
|
call assert_equal(2, len(a))
|
|
" don't get prompted for the file, but directly open it
|
|
filter /vim/ browse oldfiles
|
|
call assert_equal("/tmp/vimrc_one.vim", expand("%"))
|
|
bw
|
|
let &viminfofile = _viminfofile
|
|
endfunc
|
|
|
|
func Test_viminfo_global_var()
|
|
let _viminfofile = &viminfofile
|
|
let _viminfo = &viminfo
|
|
let &viminfofile=''
|
|
set viminfo+=!
|
|
let lines = [
|
|
\ '# comment line',
|
|
\ "",
|
|
\ '# Viminfo version',
|
|
\ '|1,4',
|
|
\ "",
|
|
\ '*encoding=utf-8',
|
|
\ "",
|
|
\ '# global variables:',
|
|
\ "!VAL\tFLO\t-in",
|
|
\ "!VAR\tFLO\t-inf",
|
|
\ "",
|
|
\ ]
|
|
call writefile(lines, 'Xviminfo2', 'D')
|
|
rviminfo! Xviminfo2
|
|
call assert_equal(0.0, g:VAL)
|
|
call assert_equal(str2float("-inf"), g:VAR)
|
|
let &viminfofile = _viminfofile
|
|
let &viminfo = _viminfo
|
|
endfunc
|
|
|
|
" vim: shiftwidth=2 sts=2 expandtab
|