Update vim

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