To: vim_dev@googlegroups.com Subject: Patch 8.1.0132 Fcc: outbox From: Bram Moolenaar 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 ///