diff options
Diffstat (limited to 'data/vim/patches/8.1.0132')
| -rw-r--r-- | data/vim/patches/8.1.0132 | 737 |
1 files changed, 737 insertions, 0 deletions
diff --git a/data/vim/patches/8.1.0132 b/data/vim/patches/8.1.0132 new file mode 100644 index 000000000..2271859db --- /dev/null +++ b/data/vim/patches/8.1.0132 @@ -0,0 +1,737 @@ +To: vim_dev@googlegroups.com +Subject: Patch 8.1.0132 +Fcc: outbox +From: Bram Moolenaar <Bram@moolenaar.net> +Mime-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit +------------ + +Patch 8.1.0132 +Problem: Lua tests are old style. +Solution: Convert to new style tests. Improve coverage. (Dominique Pelle, + closes #3091) +Files: src/Makefile, src/testdir/Make_all.mak, + src/testdir/Make_amiga.mak, src/testdir/Make_vms.mms, + src/testdir/test85.in, src/testdir/test_lua.vim + + +*** ../vim-8.1.0131/src/Makefile 2018-06-23 19:22:45.618486231 +0200 +--- src/Makefile 2018-06-30 21:22:17.965276852 +0200 +*************** +*** 2119,2125 **** + test52 test59 \ + test64 test69 \ + test70 test72 \ +! test85 test86 test87 test88 \ + test94 test95 test99 test108: + cd testdir; rm -f $@.out; $(MAKE) -f Makefile $@.out VIMPROG=../$(VIMTESTTARGET) $(GUI_TESTARG) SCRIPTSOURCE=../$(SCRIPTSOURCE) + +--- 2119,2125 ---- + test52 test59 \ + test64 test69 \ + test70 test72 \ +! test86 test87 test88 \ + test94 test95 test99 test108: + cd testdir; rm -f $@.out; $(MAKE) -f Makefile $@.out VIMPROG=../$(VIMTESTTARGET) $(GUI_TESTARG) SCRIPTSOURCE=../$(SCRIPTSOURCE) + +*** ../vim-8.1.0131/src/testdir/Make_all.mak 2018-06-23 19:22:45.614486258 +0200 +--- src/testdir/Make_all.mak 2018-06-30 21:20:58.605620983 +0200 +*************** +*** 36,42 **** + SCRIPTS_MORE1 = \ + test11.out \ + test52.out \ +- test85.out \ + test86.out \ + test87.out + +--- 36,41 ---- +*** ../vim-8.1.0131/src/testdir/Make_amiga.mak 2017-11-02 20:58:54.000000000 +0100 +--- src/testdir/Make_amiga.mak 2018-06-30 21:20:58.605620983 +0200 +*************** +*** 14,20 **** + # test10 'errorformat' is different + # test11 "cat" doesn't work properly + # test52 only for Win32 +- # test85 no Lua interface + # test86, 87 no Python interface + + SCRIPTS = $(SCRIPTS_ALL) $(SCRIPTS_MORE4) +--- 14,19 ---- +*** ../vim-8.1.0131/src/testdir/Make_vms.mms 2018-01-31 19:23:08.000000000 +0100 +--- src/testdir/Make_vms.mms 2018-06-30 21:20:58.605620983 +0200 +*************** +*** 93,99 **** + # + # test72: bug - Vim hangs at :rename (while rename works well otherwise) + # test78: bug - Vim dies at :recover Xtest +- # test85: no Lua interface + # test89: bug - findfile() does not work on VMS (just in the current directory) + # test102: Just ODS-5 supports space and special chars in the filename. + # On ODS-2 tests fail. +--- 93,98 ---- +*************** +*** 119,127 **** + SCRIPT_MZSCH = test70.out + .ENDIF + +! .IFDEF HAVE_ODS5 +! SCRIPT_ODS5 = test102.out +! .ENDIF + + .IFDEF HAVE_GZIP + SCRIPT_GZIP = test11.out +--- 118,126 ---- + SCRIPT_MZSCH = test70.out + .ENDIF + +! .IFDEF HAVE_ODS5 +! SCRIPT_ODS5 = test102.out +! .ENDIF + + .IFDEF HAVE_GZIP + SCRIPT_GZIP = test11.out +*************** +*** 131,140 **** + SCRIPT_GDIFF = test47.out + .ENDIF + +- .IFDEF HAVE_LUA +- SCRIPT_LUA = test85.out +- .ENDIF +- + .IFDEF HAVE_PYTHON + SCRIPT_PYTHON = test86.out test87.out + .ENDIF +--- 130,135 ---- +*** ../vim-8.1.0131/src/testdir/test85.in 2017-03-08 22:48:59.000000000 +0100 +--- src/testdir/test85.in 1970-01-01 01:00:00.000000000 +0100 +*************** +*** 1,86 **** +- Test for Lua interface and luaeval() function +- +- STARTTEST +- :so small.vim +- :set belloff=all +- :so lua.vim +- :set nocompatible viminfo+=nviminfo +- :lua l = vim.list():add"item0":add"dictionary with list OK":add"item2" +- :lua h = vim.dict(); h.list = l +- :call garbagecollect() +- /^1 +- :" change buffer contents +- :lua curbuf = vim.buffer() +- :lua curline = vim.eval"line('.')" +- :lua curbuf[curline] = "1 changed line 1" +- :" scalar test +- :let tmp_string = luaeval('"string"') +- :let tmp_1000 = luaeval('1000') +- :if printf("%s%.0f", tmp_string, tmp_1000) == "string1000" +- :let scalar_res = "OK" +- :else +- :let scalar_res = "FAILED" +- :endif +- :call append(search("^1"), "scalar test " . scalar_res) +- :" dictionary containing a list +- :let tmp = luaeval("h").list[1] +- :/^2/put =tmp +- :" circular list (at the same time test lists containing lists) +- :lua l[2] = l +- :let l2 = luaeval("h").list +- :if l2[2] == l2 +- :let res = "OK" +- :else +- :let res = "FAILED" +- :endif +- :call setline(search("^3"), "circular test " . res) +- +- :let l = [] +- :lua l = vim.eval("l") +- :lua l:add(123) +- :lua l:add("abc") +- :lua l:add(vim.eval("[1, 2, 3]")) +- :lua l:add(vim.eval("{'a':1, 'b':2, 'c':3}")) +- :lua l:insert(123) +- :lua l:insert("abc") +- :lua l:insert(vim.eval("[1, 2, 3]")) +- :lua l:insert(vim.eval("{'a':1, 'b':2, 'c':3}")) +- :lua l[0] = l[0] +- :lua l[1] = l[1] +- :lua l[2] = l[2] +- :lua l[3] = l[3] +- :lua l[0] = 123 +- :lua l[1] = "abc" +- :lua l[2] = vim.eval("[1, 2, 3]") +- :lua l[3] = vim.eval("{'a':1, 'b':2, 'c':3}") +- :lua l[3] = nil +- :lua l[2] = nil +- :lua l[1] = nil +- :lua l[0] = nil +- :lua l = nil +- :$put =string(l) +- +- :let d = {} +- :lua d = vim.eval("d") +- :lua d[0] = 123 +- :lua d[1] = "abc" +- :lua d[2] = vim.eval("[1, 2, 3]") +- :lua d[3] = vim.eval("{'a':1, 'b':2, 'c':3}") +- :lua d[4] = d[0] +- :lua d[5] = d[1] +- :lua d[6] = d[2] +- :lua d[7] = d[3] +- :lua d[3] = nil +- :lua d[2] = nil +- :lua d[1] = nil +- :lua d[0] = nil +- :lua d = nil +- :$put =string(d) +- +- :?^1?,$w! test.out +- :qa! +- ENDTEST +- +- 1 line 1 +- 2 line 2 +- 3 line 3 +--- 0 ---- +*** ../vim-8.1.0131/src/testdir/test_lua.vim 2017-01-29 22:39:50.000000000 +0100 +--- src/testdir/test_lua.vim 2018-06-30 21:20:58.609620966 +0200 +*************** +*** 1,22 **** + " Tests for Lua. +- " TODO: move tests from test85.in here. + + if !has('lua') + finish + endif + +! func Test_luado() +! new +! call setline(1, ['one', 'two', 'three']) +! luado vim.command("%d_") +! bwipe! +! +! " Check switching to another buffer does not trigger ml_get error. + new + let wincount = winnr('$') + call setline(1, ['one', 'two', 'three']) + luado vim.command("new") + call assert_equal(wincount + 1, winnr('$')) + bwipe! + bwipe! + endfunc +--- 1,494 ---- + " Tests for Lua. + + if !has('lua') + finish + endif + +! " Check that switching to another buffer does not trigger ml_get error. +! func Test_command_new_no_ml_get_error() + new + let wincount = winnr('$') + call setline(1, ['one', 'two', 'three']) + luado vim.command("new") + call assert_equal(wincount + 1, winnr('$')) ++ %bwipe! ++ endfunc ++ ++ " Test vim.command() ++ func Test_command() ++ new ++ call setline(1, ['one', 'two', 'three']) ++ luado vim.command("1,2d_") ++ call assert_equal(['three'], getline(1, '$')) ++ bwipe! ++ endfunc ++ ++ " Test vim.eval() ++ func Test_eval() ++ " lua.eval with a number ++ lua v = vim.eval('123') ++ call assert_equal('number', luaeval('vim.type(v)')) ++ call assert_equal(123.0, luaeval('v')) ++ ++ " lua.eval with a string ++ lua v = vim.eval('"abc"') ++ call assert_equal('string', luaeval('vim.type(v)')) ++ call assert_equal('abc', luaeval('v')) ++ ++ " lua.eval with a list ++ lua v = vim.eval("['a']") ++ call assert_equal('list', luaeval('vim.type(v)')) ++ call assert_equal(['a'], luaeval('v')) ++ ++ " lua.eval with a dict ++ lua v = vim.eval("{'a':'b'}") ++ call assert_equal('dict', luaeval('vim.type(v)')) ++ call assert_equal({'a':'b'}, luaeval('v')) ++ ++ call assert_fails('lua v = vim.eval(nil)', ++ \ "[string \"vim chunk\"]:1: bad argument #1 to 'eval' (string expected, got nil)") ++ call assert_fails('lua v = vim.eval(true)', ++ \ "[string \"vim chunk\"]:1: bad argument #1 to 'eval' (string expected, got boolean)") ++ call assert_fails('lua v = vim.eval({})', ++ \ "[string \"vim chunk\"]:1: bad argument #1 to 'eval' (string expected, got table)") ++ call assert_fails('lua v = vim.eval(print)', ++ \ "[string \"vim chunk\"]:1: bad argument #1 to 'eval' (string expected, got function)") ++ call assert_fails('lua v = vim.eval(vim.buffer())', ++ \ "[string \"vim chunk\"]:1: bad argument #1 to 'eval' (string expected, got userdata)") ++ ++ lua v = nil ++ endfunc ++ ++ " Test vim.window() ++ func Test_window() ++ e Xfoo2 ++ new Xfoo1 ++ ++ " Window 1 (top window) contains Xfoo1 ++ " Window 2 (bottom window) contains Xfoo2 ++ call assert_equal('Xfoo1', luaeval('vim.window(1):buffer().name')) ++ call assert_equal('Xfoo2', luaeval('vim.window(2):buffer().name')) ++ ++ " Window 3 does not exist so vim.window(3) should return nil ++ call assert_equal('nil', luaeval('tostring(vim.window(3))')) ++ ++ %bwipe! ++ endfunc ++ ++ " Test vim.window().height ++ func Test_window_height() ++ new ++ lua vim.window().height = 2 ++ call assert_equal(2, winheight(0)) ++ lua vim.window().height = vim.window().height + 1 ++ call assert_equal(3, winheight(0)) ++ bwipe! ++ endfunc ++ ++ " Test vim.window().width ++ func Test_window_width() ++ vert new ++ lua vim.window().width = 2 ++ call assert_equal(2, winwidth(0)) ++ lua vim.window().width = vim.window().width + 1 ++ call assert_equal(3, winwidth(0)) ++ bwipe! ++ endfunc ++ ++ " Test vim.window().line and vim.window.col ++ func Test_window_line_col() ++ new ++ call setline(1, ['line1', 'line2', 'line3']) ++ lua vim.window().line = 2 ++ lua vim.window().col = 4 ++ call assert_equal([0, 2, 4, 0], getpos('.')) ++ lua vim.window().line = vim.window().line + 1 ++ lua vim.window().col = vim.window().col - 1 ++ call assert_equal([0, 3, 3, 0], getpos('.')) ++ ++ call assert_fails('lua vim.window().line = 10', ++ \ '[string "vim chunk"]:1: line out of range') ++ bwipe! ++ endfunc ++ ++ " Test setting the current window ++ func Test_window_set_current() ++ new Xfoo1 ++ lua w1 = vim.window() ++ new Xfoo2 ++ lua w2 = vim.window() ++ ++ call assert_equal('Xfoo2', bufname('%')) ++ lua w1() ++ call assert_equal('Xfoo1', bufname('%')) ++ lua w2() ++ call assert_equal('Xfoo2', bufname('%')) ++ ++ lua w1, w2 = nil, nil ++ %bwipe! ++ endfunc ++ ++ " Test vim.window().buffer ++ func Test_window_buffer() ++ new Xfoo1 ++ lua w1 = vim.window() ++ lua b1 = w1.buffer() ++ new Xfoo2 ++ lua w2 = vim.window() ++ lua b2 = w2.buffer() ++ ++ lua b1() ++ call assert_equal('Xfoo1', bufname('%')) ++ lua b2() ++ call assert_equal('Xfoo2', bufname('%')) ++ ++ lua b1, b2 = nil, nil ++ %bwipe! ++ endfunc ++ ++ " Test vim.window():previous() and vim.window():next() ++ func Test_window_next_previous() ++ new Xfoo1 ++ new Xfoo2 ++ new Xfoo3 ++ wincmd j ++ ++ call assert_equal('Xfoo2', luaeval('vim.window().buffer().name')) ++ call assert_equal('Xfoo1', luaeval('vim.window():next():buffer().name')) ++ call assert_equal('Xfoo3', luaeval('vim.window():previous():buffer().name')) ++ ++ %bwipe! ++ endfunc ++ ++ " Test vim.window():isvalid() ++ func Test_window_isvalid() ++ new Xfoo ++ lua w = vim.window() ++ call assert_true(luaeval('w:isvalid()')) ++ ++ " FIXME: how to test the case when isvalid() returns v:false? ++ " isvalid() gives errors when the window is deleted. Is it a bug? ++ ++ lua w = nil ++ bwipe! ++ endfunc ++ ++ " Test vim.buffer() with and without argument ++ func Test_buffer() ++ new Xfoo1 ++ let bn1 = bufnr('%') ++ new Xfoo2 ++ let bn2 = bufnr('%') ++ ++ " Test vim.buffer() without argument. ++ call assert_equal('Xfoo2', luaeval("vim.buffer().name")) ++ ++ " Test vim.buffer() with string argument. ++ call assert_equal('Xfoo1', luaeval("vim.buffer('Xfoo1').name")) ++ call assert_equal('Xfoo2', luaeval("vim.buffer('Xfoo2').name")) ++ ++ " Test vim.buffer() with integer argument. ++ call assert_equal('Xfoo1', luaeval("vim.buffer(" . bn1 . ").name")) ++ call assert_equal('Xfoo2', luaeval("vim.buffer(" . bn2 . ").name")) ++ ++ lua bn1, bn2 = nil, nil ++ %bwipe! ++ endfunc ++ ++ " Test vim.buffer().name and vim.buffer().fname ++ func Test_buffer_name() ++ new ++ " FIXME: for an unnamed buffer, I would expect ++ " vim.buffer().name to give an empty string, but ++ " it returns 0. Is it a bug? ++ " so this assert_equal is commented out. ++ " call assert_equal('', luaeval('vim.buffer().name')) ++ bwipe! ++ ++ new Xfoo ++ call assert_equal('Xfoo', luaeval('vim.buffer().name')) ++ call assert_equal(expand('%:p'), luaeval('vim.buffer().fname')) ++ bwipe! ++ endfunc ++ ++ " Test vim.buffer().number ++ func Test_buffer_number() ++ " All numbers in Lua are floating points number (no integers). ++ call assert_equal(bufnr('%'), float2nr(luaeval('vim.buffer().number'))) ++ endfunc ++ ++ " Test inserting lines in buffer. ++ func Test_buffer_insert() ++ new ++ lua vim.buffer()[1] = '3' ++ lua vim.buffer():insert('1', 0) ++ lua vim.buffer():insert('2', 1) ++ lua vim.buffer():insert('4', 10) ++ ++ call assert_equal(['1', '2', '3', '4'], getline(1, '$')) ++ bwipe! ++ endfunc ++ ++ " Test deleting line in buffer ++ func Test_buffer_delete() ++ new ++ call setline(1, ['1', '2', '3']) ++ lua vim.buffer()[2] = nil ++ call assert_equal(['1', '3'], getline(1, '$')) ++ ++ call assert_fails('lua vim.buffer()[3] = nil', ++ \ '[string "vim chunk"]:1: invalid line number') ++ bwipe! ++ endfunc ++ ++ " Test #vim.buffer() i.e. number of lines in buffer ++ func Test_buffer_number_lines() ++ new ++ call setline(1, ['a', 'b', 'c']) ++ call assert_equal(3.0, luaeval('#vim.buffer()')) ++ bwipe! ++ endfunc ++ ++ " Test vim.buffer():next() and vim.buffer():previous() ++ " Note that these functions get the next or previous buffers ++ " but do not switch buffer. ++ func Test_buffer_next_previous() ++ new Xfoo1 ++ new Xfoo2 ++ new Xfoo3 ++ b Xfoo2 ++ ++ lua bn = vim.buffer():next() ++ lua bp = vim.buffer():previous() ++ ++ call assert_equal('Xfoo2', luaeval('vim.buffer().name')) ++ call assert_equal('Xfoo1', luaeval('bp.name')) ++ call assert_equal('Xfoo3', luaeval('bn.name')) ++ ++ call assert_equal('Xfoo2', bufname('%')) ++ ++ lua bn() ++ call assert_equal('Xfoo3', luaeval('vim.buffer().name')) ++ call assert_equal('Xfoo3', bufname('%')) ++ ++ lua bp() ++ call assert_equal('Xfoo1', luaeval('vim.buffer().name')) ++ call assert_equal('Xfoo1', bufname('%')) ++ ++ lua bn, bp = nil, nil ++ %bwipe! ++ endfunc ++ ++ " Test vim.buffer():isvalid() ++ func Test_buffer_isvalid() ++ new Xfoo ++ lua b = vim.buffer() ++ call assert_true(luaeval('b:isvalid()')) ++ ++ " FIXME: how to test the case when isvalid() returns v:false? ++ " isvalid() gives errors when the buffer is wiped. Is it a bug? ++ ++ lua b = nil + bwipe! ++ endfunc ++ ++ func Test_list() ++ call assert_equal([], luaeval('vim.list()')) ++ ++ " Same example as in :help lua-vim. ++ " FIXME: test is disabled because it does not work. ++ " See https://github.com/vim/vim/issues/3086 ++ " lua t = {math.pi, false, say = 'hi'} ++ " call assert_equal([3.141593, 0], luaeval('vim.list(t)')) ++ ++ let l = [] ++ lua l = vim.eval('l') ++ lua l:add(123) ++ lua l:add('abc') ++ lua l:add(true) ++ lua l:add(false) ++ lua l:add(vim.eval("[1, 2, 3]")) ++ lua l:add(vim.eval("{'a':1, 'b':2, 'c':3}")) ++ call assert_equal([123.0, 'abc', v:true, v:false, [1, 2, 3], {'a': 1, 'b': 2, 'c': 3}], l) ++ call assert_equal(6.0, luaeval('#l')) ++ call assert_match('^list: 0x\x\+$', luaeval('tostring(l)')) ++ ++ lua l[0] = 124 ++ lua l[4] = nil ++ lua l:insert('first') ++ lua l:insert('xx', 3) ++ call assert_equal(['first', 124.0, 'abc', 'xx', v:true, v:false, {'a': 1, 'b': 2, 'c': 3}], l) ++ ++ lua l = nil ++ endfunc ++ ++ " Test l() i.e. iterator on list ++ func Test_list_iter() ++ lua l = vim.list():add('foo'):add('bar') ++ lua str = '' ++ lua for v in l() do str = str .. v end ++ call assert_equal('foobar', luaeval('str')) ++ ++ lua str, v, l = nil, nil, nil ++ endfunc ++ ++ func Test_recursive_list() ++ lua l = vim.list():add(1):add(2) ++ lua l = l:add(l) ++ ++ call assert_equal(1.0, luaeval('l[0]')) ++ call assert_equal(2.0, luaeval('l[1]')) ++ ++ call assert_equal(1.0, luaeval('l[2][0]')) ++ call assert_equal(2.0, luaeval('l[2][1]')) ++ ++ call assert_equal(1.0, luaeval('l[2][2][0]')) ++ call assert_equal(2.0, luaeval('l[2][2][1]')) ++ ++ call assert_equal('[1.0, 2.0, [...]]', string(luaeval('l'))) ++ ++ call assert_match('^list: 0x\x\+$', luaeval('tostring(l)')) ++ call assert_equal(luaeval('tostring(l)'), luaeval('tostring(l[2])')) ++ ++ call assert_equal(luaeval('l'), luaeval('l[2]')) ++ call assert_equal(luaeval('l'), luaeval('l[2][2]')) ++ ++ lua l = nil ++ endfunc ++ ++ func Test_dict() ++ call assert_equal({}, luaeval('vim.dict()')) ++ ++ " Same example as in :help lua-vim. ++ " FIXME: test is disabled because it does not work. ++ " See https://github.com/vim/vim/issues/3086 ++ " lua t = {math.pi, false, say = 'hi'} ++ " call assert_equal({'say' : 'hi'}, luaeval('vim.dict(t)')) ++ ++ let d = {} ++ lua d = vim.eval('d') ++ lua d[0] = 123 ++ lua d[1] = "abc" ++ lua d[2] = true ++ lua d[3] = false ++ lua d[4] = vim.eval("[1, 2, 3]") ++ lua d[5] = vim.eval("{'a':1, 'b':2, 'c':3}") ++ call assert_equal({'0':123.0, '1':'abc', '2':v:true, '3':v:false, '4': [1, 2, 3], '5': {'a':1, 'b':2, 'c':3}}, d) ++ call assert_equal(6.0, luaeval('#d')) ++ call assert_match('^dict: 0x\x\+$', luaeval('tostring(d)')) ++ ++ call assert_equal('abc', luaeval('d[1]')) ++ ++ lua d[0] = 124 ++ lua d[4] = nil ++ call assert_equal({'0':124.0, '1':'abc', '2':v:true, '3':v:false, '5': {'a':1, 'b':2, 'c':3}}, d) ++ ++ lua d = nil ++ endfunc ++ ++ " Test d() i.e. iterator on dictionary ++ func Test_dict_iter() ++ let d = {'a': 1, 'b':2} ++ lua d = vim.eval('d') ++ lua str = '' ++ lua for k,v in d() do str = str .. k ..':' .. v .. ',' end ++ call assert_equal('a:1,b:2,', luaeval('str')) ++ ++ lua str, k, v, d = nil, nil, nil, nil ++ endfunc ++ ++ " Test vim.type() ++ func Test_type() ++ " The following values are identical to Lua's type function. ++ call assert_equal('string', luaeval('vim.type("foo")')) ++ call assert_equal('number', luaeval('vim.type(1)')) ++ call assert_equal('number', luaeval('vim.type(1.2)')) ++ call assert_equal('function', luaeval('vim.type(print)')) ++ call assert_equal('table', luaeval('vim.type({})')) ++ call assert_equal('boolean', luaeval('vim.type(true)')) ++ call assert_equal('boolean', luaeval('vim.type(false)')) ++ call assert_equal('nil', luaeval('vim.type(nil)')) ++ ++ " The following values are specific to Vim. ++ call assert_equal('window', luaeval('vim.type(vim.window())')) ++ call assert_equal('buffer', luaeval('vim.type(vim.buffer())')) ++ call assert_equal('list', luaeval('vim.type(vim.list())')) ++ call assert_equal('dict', luaeval('vim.type(vim.dict())')) ++ endfunc ++ ++ " Test vim.open() ++ func Test_open() ++ call assert_notmatch('XOpen', execute('ls')) ++ ++ " Open a buffer XOpen1, but do not jump to it. ++ lua b = vim.open('XOpen1') ++ call assert_equal('XOpen1', luaeval('b.name')) ++ call assert_equal('', bufname('%')) ++ ++ call assert_match('XOpen1', execute('ls')) ++ call assert_notequal('XOpen2', bufname('%')) ++ ++ " Open a buffer XOpen2 and jump to it. ++ lua b = vim.open('XOpen2')() ++ call assert_equal('XOpen2', luaeval('b.name')) ++ call assert_equal('XOpen2', bufname('%')) ++ ++ lua b = nil ++ %bwipe! ++ endfunc ++ ++ " Test vim.line() ++ func Test_line() ++ new ++ call setline(1, ['first line', 'second line']) ++ 1 ++ call assert_equal('first line', luaeval('vim.line()')) ++ 2 ++ call assert_equal('second line', luaeval('vim.line()')) ++ bwipe! ++ endfunc ++ ++ " Test vim.beep() ++ func Test_beep() ++ call assert_beeps('lua vim.beep()') ++ endfunc ++ ++ " Test errors in luaeval() ++ func Test_luaeval_error() ++ " Compile error ++ call assert_fails("call luaeval('-nil')", ++ \ '[string "luaeval"]:1: attempt to perform arithmetic on a nil value') ++ call assert_fails("call luaeval(']')", ++ \ "[string \"luaeval\"]:1: unexpected symbol near ']'") ++ endfunc ++ ++ " Test :luafile foo.lua ++ func Test_luafile() ++ call delete('Xlua_file') ++ call writefile(["str = 'hello'", "num = 123.0" ], 'Xlua_file') ++ call setfperm('Xlua_file', 'r-xr-xr-x') ++ ++ luafile Xlua_file ++ call assert_equal('hello', luaeval('str')) ++ call assert_equal(123.0, luaeval('num')) ++ ++ lua str, num = nil, nil ++ call delete('Xlua_file') ++ endfunc ++ ++ " Test :luafile % ++ func Test_luafile_percent() ++ new Xlua_file ++ append ++ str, num = 'foo', 321.0 ++ print(string.format('str=%s, num=%d', str, num)) ++ . ++ w! ++ luafile % ++ let msg = split(execute('message'), "\n")[-1] ++ call assert_equal('str=foo, num=321', msg) ++ ++ lua str, num = nil, nil ++ call delete('Xlua_file') + bwipe! + endfunc +*** ../vim-8.1.0131/src/version.c 2018-06-30 21:18:10.486300954 +0200 +--- src/version.c 2018-06-30 21:22:03.417340889 +0200 +*************** +*** 791,792 **** +--- 791,794 ---- + { /* Add new patch number below this line */ ++ /**/ ++ 132, + /**/ + +-- +hundred-and-one symptoms of being an internet addict: +155. You forget to eat because you're too busy surfing the net. + + /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\ +/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\ +\\\ an exciting new programming language -- http://www.Zimbu.org /// + \\\ help me help AIDS victims -- http://ICCF-Holland.org /// |