path: root/data/vim/patches/8.1.0132

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    ///